implab/implabjs-di Commit - r14:3f8a82c8ce73

WIP lifetime, service descriptors

cin -

r14:3f8a82c8ce73 default

parent child

Context file:

r14:3f8a82c8ce73

Collapse all files

src/main/ts/ActivationContext.ts +13 -1

             import { ActivationError } from "./ActivationError";
-            import { Descriptor, ILifetime, IActivationContext, DescriptorMap, ILifetimeManager } from "./interfaces";
+            import { Descriptor, ILifetime, IActivationContext, DescriptorMap, ILifetimeManager, ILifetimeSlot } from "./interfaces";
             import { argumentNotNull, prototype } from "./traits";
             export interface ActivationContextInfo {
                     this._services[name] = service;
                 }
+                ownerSlot<T>(slotId: string | number): ILifetimeSlot<T> {
+                    return this._lifetimeManagers[this._service.level].slot(slotId);
+                }
+                containerSlot<T>(slotId: string | number): ILifetimeSlot<T> {
+                    return this._lifetimeManagers[this._lifetimeManagers.length - 1].slot(slotId);
+                }
+                contextSlot<T>(slotId: string | number): ILifetimeSlot<T> {
+                }
                 createLifetime<T>(): ILifetime<T> {
                     const id = nextId++;
                     return {

src/main/ts/ContainerBuilder.ts +2 -7

             /**
              * Container builder used to prepare service descriptors and create a IoC container
              */
-            export class ContainerBuilder<S extends ContainerServicesConstraint<S>, U extends keyof S> implements
+            export class ContainerBuilder<S, U extends keyof S> implements
                 IContainerBuilder<S, U> {
                 private _pending = 1;
                 private readonly _lifetime: ILifetime<IDestroyable>;
                 constructor(parentServices: DescriptorMap<S> | null = null, lifetime?: ILifetime<IDestroyable>) {
-                    this._services = {
+                    this._services = { ...parentServices }; // create a copy
-                        ...parentServices,
-                        container: containerSelfDescriptor as any,
-                        childContainer: containerSelfDescriptor as any
-                    };
-                    this._lifetimeManager = new LifetimeManager();
                     this._lifetime = lifetime ?? emptyLifetime();
                 }
                 createServiceBuilder<K extends U>(name: K):

src/main/ts/DescriptorBuilder.ts +4 -8

             import { BuildDescriptorFn, IDescriptorBuilder, DepsMap, Resolve, DescriptorMap } from "./interfaces";
             import { Descriptor, ILifetime, ActivationType } from "./interfaces";
             import { DescriptorImpl } from "./DescriptorImpl";
-            import { contextLifetime, emptyLifetime, hierarchyLifetime, LifetimeManager, singletonLifetime } from "./LifetimeManager";
+            import { containerLifetime, contextLifetime, emptyLifetime, hierarchyLifetime, LifetimeManager, singletonLifetime } from "./LifetimeManager";
             import { each, isPromise, isString, key, oid } from "./traits";
             /**
              * @template {T} Тип сервиса
              */
             export class DescriptorBuilder<S, T, R, U extends keyof S> implements IDescriptorBuilder<S, T, R, U> {
-                private readonly _lifetimeManager: LifetimeManager;
                 private readonly _cb: (d: Descriptor<S, T>) => void;
                 private readonly _eb: (err: unknown) => void;
                 private readonly _refs: DepsMap<R>;
-                private _lifetime = emptyLifetime<T>();
+                private _lifetime: ILifetime<T> = emptyLifetime<T>();
                 private _overrides: DescriptorMap<S>;
                  * Creates new DescriptorBuilder. Accepts a lifetime container for resolving "container"
                  * lifetime.
                  *
-                 * @param lifetimeManager The lifetime container is the container where the service is to be registered.
                  * @param cb The callback to receive the built service descriptor
                  * @param eb The callback to receive the error due
                  */
-                constructor(lifetimeManager: LifetimeManager, cb: (d: Descriptor<S, T>) => void, eb: (err: unknown) => void) {
+                constructor(cb: (d: Descriptor<S, T>) => void, eb: (err: unknown) => void) {
-                    this._lifetimeManager = lifetimeManager;
                     this._cb = cb;
                     this._eb = eb;
                     this._overrides = {};
                         if (builder) {
                             this._defer();
                             const d = new DescriptorBuilder<S, NonNullable<S[K]>, object, U>(
-                                this._lifetimeManager,
                                 result => {
                                     this._overrides[nameOrServices] = result;
                                     this._complete();
                 _resolveLifetime<T>(activation: ActivationType, typeId?: string | object): ILifetime<T> {
                     switch (activation) {
                         case "container":
-                            return this._lifetimeManager.create();
+                            return containerLifetime();
                         case "hierarchy":
                             return hierarchyLifetime();
                         case "context":

src/main/ts/DescriptorImpl.ts +7 -6

             import { each, key } from "./traits";
             export interface DescriptorImplArgs<S, T> {
-                lifetime: ILifetime<T>;
-                factory: (refs: Record<key, unknown>) => NonNullable<T>;
+                readonly lifetime: ILifetime<NonNullable<T>>;
+                readonly factory: (refs: Record<key, unknown>) => NonNullable<T>;
-                cleanup?: (item: NonNullable<T>) => void;
+                readonly cleanup?: (item: NonNullable<T>) => void;
-                overrides?: DescriptorMap<S>;
+                readonly overrides?: DescriptorMap<S>;
-                dependencies?: DepsMap<S>;
+                readonly dependencies?: DepsMap<S>;
             }
             export const containerSelfDescriptor = <S>() => Object.freeze({
                 private readonly _overrides?: DescriptorMap<S>;
-                private readonly _lifetime: ILifetime<T>;
+                private readonly _lifetime: ILifetime<NonNullable<T>>;
                 private readonly _factory: (refs: Record<key, unknown>) => NonNullable<T>;

src/main/ts/interfaces.ts +1 -5

             export interface Descriptor<S, T> {
-                /** The level of the service in the containers chain.
-                */
-                readonly level: number;
                 /** This flags indicates that this registration can be replaced or overridden. */
                 readonly configurable?: boolean;
              * Интерфейс для управления жизнью экземпляра объекта. Каждая регистрация имеет
              * свой собственный объект `ILifetime`, который создается при первой активации
              */
-            export type ILifetime<T> = (context: ILifetimeContext) => ILifetimeSlot<NonNullable<T>>;
+            export type ILifetime<T> = (context: ILifetimeContext) => ILifetimeSlot<T>;
             export interface ILifetimeSlot<T> {
                 readonly has: () => boolean;

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages