implab/implabjs-di Commit - r10:99a53d63fd6f

intoruced initial work on ILifetimeSlot

cin -

r10:99a53d63fd6f default

parent child

Context file:

r10:99a53d63fd6f

Collapse all files

src/main/ts/LifetimeManager.ts +91 -65

-            import { IActivationContext, ILifetime, ILifetimeManager } from "./interfaces";
+            import { IActivationContext, ILifetime, ILifetimeContext, ILifetimeManager, ILifetimeSlot } from "./interfaces";
             import { ActivationContext } from "./ActivationContext";
             import { argumentNotNull, isDestroyable } from "./traits";
             const safeCall = (item: () => void) => {
                 try {
                     item();
                 } catch {
                     // silence!
                 }
             };
-            const _emptyLifetime = Object.freeze({
+            const _emptySlot = Object.freeze({
-                has() {
+                has: () => false,
-                    return false;
-                },
-                initialize() {
+                initialize: () => void (0),
-                },
-                get() {
+                get: () => {
                     throw new Error("The specified item isn't registered with this lifetime manager");
                 },
-                store() {
+                store: () => void (0)
-                    // does nothing
-                },
-                toString() {
-                    return `[object EmptyLifetime]`;
             });
-            const _unknownLifetime = Object.freeze({
+            const _unknonwSlot = Object.freeze({
-                has() {
+                has: () => false,
-                    return false;
-                },
+                initialize: () => {
-                initialize() {
                     throw new Error("Can't call initialize on the unknown lifetime object");
                 },
-                get() {
+                get: () => {
                     throw new Error("The lifetime object isn't initialized");
                 },
-                store() {
+                store: () => {
                     throw new Error("Can't store a value in the unknown lifetime object");
-                },
-                toString() {
-                    return `[object UnknownLifetime]`;
                 }
             });
             let nextId = 0;
             const singletons: { [K: string]: unknown } = {};
-            export class LifetimeManager implements ILifetimeManager {
-                private _cleanup: (() => void)[] = [];
-                private readonly _cache: { [K: string]: unknown } = {};
-                private _destroyed = false;
-                private readonly _pending: { [K: string]: unknown } = {};
+            const pendingSlot = <T>(store: (item: T) => void) => ({
+                has: () => false,
-                create<T>(): ILifetime<T> & { remove(): void; } {
-                    const id = ++nextId;
-                    return {
-                        has: () => id in this._cache,
                 get: () => {
-                            const t = this._cache[id] as T;
+                    throw new Error("The value in this slot doesn't exist");
-                            if (t === undefined || t === null)
-                                throw new Error(`The item with with the key ${id} isn't found`);
-                            return t;
                 },
                 initialize: () => {
-                            if (this._pending[id])
+                    throw new Error("Cyclic reference detected");
-                                throw Error(`Cyclic reference detected: the item with the key ${id} is already activating.`);
+                },
-                            this._pending[id] = true;
+                store
+            });
+            const noop = () => void(0);
+            const valueSlot = <T>(value: T, cleanup: (item: T) => void) => ({
+                has: () => true,
+                get: () => value,
+                initialize: () => {
+                    throw new Error("The slot already has a value");
                 },
-                        store: (item: NonNullable<T>, cleanup?: (item: NonNullable<T>) => void) => {
+                store: () => {
-                            if (id in this._cache)
+                    throw new Error("The slot already has a value");
-                                throw new Error(`The item with with the key ${id} already registered with this lifetime manager`);
-                            if (this._destroyed)
+            });
-                                throw new Error("Lifetime manager is destroyed");
-                            delete this._pending[id];
+            export class LifetimeManager implements ILifetimeManager {
+                private _destroyed = false;
-                            this._cache[id] = item;
+                private readonly _slots: Record<string, ILifetimeSlot<unknown>> = {};
+                slot<T>(cookie: string): ILifetimeSlot<T> {
+                    if (cookie in this._slots)
+                        return this._slots[cookie] as ILifetimeSlot<T>;
-                            if (cleanup) {
+                    const store = (item: T, cleanup?: (item: T) => void) => {
-                                this._cleanup.push(() => cleanup(item));
+                        this._assertNotDestroyed();
-                            } else if (isDestroyable(item)) {
+                        this._slots[cookie] = valueSlot(
-                                this._cleanup.push(() => item.destroy());
+                            item,
+                            cleanup ?? isDestroyable(item) ? () => item.destroy() : noop
+                        );
+                    };
+                    return {
+                        has: () => false,
+                        get: () => {
+                            throw new Error("The value isn't stored in this slot");
                         },
+                        store,
-                        remove: () => {
+                        initialize: () => {
-                            if (this._pending[id])
+                            this._assertNotDestroyed();
-                                throw new Error(`The item '${id}' can't be removed before it has been stored`);
+                            this._slots[cookie] = pendingSlot(store);
-                            delete this._cache[id];
                         }
                     };
                 }
+                private _assertNotDestroyed() {
+                    if (this._destroyed)
+                        throw new Error("The lifetime manager is destroyed");
+                }
                 destroy() {
                     if (!this._destroyed) {
                         this._destroyed = true;
                         this._cleanup.forEach(safeCall);
                         this._cleanup.length = 0;
                     }
                 }
             }
             export const emptyLifetime = <T>(): ILifetime<T> => {
                 return _emptyLifetime;
             };
             export const hierarchyLifetime = <T>(): ILifetime<T> => {
                 let _lifetime: ILifetime<T> = _unknownLifetime;
                 return {
-                    initialize(context: IActivationContext<object>) {
+                    initialize(context: ILifetimeContext) {
                         if (_lifetime !== _unknownLifetime)
                             throw new Error("Cyclic reference activation detected");
                         _lifetime = context.createContainerLifetime<T>();
                     },
                     get() {
                         return _lifetime.get();
                     },
                     has() {
                         return _lifetime.has();
                     },
                     store(item: NonNullable<T>, cleanup?: (item: NonNullable<T>) => void) {
                         return _lifetime.store(item, cleanup);
                     },
                     toString() {
                         return `[object HierarchyLifetime, has=${String(this.has())}]`;
                     }
                 };
             };
+            /**
+             * Creates a lifetime instance bound to the current activation context. This
+             * lifetime will store the service instance per activation context. Every
+             * top level service resolution will create a new activation context. This
+             * context is propagated to subsequent service resolution thus all services
+             * with context lifetime will be shared among their consumers.
+             *
+             * @returns The instance of the lifetime.
+             */
             export const contextLifetime = <T>(): ILifetime<T> => {
                 let _lifetime: ILifetime<T> = _unknownLifetime;
                 return {
-                    initialize(context: ActivationContext<object>) {
+                    initialize(context: ILifetimeContext) {
                         if (_lifetime !== _unknownLifetime)
                             throw new Error("Cyclic reference detected");
                         _lifetime = context.createLifetime();
                     },
                     get() {
                         return _lifetime.get();
                     },
                     has() {
                         return _lifetime.has();
                     },
                     store(item: NonNullable<T>) {
                         _lifetime.store(item);
                     },
                     toString() {
                         return `[object ContextLifetime, has=${String(this.has())}]`;
                     }
                 };
             };
+            /**
+             * Creates the lifetime for the service which will allow existence only one
+             * instance with the specified {@linkcode typeId}. If there will be created
+             * several lifetime instances with same `typeId` in the runtime, they will
+             * share the same service instance.
+             *
+             * @param typeId The identified for the global instance, usually this is a
+             *   fully qualified class name
+             * @returns The lifetime instance
+             */
             export const singletonLifetime = <T>(typeId: string): ILifetime<T> => {
                 argumentNotNull(typeId, "typeId");
                 let pending = false;
                 return {
                     has() {
                         return typeId in singletons;
                     },
                     get() {
                         if (!this.has())
                             throw new Error(`The instance ${typeId} doesn't exists`);
                         return singletons[typeId] as NonNullable<T>;
                     },
                     initialize() {
                         if (pending)
                             throw new Error("Cyclic reference detected");
                         pending = true;
                     },
                     store(item: NonNullable<T>) {
                         singletons[typeId] = item;
                         pending = false;
                     },
                     toString() {
                         return `[object SingletonLifetime, has=${String(this.has())}, typeId=${typeId}]`;
                     }
                 };
             };
+            /** Creates a lifetime bound to the specified container. Using this lifetime
+             * will create a single service instance per the specified container.
+             *
+             * @param container The container which will manage the lifetime for the service
+             */
             export const containerLifetime = <T>(container: { createLifetime<X>(): ILifetime<X> }) => {
                 let _lifetime: ILifetime<T> = _unknownLifetime;
                 return {
                     initialize() {
                         if (_lifetime !== _unknownLifetime)
                             throw new Error("Cyclic reference detected");
                         _lifetime = container.createLifetime();
                     },
                     get() {
                         return _lifetime.get();
                     },
                     has() {
                         return _lifetime.has();
                     },
-                    store(item: NonNullable<T>) {
+                    store(item: NonNullable<T>, cleanup?: (item: NonNullable<T>) => void) {
-                        _lifetime.store(item);
+                        _lifetime.store(item, cleanup);
                     },
                     toString() {
                         return `[object ContainerLifetime, has=${String(_lifetime.has())}]`;
                     }
                 };
             };

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

             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>;
             }
-            export interface IActivationContext<S> extends ServiceLocator<S> {
+            /** The context used to initialize lifetime instance {@linkcode ILifetime} */
+            export interface ILifetimeContext {
                 createLifetime<T>(): ILifetime<T>;
                 createContainerLifetime<T>(): ILifetime<T>;
+            }
+            export interface IActivationContext<S> extends ILifetimeContext, ServiceLocator<S> {
                 register<K extends keyof S>(name: K, service: DescriptorMap<S>[K]): void;
             }
             /**
              * 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 LifetimeContainer {
                 createLifetime<T>(): ILifetime<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> {
                 /** Проверяет, что уже создан экземпляр объекта */
                 has(): boolean;
                 get(): NonNullable<T>;
-                initialize(context: IActivationContext<unknown>): void;
+                initialize(context: ILifetimeContext): void;
                 store(item: NonNullable<T>, cleanup?: (item: NonNullable<T>) => void): void;
                 toString(): string;
             }
+            export interface ILifetimeSlot<T> {
+                has: () => boolean;
+                get: () => T;
+                initialize: () => void;
+                store(item: T, cleanup?: (item: T) => void): void;
+            }
             export interface ILifetimeManager extends IDestroyable {
                 create<T>(): ILifetime<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