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) {
+                constructor(services: DescriptorMap<S>, lifetimeManagers: ILifetimeManager[], destroyed: () => void) {
-                    this._services = {
+                    this._services = services;
-                        ...services,
-                        container: {
-                            configurable: false,
-                            activate: () => this
-                        },
-                        childContainer: {
-                            configurable: false,
-                            activate: () => this.createChildBuilder(),
-                    };
                     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) :
+                cleanup ? () => cleanup(value) : _destroy(value);
-                    isDestroyable(value) ? () => _destroy(value) :
-                        noop;
             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>> = {
+            export type ContainerProvided<S, U extends keyof S = keyof S> = {
-                container: ServiceLocator<ContainerServices<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>> = {
+            export type ContainerServices<S> = {
-                [k in keyof S | ContainerKeys]:
+                [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