implab/implabjs-di Commit - r13:dc3d64c43573

WIP service descriptors

cin -

r13:dc3d64c43573 default

parent child

Context file:

r13:dc3d64c43573

Collapse all files

src/main/ts/ActivationContext.ts +3 -7

                  private readonly _service: Descriptor<S, unknown>;
-                 private readonly _containerLifetimeManager: ILifetimeManager;
+                 private readonly _lifetimeManagers: ILifetimeManager[];
                  private readonly _parent: ActivationContext<S> | undefined;
                   * @param service the service to activate, this parameter is used for the
                   *  debug purpose.
                   */
-                 constructor(containerLifetimeManager: ILifetimeManager, services: DescriptorMap<S>, name: string, service: Descriptor<S, unknown>, cache = {}) {
+                 constructor(lifetimeManagers: ILifetimeManager[], services: DescriptorMap<S>, name: string, service: Descriptor<S, unknown>, cache = {}) {
                      this._name = name;
                      this._service = service;
                      this._cache = cache;
                      this._services = services;
-                     this._containerLifetimeManager = containerLifetimeManager;
+                     this._lifetimeManagers = lifetimeManagers;
                  }
                  /** the name of the current resolving dependency */
                      return this._name;
                  }
-                 createContainerLifetime<T>() {
-                     return this._containerLifetimeManager.create<T>();
+                 }
                  resolve<K extends keyof S>(name: K): NonNullable<S[K]>;
                  resolve<K extends keyof S, T>(name: K, def: T): NonNullable<S[K]> | T;
                  resolve<K extends keyof S, T>(name: K, def?: T): NonNullable<S[K]> | T | undefined {

src/main/ts/Container.ts +6 -16

              import { ActivationContext } from "./ActivationContext";
              import { ActivationError } from "./ActivationError";
              import { ContainerBuilder } from "./ContainerBuilder";
+             import { LifetimeManager } from "./LifetimeManager";
              import { DescriptorMap, IContainerBuilder, IDestroyable, ILifetimeManager, ServiceLocator } from "./interfaces";
              export class Container<S> implements ServiceLocator<S>, IDestroyable {
                  private readonly _services: DescriptorMap<S>;
-                 private readonly _lifetimeManager: ILifetimeManager;
+                 private readonly _lifetimeManagers: ILifetimeManager[];
                  private _disposed: boolean;
                  private readonly _onDestroyed: () => void;
-                 constructor(services: DescriptorMap<S>, lifetimeManager: ILifetimeManager, destroyed: () => void) {
-                     this._services = {
-                         ...services,
-                         container: {
-                             configurable: false,
-                             activate: () => this
-                         },
-                         childContainer: {
-                             configurable: false,
-                             activate: () => this.createChildBuilder(),
+                         }
-                     };
+                 constructor(services: DescriptorMap<S>, lifetimeManagers: ILifetimeManager[], destroyed: () => void) {
+                     this._services = services;
                      this._disposed = false;
-                     this._lifetimeManager = lifetimeManager;
+                     this._lifetimeManagers = lifetimeManagers.concat(new LifetimeManager());
                      this._onDestroyed = destroyed;
                  }
                          else
                              throw new Error(`Service '${String(name)}' isn't found`);
                      } else {
-                         const context = new ActivationContext(this._lifetimeManager, this._services, String(name), d);
+                         const context = new ActivationContext(this._lifetimeManagers, this._services, String(name), d);
                          try {
                              return d.activate(context);
                          } catch (error) {

src/main/ts/ContainerBuilder.ts +9 -4

              import { Container } from "./Container";
              import { DescriptorBuilder } from "./DescriptorBuilder";
-             import { Descriptor, IContainerBuilder, IDescriptorBuilder, DescriptorMap, ServiceLocator, ILifetime, IDestroyable } from "./interfaces";
+             import { containerSelfDescriptor } from "./DescriptorImpl";
+             import { Descriptor, IContainerBuilder, IDescriptorBuilder, DescriptorMap, ServiceLocator, ILifetime, IDestroyable, ContainerServices, ContainerServicesConstraint } from "./interfaces";
              import { emptyLifetime, LifetimeManager } from "./LifetimeManager";
              import { isDestroyable, prototype } from "./traits";
              /**
               * Container builder used to prepare service descriptors and create a IoC container
               */
-             export class ContainerBuilder<S, U extends keyof S> implements
+             export class ContainerBuilder<S extends ContainerServicesConstraint<S>, U extends keyof S> implements
                  IContainerBuilder<S, U> {
                  private _pending = 1;
-                 private readonly _services: DescriptorMap<S>;
+                 private readonly _services: DescriptorMap<ContainerServices<S>>;
                  private readonly _lifetimeManager = new LifetimeManager();
                  private readonly _lifetime: ILifetime<IDestroyable>;
                  constructor(parentServices: DescriptorMap<S> | null = null, lifetime?: ILifetime<IDestroyable>) {
-                     this._services = prototype(parentServices);
+                     this._services = {
+                         ...parentServices,
+                         container: containerSelfDescriptor as any,
+                         childContainer: containerSelfDescriptor as any
+                     };
                      this._lifetimeManager = new LifetimeManager();
                      this._lifetime = lifetime ?? emptyLifetime();
                  }

src/main/ts/DescriptorImpl.ts +7 0

                  dependencies?: DepsMap<S>;
              }
+             export const containerSelfDescriptor = <S>() => Object.freeze({
+                 level: 0,
+                 activate(context: IActivationContext<S>) {
+                     return context.createChildContainer();
+                 }
+             });
              export class DescriptorImpl<S, T> implements Descriptor<S, T> {

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

                  cleanup: noop,
              });
-             const _destroy = (item: IDestroyable) => item.destroy();
+             const _destroy = (item: unknown) => () => isDestroyable(item) && item.destroy() ;
              const _makeCleanup = <T>(value: T, cleanup?: (item: T) => void) =>
-                 cleanup ? () => cleanup(value) :
-                     isDestroyable(value) ? () => _destroy(value) :
-                         noop;
+                 cleanup ? () => cleanup(value) : _destroy(value);
              const newSlot = <T>(put: (item: ILifetimeSlot<T>) => void, remove: () => void): ILifetimeSlot<T> => ({
                  has: () => false,
              let nextId = 1;
+             export const containerLifetime = <T>() => {
+                 const slotId = nextId ++;
+                 return (context: ILifetimeContext) =>
+                     context.ownerSlot<T>(slotId);
+             };
              export const hierarchyLifetime = <T>() => {
                  const slotId = nextId++;
                  return (context: ILifetimeContext) =>

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

+             import { ContainerBuilder } from "./ContainerBuilder";
              import { key } from "./traits";
              export interface IDestroyable {
              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;
              /** The context used to initialize lifetime instance {@linkcode ILifetime} */
              export interface ILifetimeContext {
+                 ownerSlot<T>(slotId: string | number): ILifetimeSlot<T>;
                  contextSlot<T>(slotId: string | number): ILifetimeSlot<T>;
                  containerSlot<T>(slotId: string | number): ILifetimeSlot<T>;
                  register<K extends keyof S>(name: K, service: DescriptorMap<S>[K]): void;
                  fail(error: unknown): never;
+                 selfContainer(): ServiceLocator<S>;
+                 createChildContainer(): IContainerBuilder<S, Exclude<keyof S, ContainerKeys>>;
              }
              /**
              type ContainerKeys = keyof ContainerProvided<object>;
-             export type ContainerProvided<S extends ContainerServicesConstraint<S>> = {
-                 container: ServiceLocator<ContainerServices<S>>;
+             export type ContainerProvided<S, U extends keyof S = keyof S> = {
+                 container: ServiceLocator<ContainerProvided<S>>;
-                 childContainer: IContainerBuilder<ContainerServices<S>, Exclude<keyof S, ContainerKeys>>;
+                 childContainer: IContainerBuilder<S, U>;
              };
               *
               * Сервисы, предоставляемые контейнером не могут быть null или undefined.
               */
-             export type ContainerServices<S extends ContainerServicesConstraint<S>> = {
-                 [k in keyof S | ContainerKeys]:
+             export type ContainerServices<S> = {
+                 [k in (keyof S) | ContainerKeys]:
                  k extends ContainerKeys ? ContainerProvided<S>[k] :
                  k extends keyof S ? S[k] : never
              };

src/test/ts/t/container.ts +3 -3

              import { describe, it } from "mocha";
              import { Container } from "../Container";
              import { ContainerBuilder } from "../ContainerBuilder";
-             import { ContainerServices, DepsMap, IContainerBuilder, Refs, Resolver } from "../interfaces";
+             import { ContainerServices, DepsMap, IContainerBuilder, Refs, Resolver, ServiceLocator } from "../interfaces";
              import { fluent } from "../traits";
              class Foo {
                  refs.default;
              }
-             declare const x: ContainerServices<Services>;
+             declare const x: ServiceLocator<ContainerServices<Services>>;
-             x.container.resolve("container");
+             x.resolve("container").resolve("container");
              mmap({

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