implab/implabjs-di Commit - r15:3985e8405319

sync

cin -

r15:3985e8405319 tip default

parent child

Context file:

r15:3985e8405319

Collapse all files

src/main/ts/LifetimeSlot.ts created 644 +61 0

@@ -0,0 +1,61
	1	import { ILifetimeSlot } from "../typings/interfaces";
	2	import { isDestroyable } from "./traits";
	3
	4	const _destroy = (item: unknown) => () => isDestroyable(item) && item.destroy();
	5
	6	enum State {
	7	New,
	8
	9	Initialized,
	10
	11	Destroyed
	12	}
	13
	14	export class LifetimeSlot<T> implements ILifetimeSlot<T> {
	15	private _value: NonNullable<T> \| undefined = undefined;
	16
	17	private _state = State.New;
	18
	19	cleanup: () => void;
	20
	21	readonly remove: () => void;
	22
	23	constructor(remove: () => void) {
	24	this.remove = this._finalizer(remove);
	25	this.cleanup = this._finalizer(() => { });
	26	}
	27
	28	has(): boolean {
	29	this._assertNotDisposed();
	30	return this._value !== undefined;
	31	}
	32	get(): NonNullable<T> {
	33	this._assertNotDisposed();
	34	if (this._value === undefined)
	35	throw new Error("The slot doesn't have a value");
	36	return this._value;
	37	}
	38
	39	initialize(): boolean {
	40	return this._state === State.New ?
	41	(this._state = State.Initialized, true) :
	42	false;
	43	}
	44
	45	store(item: NonNullable<T>, cleanup: ((item: NonNullable<T>) => void) \| undefined = _destroy): void {
	46	this._assertNotDisposed();
	47	this._value = item;
	48	if (cleanup)
	49	this.cleanup = this._finalizer(() => cleanup(item));
	50	}
	51
	52	private _finalizer(cb: () => void) {
	53	return () => this._state !== State.Destroyed ? (this._state = State.Destroyed, cb()) : void (0);
	54	}
	55
	56	private _assertNotDisposed() {
	57	if (this._state === State.Destroyed)
	58	throw new Error("The slot is disposed");
	59	}
	60
	61	} No newline at end of file

build.gradle +2 -3

             plugins {
               id "org.implab.gradle-typescript" version "1.3.4"
               id "org.implab.gradle-mercurial" version "1.0.1"
             }
             if (!symbols in ['local', 'pack', 'none'])
                 throw new Exception("The symbols property value is invalid: $symbols");
             if (!flavour in ['browser', 'node'])
                 throw new Exception("The flavour property value is invalid: $flavour");
             ext {
                 packageName = flavour == 'browser' ? "@$npmScope/$name-amd" : "@$npmScope/$name"
                 lint = project.hasProperty('lint') ? project.lint ?: true : false
             }
             mercurial {
                 preReleasePolicy { it
                     .addPatch(versionDistance)
                     .withPreRelease('dev')
                     .withMeta(changeset)
                 }
                 applyVersioningPolicy()
             }
             typescript {
                 compilerOptions {
                     types = []
                     declaration = true
                     experimentalDecorators = true
                     strict = true
-                    module = "commonjs"
+                    module = "nodenext"
-                    target = "es5"
+                    target = "ESNext"
-                    lib = ["es2015", "dom", "scripthost"]
                 }
                 tscCmd = "$projectDir/node_modules/.bin/tsc"
                 tsLintCmd = "$projectDir/node_modules/.bin/tslint"
             	esLintCmd = "$projectDir/node_modules/.bin/eslint"
             }
             tasks.matching{ it.name =~ /^lint/ }.configureEach {
                 onlyIf { lint }
             }
             if (symbols == 'local') {
                 tasks.matching{ it.name =~ /^configureTs/ }.configureEach {
                     compilerOptions {
                         sourceRoot = "file://" + it.rootDir
                     }
                 }
             }
             task packSources {
             }
             printVersion {
                 doLast {
                     println "packageName: $packageName";
                     println "flavour: $flavour";
                     println "target: $typescript.compilerOptions.target";
                     println "module: $typescript.compilerOptions.module";
                     println "lint: $lint";
                     println "symbols: $symbols";
                 }
             }
             test {
                 commandLine "npx", "mocha", "${->typescript.testDir.get()}";
             }

src/main/ts/ActivationContext.ts +52 -94

@@ -1,153 +1,111
1	import { ActivationError } from "./ActivationError";	1	import { ActivationError, ActivationItem } from "./ActivationError";
2	import { ~~Descriptor~~, ~~ILifetime~~, IActivationContext, DescriptorMap, ILifetimeManager, ILifetimeSlot } from "./interfaces";	2	import { IActivationContext, DescriptorMap, ILifetimeManager, ILifetimeSlot, ServiceLocator, IContainerBuilder } from "../typings/interfaces";
3	import { argumentNotNull, prototype } from "./traits";	3	import { argumentNotNull, each, prototype } from "./traits";
4		4	import { LifetimeManager } from "./LifetimeManager";
5	export interface ActivationContextInfo {	5	import { ContainerBuilder } from "./ContainerBuilder";
6	name: string;
7
8	service: string;
9
10	}
11
12	let nextId = 1;
13		6
14	/** This object is created once per `Container.resolve` method call and used to	7	/** This object is created once per `Container.resolve` method call and used to
15	* cache dependencies and to track created instances. The activation context	8	* cache dependencies and to track created instances. The activation context
16	* tracks services with `context` activation type.	9	* tracks services with `context` activation type.
17	*	10	*
18	* @template S The service map used in the activation context, services from	11	* @template S The service map used in the activation context, services from
19	* this map are available to resolution.	12	* this map are available to resolution.
20	* @template U A set of keys from the service map which can be overridden in	13	* @template U A set of keys from the service map which can be overridden in
21	* this activation context.	14	* this activation context.
22	*/	15	*/
23	export class ActivationContext<S> implements IActivationContext<S> {	16	export class ActivationContext<S> implements IActivationContext<S> {
24	private readonly _cache: Record<string, unknown>;
25		17
26	private readonly _~~services~~: ~~DescriptorMap~~<S>;	18	private readonly _container: ServiceLocator<S>;
27
28	private readonly _name: string;
29		19
30	private readonly _service: Descriptor<S, unknown>;	20	private readonly _contextScope: ILifetimeManager;
31		21
32	private readonly _lifetimeManagers: ILifetimeManager[];	22	private _services: DescriptorMap<S>;
33		23
34	private readonly _parent: ActivationContext<S> \| undefined;	24	private readonly _scope: ILifetimeManager[];
35		25
36	/** Creates a new activation context with the specified parameters.	26	/** Creates a new activation context with the specified parameters.
37	* @param containerLifetimeManager the container which starts the activation process	27	* @param containerLifetimeManager the container which starts the activation process
38	* @param services the initial service registrations	28	* @param services the initial service registrations
39	* @param name the name of the service being activated, this parameter is	29	* @param name the name of the service being activated, this parameter is
40	* used for the debug purpose.	30	* used for the debug purpose.
41	* @param service the service to activate, this parameter is used for the	31	* @param service the service to activate, this parameter is used for the
42	* debug purpose.	32	* debug purpose.
43	*/	33	*/
44	constructor(lifetimeManagers: ILifetimeManager[], services: DescriptorMap<S>, name: string, service: Descriptor<S, unknown>, cache = {}) {	34	constructor(container: ServiceLocator<S>, scope: ILifetimeManager[], services: DescriptorMap<S>, contextScope: ILifetimeManager = new LifetimeManager()) {
45	this._~~name~~ = ~~name~~;	35	this._container = container;
46	this._~~servic~~e = ~~servic~~e;	36	this._contextScope = contextScope;
47	this._cache = cache;
48	this._services = services;	37	this._services = services;
49	this._lifetimeManagers = lifetimeManagers;	38	this._scope = scope;
50	}
51
52	/** the name of the current resolving dependency */
53	getName() {
54	return this._name;
55	}	39	}
56		40
57	resolve<K extends keyof S>(name: K): NonNullable<S[K]>;	41	resolve<K extends keyof S>(name: K, stack: ActivationItem[]): NonNullable<S[K]>;
58	resolve<K extends keyof S, T>(name: K, def: T): NonNullable<S[K]> \| T;	42	resolve<K extends keyof S, T>(name: K, stack: ActivationItem[], def: T): NonNullable<S[K]> \| T;
59	resolve<K extends keyof S, T>(name: K, def?: T): NonNullable<S[K]> \| T \| undefined {	43	resolve<K extends keyof S, T>(name: K, stack: ActivationItem[], def?: T): NonNullable<S[K]> \| T \| undefined {
60	const d = this._services[name];	44	const service = this._services[name];
61		45
62	if (d !== undefined) {	46	if (service !== undefined) {
63	return ~~this~~.activate(d, ~~name~~.~~toString());~~	47	return service.activate(
		48	this,
		49	stack.concat({
		50	name: name.toString(),
		51	descriptor: service.toString()
		52	})
		53	);
64	} else {	54	} else {
65	if (arguments.length > 1)	55	if (arguments.length > 2)
66	return def;	56	return def;
67	else	57	else
68	throw new Error(`Service ${~~String~~(~~name~~)} not found`);	58	throw new Error("Service not found");
69	}	59	}
70	}	60	}
71		61
72	/**	62	/**
73	* registers services local to the the activation context	63	* registers services local to the the activation context
74	*	64	*
75	* @name{string} the name of the service	65	* @name{string} the name of the service
76	* @service{string} the service descriptor to register	66	* @service{string} the service descriptor to register
77	*/	67	*/
78	register<K extends keyof S>(name: K, service: DescriptorMap<S>[K]) {	68	private _register<K extends keyof S>(name: K, service: DescriptorMap<S>[K]) {
79	argumentNotNull(name, "name");	69	argumentNotNull(name, "name");
80		70
81	const d = this._services[name];	71	const d = this._services[name];
82	if (d !== undefined && !d.configurable)	72	if (d !== undefined && !d.configurable)
83	throw new Error(`Service ${String(name)} can't be overridden`);	73	throw new Error(`Service ${String(name)} can't be overridden`);
84		74
85	this._services[name] = service;	75	this._services[name] = service;
86	}	76	}
87		77
88	~~owner~~Slot<T>(slotId: string \| number): ILifetimeSlot<T> {	78	scopeSlot<T>(level: number, slotId: string \| number): ILifetimeSlot<T> {
89	return this._lifetimeManagers[this._service.level].slot(slotId);	79	if (level < 0 \|\| level >= this._scope.length)
		80	throw new Error("The scope level is out of range");
		81	return this._scope[level].slot(slotId);
90	}	82	}
91		83
92	~~container~~Slot<T>(slotId: string \| number): ILifetimeSlot<T> {	84	hierarchySlot<T>(slotId: string \| number): ILifetimeSlot<T> {
93	return this._~~lifetimeManagers~~[this._~~lifetimeManagers~~.length - 1].slot(slotId);	85	return this._scope[this._scope.length - 1].slot(slotId);
		86	}
		87
		88	selfContainer(): ServiceLocator<S> {
		89	return this._container;
		90	}
		91
		92	createChildContainer(): IContainerBuilder<S, keyof S> {
		93	return new ContainerBuilder(this._services, this._scope);
94	}	94	}
95		95
96	contextSlot<T>(slotId: string \| number): ILifetimeSlot<T> {	96	contextSlot<T>(slotId: string \| number): ILifetimeSlot<T> {
97		97	return this._contextScope.slot(slotId);
98	}
99
100	createLifetime<T>(): ILifetime<T> {
101	const id = nextId++;
102	return {
103	initialize() { },
104	has: () => id in this._cache,
105	get: () => {
106	const v = this._cache[id] as T;
107	if (v === undefined \|\| v === null)
108	throw new Error("The value isn't present in the activation context");
109	return v;
110	},
111	store: item => {
112	this._cache[id] = item;
113	}
114	};
115	}	98	}
116		99
117	activate<T>(d: Descriptor<S, T>, name: string) {	100	withOverrides<X>(overrides: DescriptorMap<S>, action: () => X) {
118	// TODO: add logging	101	const services = this._services;
119	// if (trace.isLogEnabled())	102	this._services = prototype(this._services);
120	// trace.log("enter {0} {1}", name, d);	103	try {
121		104	each(overrides, (v, k) => this._register(k, v));
122	const ctx = new ActivationContext(	105	return action();
123	this._containerLifetimeManager,	106	} finally {
124	d.hasOverrides ? prototype(this._services) : this._services,	107	this._services = services;
125	~~name~~,	108	}
126	d,
127	this._cache
128	);
129
130	const v = d.activate(ctx);
131
132	// if (trace.isLogEnabled())
133	// trace.log(`leave ${name}`);
134
135	return v;
136	}
137
138	getStack(): ActivationContextInfo[] {
139	const stack = [{
140	name: this._name,
141	service: this._service.toString()
142	}];
143
144	return this._parent ?
145	stack.concat(this._parent.getStack()) :
146	stack;
147	}
148
149	fail(innerException: unknown): never {
150	throw new ActivationError(this._name, this.getStack(), innerException);
151	}	109	}
152		110
153	}	111	}

src/main/ts/ActivationError.ts +17 -20

             export interface ActivationItem {
                 name: string;
-                service: string;
+                descriptor: string;
             }
             /**
              * Contains information about the error which occurred during service activation.
              *
              * Information about activation error includes original exception which has
              * occurred, the name of the service being activated and activation stack of
              * services.
              */
             export class ActivationError {
                 /**
                  * Stack of services being activating
                  */
                 readonly activationStack: ActivationItem[];
                 /**
-                 * The name of the failed service
-                 */
-                readonly service: string;
-                /**
                  * The exception which occurred during activation of the service
                  */
                 readonly innerException: unknown;
                 /**
                  * Error message
                  */
                 readonly message: string;
-                constructor(service: string, activationStack: ActivationItem[], innerException: unknown) {
+                constructor(message: string, activationStack: ActivationItem[], innerException?: unknown) {
-                    this.message = "Failed to activate the service";
+                    this.message = message;
                     this.activationStack = activationStack;
-                    this.service = service;
                     this.innerException = innerException;
                 }
                 toString() {
                     const parts = [this.message];
-                    if (this.service)
-                        parts.push(`when activating: ${String(this.service)}`);
+                    if (this.activationStack && this.activationStack.length) {
+                        const [{ name, descriptor }, ...before] = this.activationStack;
+                        parts.push(`when activating: ${name}, ${descriptor}`);
+                        if (before) {
+                            parts.push("at");
+                            parts.push.apply(
+                                null,
+                                before.map(({ name: name, descriptor: service }) => `    ${name} ${service}`)
+                            );
+                        }
+                    }
                     if (this.innerException)
                         parts.push(`caused by: ${String(this.innerException)}`);
-                    if (this.activationStack) {
-                        parts.push("at");
-                        parts.push.apply(null,
-                            this.activationStack
-                                .map(({ name, service }) => `    ${name} ${service}`)
-                        );
                     return parts.join("\n");
                 }
             }

src/main/ts/Container.ts +36 -29

             import { ActivationContext } from "./ActivationContext";
-            import { ActivationError } from "./ActivationError";
             import { ContainerBuilder } from "./ContainerBuilder";
-            import { LifetimeManager } from "./LifetimeManager";
+            import { LifetimeManager, emptySlot } from "./LifetimeManager";
-            import { DescriptorMap, IContainerBuilder, IDestroyable, ILifetimeManager, ServiceLocator } from "./interfaces";
+            import { DescriptorMap, IContainerBuilder, IDestroyable, ILifetimeManager, ILifetimeSlot, ServiceLocator } from "../typings/interfaces";
+            let nextId = 1;
             export class Container<S> implements ServiceLocator<S>, IDestroyable {
                 private readonly _services: DescriptorMap<S>;
-                private readonly _lifetimeManagers: ILifetimeManager[];
+                private readonly _scope: ILifetimeManager[];
+                private readonly _containerId = `container-${nextId++}`;
+                private readonly _slot: ILifetimeSlot<this>;
                 private _disposed: boolean;
-                private readonly _onDestroyed: () => void;
+                constructor(services: DescriptorMap<S>, parentScope: ILifetimeManager[]) {
-                constructor(services: DescriptorMap<S>, lifetimeManagers: ILifetimeManager[], destroyed: () => void) {
                     this._services = services;
                     this._disposed = false;
-                    this._lifetimeManagers = lifetimeManagers.concat(new LifetimeManager());
+                    this._scope = parentScope.concat(new LifetimeManager());
-                    this._onDestroyed = destroyed;
+                    // If this container is created inside the parent container scope,
+                    // allocated lifetime slot
+                    this._slot = parentScope.length ?
+                        parentScope[parentScope.length - 1].slot(this._containerId) :
+                        emptySlot<this>();
+                    // store the container reference in the lifetime slot
+                    this._slot.store(this);
                 }
                 private _assertNotDestroyed() {
                     if (this._disposed)
                         throw new Error("The container is destroyed");
                 }
                 createChildBuilder(): IContainerBuilder<S, keyof S> {
                     this._assertNotDestroyed();
-                    const lifetime = this._lifetimeManager.create<IDestroyable>();
+                    return new ContainerBuilder(this._services, this._scope);
-                    return new ContainerBuilder(this._services, lifetime);
                 }
                 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) {
                     this._assertNotDestroyed();
-                    const d = this._services[name];
+                    const context = new ActivationContext(this, this._scope, this._services);
-                    if (d === undefined) {
-                        if (arguments.length > 1)
+                    return arguments.length === 1 ?
-                            return def;
+                        context.resolve(name, []) :
-                        else
+                        context.resolve(name, [], def);
-                            throw new Error(`Service '${String(name)}' isn't found`);
-                    } else {
-                        const context = new ActivationContext(this._lifetimeManagers, this._services, String(name), d);
-                        try {
-                            return d.activate(context);
-                        } catch (error) {
-                            throw new ActivationError(name.toString(), context.getStack(), error);
                 }
                 destroy() {
                     if (this._disposed)
                         return;
                     this._disposed = true;
-                    this._lifetimeManager.destroy();
-                    (0,this._onDestroyed)();
+                    // destroy own scope
+                    this._scope[this._scope.length - 1].destroy();
+                    // release lifetime slot if the container is destroyed before the parent
+                    // container. If this container is destroyed during the parent container
+                    // cleanup procedure this call will have no effect.
+                    this._slot.remove();
                 }
             }

src/main/ts/ContainerBuilder.ts +10 -19

             import { Container } from "./Container";
             import { DescriptorBuilder } from "./DescriptorBuilder";
-            import { containerSelfDescriptor } from "./DescriptorImpl";
+            import { Descriptor, IContainerBuilder, IDescriptorBuilder, DescriptorMap, ServiceLocator, ILifetimeManager } from "../typings/interfaces";
-            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
                 IContainerBuilder<S, U> {
                 private _pending = 1;
-                private readonly _services: DescriptorMap<ContainerServices<S>>;
+                private readonly _services: DescriptorMap<S>;
-                private readonly _lifetimeManager = new LifetimeManager();
+                private readonly _scope: ILifetimeManager[];
-                private readonly _lifetime: ILifetime<IDestroyable>;
+                private readonly _level: number;
-                constructor(parentServices: DescriptorMap<S> | null = null, lifetime?: ILifetime<IDestroyable>) {
+                constructor(parentServices: DescriptorMap<S> | null, scope: ILifetimeManager[] = []) {
                     this._services = { ...parentServices }; // create a copy
-                    this._lifetime = lifetime ?? emptyLifetime();
+                    this._level = scope.length;
+                    this._scope = scope;
                 }
-                createServiceBuilder<K extends U>(name: K):
+                createServiceBuilder<K extends U>(name: K): IDescriptorBuilder<S, S[K], Record<never, never>, U> {
-                    IDescriptorBuilder<S, S[K], Record<never, never>, U> {
-                    return new DescriptorBuilder(this._lifetimeManager, this._register(name), this._fail);
+                    return new DescriptorBuilder(this._level, String(name), this._register(name), this._fail);
                 }
                 build(): ServiceLocator<S> {
                     this._assertBuilding();
                     if (!this._complete())
                         throw new Error("The configuration didn't complete.");
-                    const {remove, store} = this._lifetime(null);
+                    return new Container(this._services, this._scope);
-                    const container = new Container(this._services, this._lifetimeManager, remove);
-                    store(container);
-                    return container;
                 }
                 private readonly _register = <K extends U>(name: K) =>
                     (descriptor: Descriptor<S, S[K]>) => {
                         this._complete();
                         this._services[name] = descriptor;
                     };
                 private readonly _fail = (ex: unknown) => {
                     throw ex;
                 };
                 private _assertBuilding() {
                     if (!this._pending)
                         throw new Error("The descriptor builder is finalized");
                 }
                 private _complete() {
                     return !(--this._pending);
                 }
             }

src/main/ts/DescriptorBuilder.ts +15 -7

-            import { BuildDescriptorFn, IDescriptorBuilder, DepsMap, Resolve, DescriptorMap } from "./interfaces";
+            import { BuildDescriptorFn, IDescriptorBuilder, DepsMap, Resolve, DescriptorMap } from "../typings/interfaces";
-            import { Descriptor, ILifetime, ActivationType } from "./interfaces";
+            import { Descriptor, ILifetime, ActivationType } from "../typings/interfaces";
             import { DescriptorImpl } from "./DescriptorImpl";
-            import { containerLifetime, contextLifetime, emptyLifetime, hierarchyLifetime, LifetimeManager, singletonLifetime } from "./LifetimeManager";
+            import { contextLifetime, emptyLifetime, hierarchyLifetime, scopeLifetime, singletonLifetime } from "./LifetimeManager";
             import { each, isPromise, isString, key, oid } from "./traits";
             /**
              * @template {S} Карта доступных зависимостей, как правило `ContainerServices`
              * @template {T} Тип сервиса
              */
             export class DescriptorBuilder<S, T, R, U extends keyof S> implements IDescriptorBuilder<S, T, R, U> {
                 private readonly _cb: (d: Descriptor<S, T>) => void;
                 private readonly _eb: (err: unknown) => void;
                 private readonly _refs: DepsMap<R>;
+                private readonly _level: number;
+                private readonly _instanceId: string | number;
                 private _lifetime: ILifetime<T> = emptyLifetime<T>();
                 private _overrides: DescriptorMap<S>;
                 private _cleanup?: (item: T) => void;
                 private _factory?: (refs: R) => NonNullable<T>;
                 private _pending = 1;
                 private _failed = false;
                 private _finalized = false;
                 /**
                  * Creates new DescriptorBuilder. Accepts a lifetime container for resolving "container"
                  * lifetime.
                  *
                  * @param cb The callback to receive the built service descriptor
                  * @param eb The callback to receive the error due
                  */
-                constructor(cb: (d: Descriptor<S, T>) => void, eb: (err: unknown) => void) {
+                constructor(level: number, instanceId: string | number, cb: (d: Descriptor<S, T>) => void, eb: (err: unknown) => void) {
                     this._cb = cb;
                     this._eb = eb;
                     this._overrides = {};
                     this._refs = {};
+                    this._level = level;
+                    this._instanceId = instanceId;
                 }
                 /** Declares dependencies to be consumed in the factory method */
                 wants<X extends DepsMap<S> & Record<keyof R & keyof X, never>>(refs: X):
                     IDescriptorBuilder<S, T, R & { [k in keyof X]: Resolve<S, X[k]>; }, U> {
                     each(refs, (v, k) => this._refs[k] = v);
                     return this as IDescriptorBuilder<S, T, R & {
                         [k in keyof X]: Resolve<S, X[k]>;
                     }, U>;
                 }
                 /** Registers a factory method for the service */
                 factory(f: (refs: R) => NonNullable<T>): void {
                     this._assertBuilding();
                     this._factory = f;
                     this._finalize();
                     this._complete();
                 }
                 private _assertBuilding() {
                     if (this._finalized)
                         throw new Error("The descriptor builder is finalized");
                 }
                 private _finalize() {
                     this._finalized = true;
                 }
                 override<K extends U>(name: K, builder: BuildDescriptorFn<S, NonNullable<S[K]>, U>): this;
                 override<K extends U>(services: { [k in K]: BuildDescriptorFn<S, NonNullable<S[k]>, U> }): this;
                 override<K extends U>(nameOrServices: K | { [name in K]: BuildDescriptorFn<S, NonNullable<S[K]>, U> }, builder?: BuildDescriptorFn<S, NonNullable<S[K]>, U>): this {
                     this._assertBuilding();
                     const guard = (v: void | Promise<void>) => {
                         if (isPromise(v))
                             v.catch(err => this._fail(err));
                     };
                     if (typeof nameOrServices !== "object") {
                         if (builder) {
                             this._defer();
                             const d = new DescriptorBuilder<S, NonNullable<S[K]>, object, U>(
+                                this._level,
+                                String(nameOrServices),
                                 result => {
                                     this._overrides[nameOrServices] = result;
                                     this._complete();
                                 },
                                 err => this._fail(err)
                             );
                             try {
                                 guard(builder(d));
                             } catch (err) {
                                 this._fail(err);
                             }
                         }
                     } else {
                         each(nameOrServices, (v, k) => this.override(k, v));
                     }
                     return this;
                 }
                 /** Specified the singleton lifetime for the service */
                 lifetime(lifetime: "singleton", typeId: string): this;
                 /**
                  * Specifies the lifetime for the service, either {@linkcode ILifetime<T>}
                  * object or {@linkcode ActivationType} literal.
                  * @param lifetime
                  */
                 lifetime(lifetime: ILifetime<T> | Exclude<ActivationType, "singleton">): this;
                 lifetime(lifetime: ILifetime<T> | ActivationType, typeId?: string): this {
                     this._assertBuilding();
                     if (isString(lifetime)) {
                         this._lifetime = this._resolveLifetime(lifetime, typeId);
                     } else {
                         this._lifetime = lifetime;
                     }
                     return this;
                 }
                 /** Registers cleanup callback, used when lifetime of the instance is managed
                  * by the container or some external mechanism
                  */
                 cleanup(cb: (item: T) => void): this {
                     this._assertBuilding();
                     this._cleanup = cb;
                     return this;
                 }
                 /** Registers a value as the instance of the service */
                 value(v: NonNullable<T>): void {
                     this._assertBuilding();
                     this._cb({
                         activate() {
                             return v;
                         }
                     });
                     this._finalize();
                 }
                 _resolveLifetime<T>(activation: ActivationType, typeId?: string | object): ILifetime<T> {
                     switch (activation) {
                         case "container":
-                            return containerLifetime();
+                            return scopeLifetime(this._level, this._instanceId);
                         case "hierarchy":
-                            return hierarchyLifetime();
+                            return hierarchyLifetime(this._instanceId);
                         case "context":
-                            return contextLifetime();
+                            return contextLifetime(this._instanceId);
                         case "singleton": {
                             if (!typeId)
                                 throw Error("The singleton activation requires a typeId");
                             const _oid = isString(typeId) ? typeId : oid(typeId);
                             return singletonLifetime(_oid);
                         }
                         default:
                             return emptyLifetime();
                     }
                 }
                 _defer() {
                     this._pending++;
                 }
                 _complete() {
                     if (--this._pending === 0) {
                         if (!this._factory)
                             throw new Error("The factory must be specified");
                         this._cb(new DescriptorImpl<S, T>({
                             lifetime: this._lifetime,
                             factory: this._factory as (refs: Record<key, unknown>) => NonNullable<T>,
                             overrides: this._overrides,
                             cleanup: this._cleanup
                         }));
                     }
                 }
                 _fail(err: unknown) {
                     if (!this._failed) {
                         this._failed = true;
                         this._eb.call(undefined, err);
                     }
                 }
             }

src/main/ts/DescriptorImpl.ts +46 -62

@@ -1,105 +1,89
1	import { Descriptor, ILifetime, ~~DepsMap~~, IActivationContext, DescriptorMap } from "./interfaces";	1	import { Descriptor, ILifetime, IActivationContext, DescriptorMap, DescriptorDepsMap } from "../typings/interfaces";
		2	import { ActivationError, ActivationItem } from "./ActivationError";
2	import { each, key } from "./traits";	3	import { each, key } from "./traits";
3		4
4	export interface DescriptorImplArgs<S, T> {	5	export interface DescriptorImplArgs<S, T> {
5		6
6	readonly lifetime: ILifetime<~~NonNullable~~<T>>;	7	readonly lifetime: ILifetime<T>;
7		8
8	readonly factory: (refs: Record<key, unknown>) => NonNullable<T>;	9	readonly factory: (refs: Record<key, unknown>) => NonNullable<T>;
9		10
10	readonly cleanup?: (item: NonNullable<T>) => void;	11	readonly cleanup?: (item: NonNullable<T>) => void;
11		12
12	readonly overrides?: DescriptorMap<S>;	13	readonly overrides?: DescriptorMap<S>;
13		14
14	readonly dependencies?: DepsMap<S>;	15	readonly dependencies?: DescriptorDepsMap<S>;
15	}	16	}
16		17
17	export const containerSelfDescriptor = <S>() => Object.freeze({
18	level: 0,
19	activate(context: IActivationContext<S>) {
20	return context.createChildContainer();
21	}
22	});
23
24
25	export class DescriptorImpl<S, T> implements Descriptor<S, T> {	18	export class DescriptorImpl<S, T> implements Descriptor<S, T> {
26		19
27	private readonly _overrides?: DescriptorMap<S>;	20	private readonly _overrides: DescriptorMap<S> \| undefined;
28		21
29	private readonly _lifetime: ILifetime<~~NonNullable~~<T>>;	22	private readonly _lifetime: ILifetime<T>;
30		23
31	private readonly _factory: (refs: Record<key, unknown>) => NonNullable<T>;	24	private readonly _factory: (refs: Record<key, unknown>) => NonNullable<T>;
32		25
33	private readonly _cleanup?: (item: NonNullable<T>) => void;	26	private readonly _cleanup: (item: NonNullable<T>) => void;
34		27
35	private readonly _deps?: DepsMap<S>;	28	private readonly _dependencies: DescriptorDepsMap<S> \| undefined;
36
37	readonly hasOverrides: boolean;
38		29
39	constructor({ lifetime, factory, cleanup, overrides, dependencies }: DescriptorImplArgs<S, T>) {	30	constructor({ lifetime, factory, cleanup, overrides, dependencies }: DescriptorImplArgs<S, T>) {
40	this._lifetime = lifetime;	31	this._lifetime = lifetime;
41	this._factory = factory;	32	this._factory = factory;
42	if (cleanup)	33	this._cleanup = cleanup ? cleanup : () => { };
43	this._cleanup = cleanup;	34	this._overrides = overrides;
44	if (overrides)	35	this._dependencies = dependencies;
45	this._overrides = overrides;
46	if (dependencies)
47	this._deps = dependencies;
48
49	this.hasOverrides = !!overrides;
50	}	36	}
51		37
52	activate(context: IActivationContext<S>): NonNullable<T> {	38	activate(context: IActivationContext<S>, stack: ActivationItem[]): NonNullable<T> {
53		39
54	const { ~~has~~, ~~get~~, ~~initialize~~, ~~store~~ } = this._lifetime(context);	40	const slot = this._lifetime(context);
		41	if (slot.has())
		42	return slot.get();
		43
		44	if (!slot.initialize())
		45	throw new Error("Cyclic reference detected");
55		46
56	if (has())	47	const instance = this._overrides ?
57	return get();	48	context.withOverrides(this._overrides, () => this._activate(context, stack)) :
		49	this._activate(context, stack);
58		50
59	initialize();	51	slot.store(instance, this._cleanup);
60		52
61	if (this._overrides)	53	return instance;
62	each(this._overrides, (v, k) => context.register(k, v));	54	}
63		55
64	const resolve = <K extends keyof S>({ name, lazy, ...opts }: { name: K; lazy?: boolean; default?: S[K] \| null; }) => {	56	private _activate(context: IActivationContext<S>, stack: ActivationItem[]) {
65	if (lazy) {	57	const refs: Record<key, unknown> = {};
66	return "default" in opts ?	58	if (this._dependencies) {
67	() => context.resolve(name, opts.default) :	59	const resolve = <K extends keyof S>({ name, lazy, ...opts }: { name: K; lazy?: boolean; default?: S[K]; }) => {
68	() => context.resolve(name);	60	if (lazy) {
69	} else {	61	return "default" in opts ?
70	return "default" in opts ?	62	() => context.resolve(name, stack, opts.default) :
71	context.resolve(name, ~~opts~~.~~default~~) :	63	() => context.resolve(name, stack);
72	context.resolve(name);	64	} else {
73	}	65	return "default" in opts ?
74	};	66	context.resolve(name, stack, opts.default) :
		67	context.resolve(name, stack);
		68	}
		69	};
75		70
76	const deps = this._deps;	71	// can throw activation exception
77		72	each(this._dependencies, (v, k) => {
78	const refs = deps ?	73	refs[k] = resolve(v);
79	Object.keys(deps)	74	});
80	.map(k => {	75	}
81	const ref = deps[k];
82	return typeof ref !== "object" ?
83	{ [k]: resolve({ name: ref }) } :
84	{ [k]: resolve(ref) };
85	})
86	.reduce((a, p) => ({ ...a, ...p }), {}) :
87	{};
88		76
89	try {	77	try {
90	// call the factory method	78	// call the factory method
91	~~const~~ ~~instance~~ = (0, this._factory)(refs);	79	return (0, this._factory)(refs);
92		80	} catch (e) {
93	// store the instance	81	throw new ActivationError("Error creating instance", stack, e);
94	store(instance, this._cleanup);
95	return instance;
96	} catch (err) {
97	context.fail(err);
98	}	82	}
99	}	83	}
100		84
101		85
102	toString() {	86	toString() {
103	return `[object DescriptorImpl, lifetime=${String(this._lifetime)}]`;	87	return `[object DescriptorImpl, lifetime=${String(this._lifetime)}]`;
104	}	88	}
105	}	89	}

src/main/ts/FluentConfiguration.ts +1 -1

-            import {  ConfigurationMap, ConfigurationMapConstraint, ContainerServices, ContainerServicesConstraint, ExtractRequiredKeys, IContainerBuilder } from "./interfaces";
+            import {  ConfigurationMap, ConfigurationMapConstraint, ContainerServices, ContainerServicesConstraint, ExtractRequiredKeys, IContainerBuilder } from "../typings/interfaces";
             import { argumentNotNull, each, isKey } from "./traits";
             type ContainerExtensionConstraint<X, S> = ContainerServicesConstraint<Pick<S, keyof X & keyof S>>;
             export class FluentConfiguration<S extends ContainerServicesConstraint<S>, Y extends keyof S = keyof S> {
                 private _builders: Partial<ConfigurationMap<ContainerServices<S>, keyof S, keyof S>> = {};
                 /** Adds a declaration of the services to the current config.
                  *
                  * @template D The map of the services
                  * @returns self
                  */
                 declare<D extends ContainerExtensionConstraint<D,S>>(): FluentConfiguration<S & D, Y | keyof D> {
                     return this as unknown as FluentConfiguration<S & D, Y | keyof D>;
                 }
                 /** Adds compile-time information about the already provided services
                  *
                  * @template P The map of the provided services
                  * @returns self
                  */
                 provided<P extends Pick<S, keyof P & keyof S>>(): FluentConfiguration<S & P, Exclude<Y, keyof P>> {
                     return this as unknown as FluentConfiguration<S & P, Exclude<Y, keyof P>>;
                 }
                 /** Register the service.
                  *
                  * @param name The name of the service
                  * @param builder The service builder
                  * @returns self
                  */
                 register<K extends Y>(name: K, builder: ConfigurationMap<ContainerServices<S>,Y, keyof S>[K]): FluentConfiguration<S, Exclude<Y, K>>;
                 /** Registers the collection of services
                  * @param config The collection of services to register.
                  * @returns self
                  */
                 register<X extends ConfigurationMapConstraint<ContainerServices<S>, Y, keyof X>>(config: X): FluentConfiguration<S, Exclude<Y, keyof X>>;
                 register<K extends Y>(nameOrConfig: K | ConfigurationMap<ContainerServices<S>, K, keyof S>, builder?: ConfigurationMap<ContainerServices<S>, Y, keyof S>[K]) {
                     if (isKey(nameOrConfig)) {
                         argumentNotNull(builder, "builder");
                         this._builders[nameOrConfig] = builder;
                     } else {
                         each(nameOrConfig, (v, k) => this.register(k, v));
                     }
                     return this; // as FluentConfiguration<S, Exclude<Y, K>>;
                 }
                 /**
                  * This method is used to enable a compile time check of the configuration.
                  * If there are not configured services in the configuration the compiler
                  * will trigger the error.
                  *
                  * @param missing Empty object literal should always be specified.
                  * @returns self
                  */
                 // eslint-disable-next-line @typescript-eslint/no-unused-vars
                 done(...args: ExtractRequiredKeys<S, Y> extends never ? [] : [services: {[ k in ExtractRequiredKeys<S, Y>]: "required"}]) {
                 //done() {
                     return this;
                 }
                 configure<C extends IContainerBuilder<ContainerServices<S>, keyof S>>(builder: C) {
                     each(this._builders, (v, k) => {
                         v(builder.createServiceBuilder(k));
                     });
                     return builder.build();
                 }
             }

src/main/ts/LifetimeManager.ts +27 -104

@@ -1,174 +1,97
1	import { I~~Destroyabl~~e, ILifetimeContext, ILifetimeManager, ILifetimeSlot } from "./interfaces";	1	import { ILifetime, ILifetimeContext, ILifetimeManager, ILifetimeSlot } from "../typings/interfaces";
2	import { argumentNotNull, isDestroyable } from "./traits";	2	import { LifetimeSlot } from "./LifetimeSlot";
3		3	import { argumentNotNull } from "./traits";
4	const safeCall = (item: () => void) => {
5	try {
6	item();
7	} catch {
8	// silence!
9	}
10	};
11		4
12	const noop = () => { };	5	const noop = () => { };
13		6
14	const fail = (message: string) => (): never => {	7	const fail = (message: string) => (): never => {
15	throw new Error(message);	8	throw new Error(message);
16	};	9	};
17		10
18	const _emptySlot = Object.freeze({	11	const _emptySlot = Object.freeze({
19	has: () => false,	12	has: () => false,
20		13
21	initialize: ~~noop~~,	14	initialize: () => false,
22		15
23	get: fail("The specified item isn't registered with a lifetime manager"),	16	get: fail("The specified item isn't registered with a lifetime manager"),
24		17
25	store: noop,	18	store: noop,
26		19
27	remove: noop,	20	remove: noop,
28		21
29	cleanup: noop,	22	cleanup: noop,
30	});	23	});
31		24
32	const _destroy = (item: unknown) => () => isDestroyable(item) && item.destroy() ;
33
34	const _makeCleanup = <T>(value: T, cleanup?: (item: T) => void) =>
35	cleanup ? () => cleanup(value) : _destroy(value);
36
37	const newSlot = <T>(put: (item: ILifetimeSlot<T>) => void, remove: () => void): ILifetimeSlot<T> => ({
38	has: () => false,
39
40	initialize: () => put(pendingSlot(put, remove)),
41
42	get: fail("The slot doesn't hold a value"),
43
44	store: (value, cleanup) => put(valueSlot(value, cleanup, remove)),
45
46	remove: noop,
47
48	cleanup: noop,
49	});
50
51	const pendingSlot = <T>(put: (item: ILifetimeSlot<T>) => void, remove: () => void): ILifetimeSlot<T> => ({
52	has: () => false,
53
54	get: fail("The value in this slot doesn't exist"),
55
56	initialize: fail("Cyclic reference detected"),
57
58	store: (value, cleanup) => put(valueSlot(value, cleanup, remove)),
59
60	remove,
61
62	cleanup: noop
63	});
64
65	const valueSlot = <T>(value: T, cleanup: ((item: T) => void) \| undefined, remove: () => void) => ({
66	has: () => true,
67
68	get: () => value,
69
70	initialize: fail("The slot already has a value"),
71
72	store: fail("The slot already has a value"),
73
74	cleanup: _makeCleanup(value, cleanup),
75
76	remove: remove
77	});
78
79	export class LifetimeManager implements ILifetimeManager {	25	export class LifetimeManager implements ILifetimeManager {
80	private _destroyed = false;	26	private _destroyed = false;
81		27
82	private readonly _slots: Record<string, ILifetimeSlot<unknown>> = {};	28	private readonly _slots: Record<string, ILifetimeSlot<unknown>> = {};
83		29
84	slot<T>(~~cookie~~: string \| number): ILifetimeSlot<T> {	30	slot<T>(slotId: string \| number): ILifetimeSlot<T> {
85	if (cookie in this._slots)
86	return this._slots[cookie] as ILifetimeSlot<T>;
87
88	return newSlot<T>(this._put(cookie), this._remove(cookie));
89	}
90
91	private readonly _put = (id: string \| number) => <T>(slot: ILifetimeSlot<T>) => {
92	this._assertNotDestroyed();
93	this._slots[id] = slot as ILifetimeSlot<unknown>;
94	};
95
96	private readonly _remove = (id: string \| number) => () => {
97	this._assertNotDestroyed();
98	delete this._slots[id];
99	};
100
101	private _assertNotDestroyed() {
102	if (this._destroyed)	31	if (this._destroyed)
103	throw new Error("The lifetime manager is destroyed");	32	throw new Error("The lifetime manager is destroyed");
104		33
		34	if (slotId in this._slots)
		35	return this._slots[slotId] as ILifetimeSlot<T>;
		36
		37	return this._slots[slotId] = new LifetimeSlot<T>(() => delete this._slots[slotId]);
105	}	38	}
106		39
		40
107	destroy() {	41	destroy() {
108	if (!this._destroyed) {	42	if (!this._destroyed) {
109	this._destroyed = true;	43	this._destroyed = true;
110	Object.values(this._slots).forEach(({ ~~cleanup~~ }) => ~~safeCall~~(~~cleanup));~~	44	Object.values(this._slots).forEach(slot => {
		45	try {
		46	slot.cleanup();
		47	} catch {
		48	// ignore
		49	}
		50	});
111	}	51	}
112	}	52	}
113		53
114	}	54	}
115		55
116	export const empty~~Lifetime~~ = <T>() => () => _emptySlot as ILifetimeSlot<T>;	56	export const emptySlot = <T>() => _emptySlot as ILifetimeSlot<T>;
117		57
118	let nextId = 1;	58	export const emptyLifetime = <T>() => emptySlot as ILifetime<T>;
119		59
120	export const containerLifetime = <T>() => {	60	export const scopeLifetime = <T>(level: number, slotId: string \| number) =>
121	const slotId = nextId ++;	61	(context: ILifetimeContext) =>
122	return (context: ILifetimeContext) =>	62	context.scopeSlot<T>(level, slotId);
123	context.ownerSlot<T>(slotId);
124	};
125		63
126	export const hierarchyLifetime = <T>() => {	64	export const hierarchyLifetime = <T>(slotId: string \| number) =>
127	const slotId = nextId++;	65	(context: ILifetimeContext) =>
128	return (context: ILifetimeContext) =>	66	context.hierarchySlot<T>(slotId);
129	context.containerSlot<T>(slotId);
130	};
131		67
132	/**	68	/**
133	* Creates a lifetime instance bound to the current activation context. This	69	* Creates a lifetime instance bound to the current activation context. This
134	* lifetime will store the service instance per activation context. Every	70	* lifetime will store the service instance per activation context. Every
135	* top level service resolution will create a new activation context. This	71	* top level service resolution will create a new activation context. This
136	* context is propagated to subsequent service resolution thus all services	72	* context is propagated to subsequent service resolution thus all services
137	* with context lifetime will be shared among their consumers.	73	* with context lifetime will be shared among their consumers.
138	*	74	*
139	* @returns The instance of the lifetime.	75	* @returns The instance of the lifetime.
140	*/	76	*/
141	export const contextLifetime = <T>() => {	77	export const contextLifetime = <T>(slotId: string \| number) =>
142	const slotId = nextId++;	78	(context: ILifetimeContext) =>
143
144	return (context: ILifetimeContext) =>
145	context.contextSlot<T>(slotId);	79	context.contextSlot<T>(slotId);
146	};
147		80
148	const singletons = new LifetimeManager();	81	const singletons = new LifetimeManager();
149		82
150	/**	83	/**
151	* Creates the lifetime for the service which will allow existence only one	84	* Creates the lifetime for the service which will allow existence only one
152	* instance with the specified {@linkcode typeId}. If there will be created	85	* instance with the specified {@linkcode typeId}. If there will be created
153	* several lifetime instances with same `typeId` in the runtime, they will	86	* several lifetime instances with same `typeId` in the runtime, they will
154	* share the same service instance.	87	* share the same service instance.
155	*	88	*
156	* @param typeId The identified for the global instance, usually this is a	89	* @param typeId The identified for the global instance, usually this is a
157	* fully qualified class name	90	* fully qualified class name
158	* @returns The lifetime instance	91	* @returns The lifetime instance
159	*/	92	*/
160	export const singletonLifetime = <T>(typeId: string) => {	93	export const singletonLifetime = <T>(typeId: string) => {
161	argumentNotNull(typeId, "typeId");	94	argumentNotNull(typeId, "typeId");
162		95
163	return () => singletons.slot<T>(typeId);	96	return () => singletons.slot<T>(typeId);
164	};	97	};
165
166	/** Creates a lifetime bound to the specified container. Using this lifetime
167	* will create a single service instance per the specified container.
168	*
169	* @param container The container which will manage the lifetime for the service
170	*/
171	export const containerLifetime = <T>(manager: ILifetimeManager) => {
172	const slotId = nextId++;
173	return () => manager.slot<T>(slotId);
174	};

src/main/ts/traits.ts +1 -1

             import { FluentConfiguration } from "./FluentConfiguration";
-            import { ContainerServices, ContainerServicesConstraint, IDestroyable } from "./interfaces";
+            import { ContainerServicesConstraint, IDestroyable } from "../typings/interfaces";
             export function fluent<S extends ContainerServicesConstraint<S>>() {
                 return new FluentConfiguration<S>();
             }
             export type key = string | number | symbol;
             export const isKey = (v: unknown): v is key =>
                 typeof v === "string" || typeof v === "number" || typeof v === "symbol";
             export const isString = (v: unknown): v is string =>
                 typeof v === "string";
             export const isNotNull = <T>(v: T): v is NonNullable<T> => v !== null && v !== undefined;
             export const each = <T extends object>(obj: T, cb: <X extends Extract<keyof T, string>>(v: NonNullable<T[X]>, k: X) => void) =>
                 (Object.keys(obj) as (Extract<keyof T, string>)[])
                     .forEach(k => {
                         const v = obj[k];
                         isNotNull(v) && cb(v, k);
                     });
             export const argumentNotNull = (arg: unknown, name: string) => {
                 if (arg === null || arg === undefined)
                     throw new Error("The argument " + name + " can't be null or undefined");
             };
             export const isPromise = <T = unknown>(val: unknown): val is PromiseLike<T> =>
                 isNotNull(val) && typeof (val as PromiseLike<T>).then === "function";
             export const isDestroyable = (d: unknown): d is IDestroyable =>
                 isNotNull(d) && typeof (d as IDestroyable).destroy === "function";
             let _nextOid = 0;
             const _oid = typeof Symbol === "function" ?
                 Symbol.for("__implab__oid__") :
                 "__implab__oid__";
             type OidSlot = { [k in typeof _oid]?: string };
             export const oid = <T extends object>(instance: T): string => {
                 argumentNotNull(instance, "instance");
                 const val = (instance as OidSlot)[_oid];
                 return val ? val : ((instance as OidSlot)[_oid] = `oid_${++_nextOid}`);
             };
             export const prototype = <T extends object>(instance: T | null): T =>
                 Object.create(instance) as T;

src/main/typings/interfaces.d.ts ~~src/main/ts/interfaces.ts~~ renamed +46 -27

-            import { ContainerBuilder } from "./ContainerBuilder";
+            import { ActivationItem } from "../ts/ActivationError";
-            import { key } from "./traits";
+            import { key } from "../ts/traits";
             export interface IDestroyable {
                 destroy(): void;
             }
             /**
              * @template S Карта доступных зависимостей
              */
             export interface Resolver<S> {
                 /**
                  * Функция для разрешения зависимостей, поддерживает создание фабричных методов,
                  * отложенную активацию и значение по-умолчанию для сервисов
                  * @template K Ключ сервиса из {@linkcode S}
                  * @template O Тип параметра {@linkcode opts} используется для выведения типа
                  *   возвращаемого значения.
                  * @param name Ключ сервиса, который будет разрешен.
                  * @param {boolean=} opts.lazy Признак того, что требуется отложенная активация,
                  *   будет возвращен фабричный метод для получения зависимости. Если не указан,
                  *   то считается `false`.
                  * @param {any=} opts.default Значение по умолчанию, если в контейнере указанный
                  *   сервис не зарегистрирован
                  * @returns Либо фабричный метод для получения зависимости, либо значение зависимости
                  * @throws Error Если зависимость не найдена и не предоставлено значение по-умолчанию
                  */
                 <K extends keyof S, O extends { lazy: true; }>(name: K, opts?: O): () => NonNullable<S[K]> | InferDefault<O>;
                 <K extends keyof S, O extends { lazy?: false; }>(name: K, opts?: O): NonNullable<S[K]> | InferDefault<O>;
             }
             export type DepsMap<S> = {
                 [k in key]: Refs<S> | keyof S;
             };
+            export type DescriptorDepsMap<S> = {
+                [k in key]: Refs<S>;
+            };
             export type Refs<S> = {
                 [k in keyof S]: Ref<k, S[k]>;
             }[keyof S];
             export type Ref<K extends key, D> = {
                 /** The name of the service */
                 name: K;
                 /** Make a lazy reference, the resolved dependency will be a function */
                 lazy?: boolean;
                 /** The default value for the case where the service isn't defined.
                  * When specified the dependency becomes optional, the default value can be
                  * `null` or `undefined`
                  */
-                default?: D | null
+                default?: D;
             };
             export type Lazy<T, L extends boolean> = L extends true ? () => T : T;
             /** Возвращает тип свойства `default` в типе {@link T} */
             export type InferDefault<T> = T extends { default: infer D } ? D : never;
-            export type InferLazy<R> = R extends { lazy: infer L } ?
+            export type IsLazy<R> = R extends { lazy: infer L } ?
                 L extends true ? true : false :
                 false;
             export type Resolve<S, R> =
                 R extends keyof S ? NonNullable<S[R]> :
                 R extends Ref<infer K, unknown> ?
                 K extends keyof S ?
-                Lazy<NonNullable<S[K]> | InferDefault<R>, InferLazy<R>> :
+                Lazy<NonNullable<S[K]> | InferDefault<R>, IsLazy<R>> :
                 never :
                 never;
             /**
              * Интерфейс для конфигурирования сервиса в контейнере. Конфигурирование сервиса
              * состоит из настройки различных параметров вызовами методов {@linkcode wants},
              * {@linkcode lifetime}, {@linkcode override}, {@linkcode cleanup}. Завершение настройки
              * сервиса осуществляется вызовом одного из методов {@linkcode factory} либо
              * {@linkcode value}.
              *
              * @template S Карта сервисов контейнера, доступных при описании дескриптора
              * @template T Тип сервиса
              * @template R Карта зависимостей, которая передается параметром фабрике
              * @template U Имена пользовательских сервисов, доступных для переопределения
              */
             export interface IDescriptorBuilder<S, T, R, U extends keyof S> {
                 /** Указывает фабрика для создания экземпляра сервиса, фабрика передается
                  * в виде параметра. При вызове фабрике будет передан объект с зависимостями,
                  * которые были предварительно указаны вызовами метода `wants(...)`
                  *
                  * Вызов данного метода завершает конфигурирование сервиса.
                  *
                  * @param f Фабрика для создания экземпляра сервиса.
                  */
                 factory(f: (refs: R) => NonNullable<T>): void;
                 /**
                  * Используется для указания зависимостей, которые потребуются фабричному
                  * методу при создании нового экземпляра сервиса. Данный метод может быть
                  * вызван несколько раз подряд, при этом вызовы этого метода имеют
                  * кумулятивный эффект.
                  *
                  * @template X Тип объекта с зависимостями, которые требуется получить при
                  *   создании экземпляра фабрики при помощи фабричного метода.
                  * @param refs Объект с описанием зависимостей
                  * @returns Возвращает дескриптор сервиса, в котором указаны необходимые
                  *   зависимости
                  */
                 wants<X extends DepsMap<S> & Record<keyof R & keyof X, never>>(refs: X):
                     IDescriptorBuilder<S, T, R & {
                         [k in keyof X]: Resolve<S, X[k]>;
                     }, U>
                 override<K extends U>(name: K, builder: BuildDescriptorFn<S, S[K], U>): this;
                 override<X extends ConfigurationMapConstraint<S, U, keyof X>>(services: X): this;
                 lifetime(lifetime: "singleton", typeId: string | number | object): this;
                 lifetime(lifetime: ILifetime<T> | Exclude<ActivationType, "singleton">): this;
                 /** Указывает функцию для освобождения экземпляра сервиса для случаев, когда
                  * время жизни привязано к контейнеру.
                  */
                 cleanup(cb: (item: T) => void): this;
                 /**
                  * Регистрирует в контейнере постоянное значение в качестве реализации сервиса.
                  *
                  * @param v Экземпляр реализации сервиса.
                  */
                 value(v: NonNullable<T>): void;
             }
             export type BuildDescriptorFn<S, T, U extends keyof S> = (d: IDescriptorBuilder<S, T, Record<never, never>, U>) => void;
             /**
              * Конфигурация контейнера, состоит из набора функций, которые выполняют конфигурацию.
              *
              * Все параметры конфигурации являются обязательными, если требуется ввести
              * необязательные параметры, то нужно ограничить параметр типа {@linkcode K}
              *
              * @template S Сервисы доступные в контейнере
              * @template K Сервисы участвующие в конфигурации
              */
             export type ConfigurationMap<S, K extends keyof S, U extends keyof S> = {
                 [k in K]-?: BuildDescriptorFn<S, S[k], U>
             };
             export type ConfigurationMapConstraint<S, U extends keyof S, X extends string | number | symbol> = {
                 [k in X]-?: k extends U ? BuildDescriptorFn<S, S[k], U> : never;
             };
             /**
              * The type constraint useful to restrict type parameters to prevent defining
              * the services with the {@link ContainerKeys} names.
              *
              * The constraint doesn't exclude using this keys but declares them as `never`
              * which effectively will lead using this keys to the error.
              */
             export type ContainerServicesConstraint<S> = {
                 [k in keyof S]: k extends ContainerKeys ? never : S[k];
             };
             export interface Descriptor<S, T> {
                 /** This flags indicates that this registration can be replaced or overridden. */
                 readonly configurable?: boolean;
-                /** If specified signals the activation context that a new service scope
+                activate(context: IActivationContext<S>, stack: ActivationItem[]): NonNullable<T>;
-                 * should be created to isolate service overrides.
-                 */
-                readonly hasOverrides?: boolean;
-                activate(context: IActivationContext<S>): NonNullable<T>;
             }
             /** 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>;
+                /**
+                 *
+                 * @param slotId
+                 */
+                scopeSlot<T>(level: number, slotId: string | number): ILifetimeSlot<T>;
+                hierarchySlot<T>(slotId: string | number): ILifetimeSlot<T>;
             }
-            export interface IActivationContext<S> extends ILifetimeContext, ServiceLocator<S> {
+            export interface IActivationContext<S> extends ILifetimeContext {
-                register<K extends keyof S>(name: K, service: DescriptorMap<S>[K]): void;
+                /**
+                 * @param overrides
-                fail(error: unknown): never;
+                 * @param action
+                 * @throws
+                 */
+                withOverrides<X>(overrides: DescriptorMap<S>, action: () => X): X;
                 selfContainer(): ServiceLocator<S>;
-                createChildContainer(): IContainerBuilder<S, Exclude<keyof S, ContainerKeys>>;
+                createChildContainer(): IContainerBuilder<S, keyof S>;
+                resolve<K extends keyof S>(name: K, stack: ActivationItem[]): NonNullable<S[K]>;
+                resolve<K extends keyof S, T>(name: K, stack: ActivationItem[], def: T): NonNullable<S[K]> | T;
             }
             /**
              * Descriptors map for the specified services {@linkcode S}. All entries are
              * optional regardless the required or optional services in the original map.
              *
              * @template S Сервисы контекста активации
              * @template U Карта сервисов которые создаются дескрипторами
              */
             export type DescriptorMap<S> = {
                 [k in keyof S]?: Descriptor<S, S[k]>;
             };
-            type ContainerKeys = keyof ContainerProvided<object>;
+            export type ContainerKeys = keyof ContainerProvided<object>;
             export type ContainerProvided<S, U extends keyof S = keyof S> = {
                 container: ServiceLocator<ContainerProvided<S>>;
                 childContainer: IContainerBuilder<S, U>;
             };
             /**
              * Таблица сервисов, которые предоставляет контейнер.
              *
              * Сервисы, предоставляемые контейнером не могут быть null или undefined.
              */
             export type ContainerServices<S> = {
                 [k in (keyof S) | ContainerKeys]:
                 k extends ContainerKeys ? ContainerProvided<S>[k] :
                 k extends keyof S ? S[k] : never
             };
             /**
              * Returns the service declared in the type map {@link S}.
              *
              *
              */
             export interface ServiceLocator<S> {
                 resolve<K extends keyof S>(name: K): NonNullable<S[K]>;
                 resolve<K extends keyof S, T>(name: K, def: T): NonNullable<S[K]> | T;
             }
             export interface IContainerBuilder<S, U extends keyof S> {
                 createServiceBuilder<K extends U>(name: K):
                     IDescriptorBuilder<S, S[K], Record<never, never>, U>;
                 build(): ServiceLocator<S>;
             }
             export type ActivationType = "singleton" | "container" | "hierarchy" | "context" | "call";
             /**
              * Интерфейс для управления жизнью экземпляра объекта. Каждая регистрация имеет
              * свой собственный объект `ILifetime`, который создается при первой активации
              */
             export type ILifetime<T> = (context: ILifetimeContext) => ILifetimeSlot<T>;
             export interface ILifetimeSlot<T> {
-                readonly has: () => boolean;
+                has(): boolean;
+                get(): NonNullable<T>;
-                readonly get: () => T;
+                /**
+                 * Initializes the slot, if the slot is already initialized returns false,
-                readonly initialize: () => void;
+                 * otherwise returns true. This method is used to detect cyclic references.
+                 */
+                initialize(): boolean;
-                readonly store: (item: T, cleanup?: (item: T) => void) => void;
+                store(item: NonNullable<T>, cleanup?: (item: NonNullable<T>) => void): void;
-                readonly remove: () => void;
+                /**
+                 * Removes the slot from the lifetime manager. The inner value will not be
+                 * disposed. If the slot is cleaned up calling this method has no effect.
+                 */
+                remove(): void;
-                readonly cleanup: () => void;
+                /**
+                 * Disposed inner value of this slot.
+                 */
+                cleanup(): void;
             }
             export interface ILifetimeManager extends IDestroyable {
                 slot<T>(id: string | number): ILifetimeSlot<T>;
             }
             export type ExtractRequired<T, K extends keyof T = keyof T> = { [p in K as (undefined extends T[p] ? never : p)]-?: T[p] };
             export type ExtractRequiredKeys<T, K extends keyof T = keyof T> = { [p in K]-?: undefined extends T[p] ? never : p }[K];

src/tsconfig.json +1 -2

             {
                 "compilerOptions": {
                     "moduleResolution": "node",
                     "experimentalDecorators": true,
                     "noEmitOnError": true,
                     "listFiles": true,
                     "strict": true,
                     "types": [],
-                    "target": "ES2018",
+                    "target": "ESNext"
-                    "lib": ["ES2018", "DOM", "ScriptHost"]
                 }
             }

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