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 = {
-                         ...parentServices,
-                         container: containerSelfDescriptor as any,
-                         childContainer: containerSelfDescriptor as any
-                     };
-                     this._lifetimeManager = new LifetimeManager();
+                     this._services = { ...parentServices }; // create a copy
                      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) {
-                     this._lifetimeManager = lifetimeManager;
+                 constructor(cb: (d: Descriptor<S, T>) => void, eb: (err: unknown) => void) {
                      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 +11 -10

              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>;
                      if (has())
                          return get();
                      initialize();
                      if (this._overrides)
                      try {
                          // call the factory method
-                         const instance = (0,this._factory)(refs);
+                         const instance = (0, this._factory)(refs);
                          // store the instance
                          store(instance, this._cleanup);
                          return instance;
-                     } catch(err) {
+                     } catch (err) {
                          context.fail(err);
                      }
                  }

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