implab/implabjs-di Commit - r12:94f233c23aa4

WIP lifetime services

cin -

r12:94f233c23aa4 default

parent child

Context file:

r12:94f233c23aa4

Collapse all files

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

             import { Container } from "./Container";
             import { DescriptorBuilder } from "./DescriptorBuilder";
             import { Descriptor, IContainerBuilder, IDescriptorBuilder, DescriptorMap, ServiceLocator, ILifetime, IDestroyable } 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<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._lifetimeManager = new LifetimeManager();
                     this._lifetime = lifetime ?? emptyLifetime();
                 }
                 createServiceBuilder<K extends U>(name: K):
                     IDescriptorBuilder<S, S[K], Record<never, never>, U> {
                     return new DescriptorBuilder(this._lifetimeManager, this._register(name), this._fail);
                 }
                 build(): ServiceLocator<S> {
                     this._assertBuilding();
                     if (!this._complete())
                         throw new Error("The configuration didn't complete.");
-                    const lifetime = this._lifetime;
+                    const {remove, store} = this._lifetime(null);
-                    const detach = isDestroyable(lifetime) ? () => lifetime.destroy() : () => void (0);
+                    const container = new Container(this._services, this._lifetimeManager, remove);
-                    const container = new Container(this._services, this._lifetimeManager, detach);
+                    store(container);
-                    lifetime.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/DescriptorImpl.ts +9 -5

-            import { ActivationError } from "./ActivationError";
             import { Descriptor, ILifetime, DepsMap, IActivationContext, DescriptorMap } from "./interfaces";
             import { each, key } from "./traits";
             export interface DescriptorImplArgs<S, T> {
                 lifetime: ILifetime<T>;
                 factory: (refs: Record<key, unknown>) => NonNullable<T>;
                 cleanup?: (item: NonNullable<T>) => void;
                 overrides?: DescriptorMap<S>;
                 dependencies?: DepsMap<S>;
             }
             export class DescriptorImpl<S, T> implements Descriptor<S, T> {
                 private readonly _overrides?: DescriptorMap<S>;
                 private readonly _lifetime: ILifetime<T>;
                 private readonly _factory: (refs: Record<key, unknown>) => NonNullable<T>;
                 private readonly _cleanup?: (item: NonNullable<T>) => void;
                 private readonly _deps?: DepsMap<S>;
                 readonly hasOverrides: boolean;
                 constructor({ lifetime, factory, cleanup, overrides, dependencies }: DescriptorImplArgs<S, T>) {
                     this._lifetime = lifetime;
                     this._factory = factory;
                     if (cleanup)
                         this._cleanup = cleanup;
                     if (overrides)
                         this._overrides = overrides;
                     if (dependencies)
                         this._deps = dependencies;
                     this.hasOverrides = !!overrides;
                 }
                 activate(context: IActivationContext<S>): NonNullable<T> {
-                    if (this._lifetime.has())
+                    const { has, get, initialize, store } = this._lifetime(context);
-                        return this._lifetime.get();
-                    this._lifetime.initialize(context);
+                    if (has())
+                        return get();
+                    initialize();
                     if (this._overrides)
                         each(this._overrides, (v, k) => context.register(k, v));
                     const resolve = <K extends keyof S>({ name, lazy, ...opts }: { name: K; lazy?: boolean; default?: S[K] | null; }) => {
                         if (lazy) {
                             return "default" in opts ?
                                 () => context.resolve(name, opts.default) :
                                 () => context.resolve(name);
                         } else {
                             return "default" in opts ?
                                 context.resolve(name, opts.default) :
                                 context.resolve(name);
                         }
                     };
                     const deps = this._deps;
                     const refs = deps ?
                         Object.keys(deps)
                             .map(k => {
                                 const ref = deps[k];
                                 return typeof ref !== "object" ?
                                     { [k]: resolve({ name: ref }) } :
                                     { [k]: resolve(ref) };
                             })
                             .reduce((a, p) => ({ ...a, ...p }), {}) :
                         {};
                     try {
+                        // call the factory method
                         const instance = (0,this._factory)(refs);
-                        this._lifetime.store(instance, this._cleanup);
+                        // store the instance
+                        store(instance, this._cleanup);
                         return instance;
                     } catch(err) {
                         context.fail(err);
                     }
                 }
                 toString() {
                     return `[object DescriptorImpl, lifetime=${String(this._lifetime)}]`;
                 }
             }

src/main/ts/LifetimeManager.ts +67 -149

@@ -1,252 +1,170
1	import { I~~ActivationContext~~, ~~ILifetim~~e, ILifetimeContext, ILifetimeManager, ILifetimeSlot } from "./interfaces";	1	import { IDestroyable, ILifetimeContext, ILifetimeManager, ILifetimeSlot } from "./interfaces";
2	import { ActivationContext } from "./ActivationContext";
3	import { argumentNotNull, isDestroyable } from "./traits";	2	import { argumentNotNull, isDestroyable } from "./traits";
4		3
5	const safeCall = (item: () => void) => {	4	const safeCall = (item: () => void) => {
6	try {	5	try {
7	item();	6	item();
8	} catch {	7	} catch {
9	// silence!	8	// silence!
10	}	9	}
11	};	10	};
12		11
13	const noop = () => {};	12	const noop = () => { };
14		13
15	const fail = (message: string) => {	14	const fail = (message: string) => (): never => {
16	throw new Error(message);	15	throw new Error(message);
17	};	16	};
18		17
19	const _emptySlot = Object.freeze({	18	const _emptySlot = Object.freeze({
20	has: () => false,	19	has: () => false,
21		20
22	initialize: noop,	21	initialize: noop,
23		22
24	get: fail("The specified item isn't registered with a lifetime manager"),	23	get: fail("The specified item isn't registered with a lifetime manager"),
25		24
26	store: noop,	25	store: noop,
27		26
28	remove: noop	27	remove: noop,
29	});
30
31	const _unknonwSlot = Object.freeze({
32	has: () => false,
33		28
34	initialize: () => {	29	cleanup: noop,
35	throw new Error("Can't call initialize on the unknown lifetime object");
36	},
37	get: () => {
38	throw new Error("The lifetime object isn't initialized");
39	},
40	store: () => {
41	throw new Error("Can't store a value in the unknown lifetime object");
42	}
43	});	30	});
44		31
		32	const _destroy = (item: IDestroyable) => item.destroy();
45		33
46	const ~~pendingSlot~~ = <T>(~~store~~: (item: T) => void) => ({	34	const _makeCleanup = <T>(value: T, cleanup?: (item: T) => void) =>
		35	cleanup ? () => cleanup(value) :
		36	isDestroyable(value) ? () => _destroy(value) :
		37	noop;
		38
		39	const newSlot = <T>(put: (item: ILifetimeSlot<T>) => void, remove: () => void): ILifetimeSlot<T> => ({
47	has: () => false,	40	has: () => false,
48		41
49	get: () => {	42	initialize: () => put(pendingSlot(put, remove)),
50	throw new Error("The value in this slot doesn't exist");	43
51	},	44	get: fail("The slot doesn't hold a value"),
52		45
53	initialize: () => {	46	store: (value, cleanup) => put(valueSlot(value, cleanup, remove)),
54	throw new Error("Cyclic reference detected");
55	},
56		47
57	store	48	remove: noop,
		49
		50	cleanup: noop,
58	});	51	});
59		52
60	const valueSlot = <T>(value: T, cleanup: (item: T) => void) => ({	53	const pendingSlot = <T>(put: (item: ILifetimeSlot<T>) => void, remove: () => void): ILifetimeSlot<T> => ({
		54	has: () => false,
		55
		56	get: fail("The value in this slot doesn't exist"),
		57
		58	initialize: fail("Cyclic reference detected"),
		59
		60	store: (value, cleanup) => put(valueSlot(value, cleanup, remove)),
		61
		62	remove,
		63
		64	cleanup: noop
		65	});
		66
		67	const valueSlot = <T>(value: T, cleanup: ((item: T) => void) \| undefined, remove: () => void) => ({
61	has: () => true,	68	has: () => true,
62		69
63	get: () => value,	70	get: () => value,
64		71
65	initialize: () => {	72	initialize: fail("The slot already has a value"),
66	throw new Error("The slot already has a value");	73
67	},	74	store: fail("The slot already has a value"),
68		75
69	store: () => {	76	cleanup: _makeCleanup(value, cleanup),
70	throw new Error("The slot already has a value");	77
71	}	78	remove: remove
72	});	79	});
73		80
74	const singletons: { [K: string]: unknown } = {};
75
76	export class LifetimeManager implements ILifetimeManager {	81	export class LifetimeManager implements ILifetimeManager {
77	private _destroyed = false;	82	private _destroyed = false;
78		83
79	private readonly _slots: Record<string, ILifetimeSlot<unknown>> = {};	84	private readonly _slots: Record<string, ILifetimeSlot<unknown>> = {};
80		85
81	slot<T>(cookie: string): ILifetimeSlot<T> {	86	slot<T>(cookie: string \| number): ILifetimeSlot<T> {
82	if (cookie in this._slots)	87	if (cookie in this._slots)
83	return this._slots[cookie] as ILifetimeSlot<T>;	88	return this._slots[cookie] as ILifetimeSlot<T>;
84		89
85	const store = (item: T, cleanup?: (item: T) => void) => {	90	return newSlot<T>(this._put(cookie), this._remove(cookie));
		91	}
		92
		93	private readonly _put = (id: string \| number) => <T>(slot: ILifetimeSlot<T>) => {
86	this._assertNotDestroyed();	94	this._assertNotDestroyed();
87	this._slots[~~cookie~~] = ~~valueSlot~~(	95	this._slots[id] = slot as ILifetimeSlot<unknown>;
88	item,
89	cleanup ?? isDestroyable(item) ? () => item.destroy() : noop
90	);
91	};	96	};
92		97
93	return {	98	private readonly _remove = (id: string \| number) => () => {
94	has: () => false,
95	get: () => {
96	throw new Error("The value isn't stored in this slot");
97	},
98	store,
99	initialize: () => {
100	this._assertNotDestroyed();	99	this._assertNotDestroyed();
101	this._slots[cookie] = pendingSlot(store);	100	delete this._slots[id];
102	}
103	};	101	};
104	}
105
106	remove(cookie: string) {
107	delete this._slots[cookie];
108	}
109		102
110	private _assertNotDestroyed() {	103	private _assertNotDestroyed() {
111	if (this._destroyed)	104	if (this._destroyed)
112	throw new Error("The lifetime manager is destroyed");	105	throw new Error("The lifetime manager is destroyed");
113		106
114	}	107	}
115		108
116	destroy() {	109	destroy() {
117	if (!this._destroyed) {	110	if (!this._destroyed) {
118	this._destroyed = true;	111	this._destroyed = true;
119	Object.values(this._slots).forEach(({clean}) => )	112	Object.values(this._slots).forEach(({ cleanup }) => safeCall(cleanup));
120	}	113	}
121	}	114	}
122		115
123	}	116	}
124		117
125	export const emptyLifetime = <T>(): ~~ILifetime~~<T> => {	118	export const emptyLifetime = <T>() => () => _emptySlot as ILifetimeSlot<T>;
126	return _emptyLifetime;
127	};
128		119
129	export const hierarchyLifetime = <T>(): ILifetime<T> => {	120	let nextId = 1;
130	// TODO: вот здесь ошибка, при первой активации сервиса будет получен и
131	// привязан lifetime из дочернего контейнера, при активации через второй
132	// дочерний контейнера это приведет к ошибке, точнее будет взят экземпляр
133	// из первого контейнера.
134	let _lifetime: ILifetime<T> = _unknownLifetime;
135	return {
136	initialize(context: ILifetimeContext) {
137	if (_lifetime !== _unknownLifetime)
138	throw new Error("Cyclic reference activation detected");
139		121
140	_lifetime = context.createContainerLifetime<T>();	122	export const hierarchyLifetime = <T>() => {
141	},	123	const slotId = nextId++;
142	get() {	124	return (context: ILifetimeContext) =>
143	return _lifetime.get();	125	context.containerSlot<T>(slotId);
144	},
145	has() {
146	return _lifetime.has();
147	},
148	store(item: NonNullable<T>, cleanup?: (item: NonNullable<T>) => void) {
149	return _lifetime.store(item, cleanup);
150	},
151	toString() {
152	return `[object HierarchyLifetime, has=${String(this.has())}]`;
153	}
154	};
155	};	126	};
156		127
157	/**	128	/**
158	* Creates a lifetime instance bound to the current activation context. This	129	* Creates a lifetime instance bound to the current activation context. This
159	* lifetime will store the service instance per activation context. Every	130	* lifetime will store the service instance per activation context. Every
160	* top level service resolution will create a new activation context. This	131	* top level service resolution will create a new activation context. This
161	* context is propagated to subsequent service resolution thus all services	132	* context is propagated to subsequent service resolution thus all services
162	* with context lifetime will be shared among their consumers.	133	* with context lifetime will be shared among their consumers.
163	*	134	*
164	* @returns The instance of the lifetime.	135	* @returns The instance of the lifetime.
165	*/	136	*/
166	export const contextLifetime = <T>(): ~~ILifetime~~<T> => {	137	export const contextLifetime = <T>() => {
167	let _lifetime: ILifetime<T> = _unknownLifetime;	138	const slotId = nextId++;
168	return {	139
169	~~initialize~~(context: ILifetimeContext) {	140	return (context: ILifetimeContext) =>
170	if (_lifetime !== _unknownLifetime)	141	context.contextSlot<T>(slotId);
171	throw new Error("Cyclic reference detected");
172	_lifetime = context.createLifetime();
173	},
174	get() {
175	return _lifetime.get();
176	},
177	has() {
178	return _lifetime.has();
179	},
180	store(item: NonNullable<T>) {
181	_lifetime.store(item);
182	},
183	toString() {
184	return `[object ContextLifetime, has=${String(this.has())}]`;
185	}
186	};	142	};
187	};	143
		144	const singletons = new LifetimeManager();
188		145
189	/**	146	/**
190	* Creates the lifetime for the service which will allow existence only one	147	* Creates the lifetime for the service which will allow existence only one
191	* instance with the specified {@linkcode typeId}. If there will be created	148	* instance with the specified {@linkcode typeId}. If there will be created
192	* several lifetime instances with same `typeId` in the runtime, they will	149	* several lifetime instances with same `typeId` in the runtime, they will
193	* share the same service instance.	150	* share the same service instance.
194	*	151	*
195	* @param typeId The identified for the global instance, usually this is a	152	* @param typeId The identified for the global instance, usually this is a
196	* fully qualified class name	153	* fully qualified class name
197	* @returns The lifetime instance	154	* @returns The lifetime instance
198	*/	155	*/
199	export const singletonLifetime = <T>(typeId: string): ~~ILifetime~~<T> => {	156	export const singletonLifetime = <T>(typeId: string) => {
200	argumentNotNull(typeId, "typeId");	157	argumentNotNull(typeId, "typeId");
201	let pending = false;	158
202	return {	159	return () => singletons.slot<T>(typeId);
203	has() {
204	return typeId in singletons;
205	},
206	get() {
207	if (!this.has())
208	throw new Error(`The instance ${typeId} doesn't exists`);
209	return singletons[typeId] as NonNullable<T>;
210	},
211	initialize() {
212	if (pending)
213	throw new Error("Cyclic reference detected");
214	pending = true;
215	},
216	store(item: NonNullable<T>) {
217	singletons[typeId] = item;
218	pending = false;
219	},
220	toString() {
221	return `[object SingletonLifetime, has=${String(this.has())}, typeId=${typeId}]`;
222	}
223	};
224	};	160	};
225		161
226	/** Creates a lifetime bound to the specified container. Using this lifetime	162	/** Creates a lifetime bound to the specified container. Using this lifetime
227	* will create a single service instance per the specified container.	163	* will create a single service instance per the specified container.
228	*	164	*
229	* @param container The container which will manage the lifetime for the service	165	* @param container The container which will manage the lifetime for the service
230	*/	166	*/
231	export const containerLifetime = <T>(~~container~~: { ~~createLifetime~~<X>(): ~~ILifetime~~<X> }) => {	167	export const containerLifetime = <T>(manager: ILifetimeManager) => {
232	let _lifetime: ILifetime<T> = _unknownLifetime;	168	const slotId = nextId++;
233	return {	169	return () => manager.slot<T>(slotId);
234	initialize() {
235	if (_lifetime !== _unknownLifetime)
236	throw new Error("Cyclic reference detected");
237	_lifetime = container.createLifetime();
238	},
239	get() {
240	return _lifetime.get();
241	},
242	has() {
243	return _lifetime.has();
244	},
245	store(item: NonNullable<T>, cleanup?: (item: NonNullable<T>) => void) {
246	_lifetime.store(item, cleanup);
247	},
248	toString() {
249	return `[object ContainerLifetime, has=${String(_lifetime.has())}]`;
250	}
251	};	170	};
252	};

src/main/ts/interfaces.ts +12 -19

             import { key } from "./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 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
             };
             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 } ?
                 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>> :
                 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
                  * 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 {
-                contextSlot<T>(slotId: string): ILifetimeSlot<T>;
+                contextSlot<T>(slotId: string | number): ILifetimeSlot<T>;
-                containerSlot<T>(slotId: string): ILifetimeSlot<T>;
+                containerSlot<T>(slotId: string | number): ILifetimeSlot<T>;
             }
             export interface IActivationContext<S> extends ILifetimeContext, ServiceLocator<S> {
                 register<K extends keyof S>(name: K, service: DescriptorMap<S>[K]): void;
                 fail(error: unknown): never;
             }
             /**
              * 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 ContainerProvided<S extends ContainerServicesConstraint<S>> = {
                 container: ServiceLocator<ContainerServices<S>>;
                 childContainer: IContainerBuilder<ContainerServices<S>, Exclude<keyof S, ContainerKeys>>;
             };
             /**
              * Таблица сервисов, которые предоставляет контейнер.
              *
              * Сервисы, предоставляемые контейнером не могут быть null или undefined.
              */
             export type ContainerServices<S extends ContainerServicesConstraint<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 interface ILifetime<T> {
+            export type ILifetime<T> = (context: ILifetimeContext) => ILifetimeSlot<NonNullable<T>>;
-                /** Проверяет, что уже создан экземпляр объекта */
-                has(): boolean;
-                get(): NonNullable<T>;
-                initialize(context: ILifetimeContext): void;
-                store(item: NonNullable<T>, cleanup?: (item: NonNullable<T>) => void): void;
-                toString(): string;
             export interface ILifetimeSlot<T> {
-                has: () => boolean;
+                readonly has: () => boolean;
-                get: () => T;
+                readonly get: () => T;
+                readonly initialize: () => void;
-                initialize: () => void;
+                readonly store: (item: T, cleanup?: (item: T) => void) => void;
-                store(item: T, cleanup?: (item: T) => void): void;
+                readonly remove: () => void;
+                readonly cleanup: () => void;
             }
             export interface ILifetimeManager extends IDestroyable {
-                create<T>(): ILifetime<T>;
+                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];

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