implab/implabjs-di Commit - r6:5683fe88e2a5

Corrected method signatures

cin -

r6:5683fe88e2a5 default

parent child

Context file:

r6:5683fe88e2a5

Collapse all files

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

             import { Container } from "./Container";
             import { DescriptorBuilder } from "./DescriptorBuilder";
             import { Configurable, ConfigurableKeys, ContainerServices, Descriptor, IContainerBuilder, IDescriptorBuilder, RegistrationMap, ServiceContainer } from "./interfaces";
             import { LifetimeManager } from "./LifetimeManager";
             export class ContainerBuilder<S extends Configurable<S>> implements IContainerBuilder<S>{
                 private _pending = 1;
                 private readonly _services: Partial<RegistrationMap<ContainerServices<S>>>;
                 private readonly _lifetimeManager = new LifetimeManager();
                 constructor(parentServices?: object) {
                     this._services = Object.create(parentServices ? parentServices : null) as object;
                 }
-                createServiceBuilder<K extends keyof S>(name: K): IDescriptorBuilder<S, NonNullable<S[K]>, object> {
+                createServiceBuilder<K extends keyof S>(name: K): IDescriptorBuilder<ContainerServices<S>, NonNullable<S[K]>, object, keyof S> {
                     return new DescriptorBuilder(this._lifetimeManager, this._register(name), this._fail);
                 }
                 build(): ServiceContainer<S> {
                     this._assertBuilding();
                     if(!this._complete())
                         throw new Error("The configuration didn't complete.");
                     return new Container(this._services, this._lifetimeManager);
                 }
                 private readonly _register = <K extends ConfigurableKeys<S>>(name: K) => (descriptor: Descriptor<S, NonNullable<S[K]>>) => {
                     this._complete();
                     this._services[name] = descriptor;
                 };
                 private readonly _fail = (ex: unknown) => {
                 };
                 private _assertBuilding() {
                     throw new Error("The descriptor builder is finalized");
                 }
                 private _complete() {
                     return !(--this._pending);
                 }
             }

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

             import { RegistrationBuilder, LifetimeContainer, ConfigurableKeys, IDescriptorBuilder, Ref, Resolved, DepsMap } from "./interfaces";
             import { Descriptor, ILifetime, ActivationType } from "./interfaces";
             import { DescriptorImpl, RegistrationOverridesMap } from "./DescriptorImpl";
             import { LifetimeManager } from "./LifetimeManager";
             import { each, isKey, isPromise, isString, key, oid } from "./traits";
             /**
              * @template {S} Карта доступных зависимостей, как правило `ContainerServices`
              * @template {T} Тип сервиса
              */
-            export class DescriptorBuilder<S extends object, T, R extends object = object> implements IDescriptorBuilder<S, T, R> {
+            export class DescriptorBuilder<S extends object, T, R extends object, O extends keyof S> implements IDescriptorBuilder<S, T, R, O> {
                 private readonly _lifetimeManager: LifetimeManager;
                 private readonly _cb: (d: Descriptor<S, T>) => void;
                 private readonly _eb: (err: unknown) => void;
                 private readonly _refs: DepsMap<key, keyof S>;
                 private _lifetime = LifetimeManager.empty<T>();
                 private _overrides: RegistrationOverridesMap<S>;
                 private _cleanup?: (item: T) => void;
                 private _factory?: (refs: R) => T;
                 private _pending = 1;
                 private _failed = false;
                 private _finalized = false;
                 /**
                  * Creates new DescriptorBuilder. Accepts a lifetime container for resolving "container"
                  * lifetime.
                  *
                  * @param lifetimeManager The lifetime container is the container where the service is to be registered.
                  * @param cb The callback to receive the built service descriptor
                  * @param eb The callback to receive the error due
                  */
                 constructor(lifetimeManager: LifetimeManager, cb: (d: Descriptor<S, T>) => void, eb: (err: unknown) => void) {
                     this._lifetimeManager = lifetimeManager;
                     this._cb = cb;
                     this._eb = eb;
                     this._overrides = {};
                     this._refs = {};
                 }
                 wants<X extends { [k in Exclude<key, keyof R>]: keyof S | Ref<keyof S, boolean, unknown>; }>(refs: X):
                     IDescriptorBuilder<S, T, R & {
                         [k in keyof X]:
                         X[k] extends keyof S ? NonNullable<S[X[k]]> :
                         X[k] extends Ref<infer K, infer L, infer D> ? Resolved<S, K & keyof S, L, D> :
                         never;
-                    }> {
+                    }, O> {
                     each(refs, (v, k) => this._refs[k] = v);
                     return this as IDescriptorBuilder<S, T, R & {
                         [k in keyof X]:
                         X[k] extends keyof S ? NonNullable<S[X[k]]> :
                         X[k] extends Ref<infer K, infer L, infer D> ? Resolved<S, K & keyof S, L, D> :
                         never;
-                    }>;
+                    }, O>;
                 }
                 factory(f: (refs: R) => 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 ConfigurableKeys<S>>(name: K, builder: RegistrationBuilder<S, NonNullable<S[K]>>): this;
+                override<K extends O>(name: K, builder: RegistrationBuilder<S, NonNullable<S[K]>>): this;
-                override<K extends ConfigurableKeys<S>>(services: { [k in K]: RegistrationBuilder<S, NonNullable<S[k]>> }): this;
+                override<K extends O>(services: { [k in K]: RegistrationBuilder<S, NonNullable<S[k]>> }): this;
-                override<K extends ConfigurableKeys<S>>(nameOrServices: K | { [name in K]: RegistrationBuilder<S, NonNullable<S[K]>> }, builder?: RegistrationBuilder<S, NonNullable<S[K]>>): this {
+                override<K extends O>(nameOrServices: K | { [name in K]: RegistrationBuilder<S, NonNullable<S[K]>> }, builder?: RegistrationBuilder<S, NonNullable<S[K]>>): this {
                     this._assertBuilding();
                     const guard = (v: void | Promise<void>) => {
                         if (isPromise(v))
                             v.catch(err => this._fail(err));
                     };
                     if (isKey(nameOrServices)) {
                         if (builder) {
                             this._defer();
-                            const d = new DescriptorBuilder<S, NonNullable<S[K]>>(
+                            const d = new DescriptorBuilder<S, NonNullable<S[K]>, object, O>(
                                 this._lifetimeManager,
                                 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;
                 }
                 lifetime(lifetime: "singleton", typeId: string): this;
                 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;
                 }
                 cleanup(cb: (item: T) => void): this {
                     this._assertBuilding();
                     this._cleanup = cb;
                     return this;
                 }
                 value(v: 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 this._lifetimeManager.create();
                         case "hierarchy":
                             return LifetimeManager.hierarchyLifetime();
                         case "context":
                             return LifetimeManager.contextLifetime();
                         case "singleton": {
                             if (!typeId)
                                 throw Error("The singleton activation requires a typeId");
                             const _oid = isString(typeId) ? typeId : oid(typeId);
                             return LifetimeManager.singletonLifetime(_oid);
                         }
                         default:
                             return LifetimeManager.empty();
                     }
                 }
                 _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,
                             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 +2 -3

-            import { Descriptor, ILifetime, ConfigurableKeys, DepsMap, Ref, IActivationContext } from "./interfaces";
+            import { Descriptor, ILifetime, DepsMap, Ref, IActivationContext } from "./interfaces";
-            import { ActivationContext } from "./ActivationContext";
             import { each, isKey, key } from "./traits";
-            export type RegistrationOverridesMap<S extends object> = { [k in ConfigurableKeys<S>]?: Descriptor<S, NonNullable<S[k]>> };
+            export type RegistrationOverridesMap<S extends object> = { [k in keyof S]?: Descriptor<S, NonNullable<S[k]>> };
             export interface DescriptorImplArgs<S extends object, T> {
                 lifetime: ILifetime<T>;
                 factory: (refs: Record<key, never>) => T;
                 cleanup?: (item: T) => void;
                 overrides?: RegistrationOverridesMap<S>;
                 dependencies?: DepsMap<key, keyof S>;
             }
             export class DescriptorImpl<S extends object, T> implements Descriptor<S, T> {
                 private readonly _overrides?: RegistrationOverridesMap<S>;
                 private readonly _lifetime: ILifetime<T>;
                 private readonly _factory: (refs: Record<key, never>) => T;
                 private readonly _cleanup?: (item: T) => void;
                 private readonly _deps?: DepsMap<key, keyof S>;
                 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;
                 }
                 activate(context: IActivationContext<S>): T {
                     if (this._lifetime.has())
                         return this._lifetime.get();
                     this._lifetime.initialize(context);
                     if (this._overrides)
                         each(this._overrides, (v, k) => context.register(k, v));
                     const resolve = <K extends keyof S, L extends boolean, D = never>({ name, lazy, ...opts }: Ref<K, L, D>) => {
                         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 makeRefs = (deps: typeof this._deps) => deps ?
                         Object.keys(deps)
                             .map(k => {
                                 const ref = deps[k];
                                 return isKey(ref) ?
                                     { [k]: resolve({ name: ref }) } :
                                     { [k]: resolve(ref) };
                             })
                             .reduce((a, p) => ({ ...a, ...p }), {} ) as Record<key, never>:
                         {} as Record<key, never>;
                     const instance = this._factory.call(undefined, makeRefs(this._deps));
                     this._lifetime.store(instance, this._cleanup);
                     return instance;
                 }
                 toString() {
                     return `[object DescriptorImpl, lifetime=${String(this._lifetime)}]`;
                 }
             }

src/main/ts/interfaces.ts +7 -10

-            import { ActivationContext } from "./ActivationContext";
             import { key } from "./traits";
             export interface IDestroyable {
                 destroy(): void;
             }
             /**
              * @template S Карта доступных зависимостей
              */
             export interface Resolver<S extends object> {
                 /**
                  * Функция для разрешения зависимостей, поддерживает создание фабричных методов,
                  * отложенную активацию и значение по-умолчанию для сервисов
                  * @template K Ключ сервиса из {@link S}
                  * @template O Тип параметра {@link opts} используется для выведения типа
                  *   возвращаемого значения.
                  * @param name Ключ сервиса, который будет разрешен.
                  * @param {boolean=} opts.lazy Признак того, что требуется отложенная активация,
                  *   будет возвращен фабричный метод для получения зависимости. Если не указан,
                  *   то считается `false`.
                  * @param {any=} opts.default Значение по умолчанию, если в контейнере указанный
                  *   сервис не зарегистрирован
                  * @returns Либо фабричный метод для получения зависимости, либо значение зависимости
                  * @throws Error Если зависимость не найдена и не предоставлено значение по-умолчанию
                  */
                 <K extends keyof S, O extends { lazy: true; default?: unknown }>(name: K, opts?: O): () => (O extends { default: infer T } ? T : never) | NonNullable<S[K]>;
                 <K extends keyof S, O extends { lazy?: false; default?: unknown }>(name: K, opts?: O): (O extends { default: infer T } ? T : never) | NonNullable<S[K]>;
             }
             export type DepsMap<K extends key, SK extends key> = { [k in K]: SK | Ref<SK, boolean, unknown> };
             export type Ref<K extends key, L extends boolean, D> = { name: K, lazy?: L } | { name: K, lazy?: L, default: D };
             export type Resolved<S, K extends keyof S, L, D> =
                 L extends true ? () => NonNullable<S[K]> | (unknown extends D ? never : D) : NonNullable<S[K]> | (unknown extends D ? never : D);
-            export interface IDescriptorBuilder<S extends object, T, R extends object = object> {
+            export interface IDescriptorBuilder<S extends object, T, R extends object, O extends keyof S> {
                 /**
                  *
                  * @param f
                  */
                 factory(f: (refs: R) => T): void;
                 wants<X extends DepsMap<Exclude<key, keyof R>, keyof S>>(refs: X):
                     IDescriptorBuilder<S, T, R & {
                         [k in keyof X]:
                         X[k] extends keyof S ? NonNullable<S[X[k]]> :
                         X[k] extends Ref<infer K, infer L, infer D> ? Resolved<S, K & keyof S, L, D> :
                         never
-                    }>
+                    }, O>
-                override<K extends ConfigurableKeys<S>>(name: K, builder: RegistrationBuilder<S, NonNullable<S[K]>>): this;
+                override<K extends O>(name: K, builder: RegistrationBuilder<S, NonNullable<S[K]>>): this;
-                override<K extends ConfigurableKeys<S>>(services: { [name in K]: RegistrationBuilder<S, NonNullable<S[K]>> }): this;
+                override<K extends O>(services: { [name in K]: RegistrationBuilder<S, NonNullable<S[K]>> }): this;
                 lifetime(lifetime: "singleton", typeId: string | number | object): this;
                 lifetime(lifetime: ILifetime<T> | Exclude<ActivationType, "singleton">): this;
                 cleanup(cb: (item: T) => void): this;
                 value(v: T): void;
             }
-            export type RegistrationBuilder<S extends object, T> = (d: IDescriptorBuilder<S, T>) => void;
+            export type RegistrationBuilder<S extends object, T> = (d: IDescriptorBuilder<S, T, object, ConfigurableKeys<S>>) => void;
-            export type RegistrationBuildersMap<S extends object, K extends ConfigurableKeys<S> = ConfigurableKeys<S>> = {
+            export type RegistrationBuildersMap<S extends Configurable<S>, K extends keyof S = keyof S> = {
                 [k in K]-?: RegistrationBuilder<ContainerServices<S>, NonNullable<S[k]>>
             };
             export interface Descriptor<S extends object, T> {
                 activate(context: IActivationContext<S>): T;
             }
             export interface IActivationContext<S extends object> extends ServiceLocator<S> {
                 createLifetime<T>(): ILifetime<T>;
                 createContainerLifetime<T>(): ILifetime<T>;
             }
-            export type ConfigurableDescriptor<S extends object, K extends ConfigurableKeys<S>> = Descriptor<ContainerServices<S>, S[K]>;
             export type RegistrationMap<S extends object, K extends keyof S = keyof S> = {
                 [k in K]-?: Descriptor<S, S[k]>;
             };
             export interface ContainerProvided<S extends Configurable<S>> {
                 container: ServiceLocator<ContainerServices<S>>;
                 childContainer: IContainerBuilder<S>;
             }
             export type Configurable<S> = { [k in keyof S & (keyof ContainerProvided<never>)]: never; };
             export type ProvidedKeys = keyof ContainerProvided<never>;
             export type ContainerServices<S extends Configurable<S>> = S & ContainerProvided<S>;
             export type ConfigurableKeys<S extends object> = Exclude<keyof S, ProvidedKeys>;
             export type ConfigurableServices<S extends object> = Pick<S, ConfigurableKeys<S>>;
             export type ContainerKeys<S extends Configurable<S>> = keyof S | keyof ContainerProvided<never>;
             export interface ServiceLocator<S extends object> {
                 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 ServiceContainer<S extends Configurable<S>> extends
                 ServiceLocator<ContainerServices<S>>,
                 IDestroyable {
                 createChildContainer(): IContainerBuilder<S>;
             }
             export interface IContainerBuilder<S extends Configurable<S>> {
-                createServiceBuilder<K extends keyof S>(name: K): IDescriptorBuilder<S, NonNullable<S[K]>>;
+                createServiceBuilder<K extends keyof S>(name: K): IDescriptorBuilder<S, NonNullable<S[K]>, object, keyof S>;
                 build(): ServiceContainer<S>;
             }
             export type ActivationType = "singleton" | "container" | "hierarchy" | "context" | "call";
             /**
              * Интерфейс для управления жизнью экземпляра объекта. Каждая регистрация имеет
              * свой собственный объект `ILifetime`, который создается при первой активации
              */
             export interface ILifetime<T> {
                 /** Проверяет, что уже создан экземпляр объекта */
                 has(): boolean;
                 get(): T;
                 initialize(context: IActivationContext<object>): void;
                 store(item: T, cleanup?: (item: T) => void): void;
             }
             export type ExtractRequired<T, K extends keyof T = keyof T> = { [p in K as (undefined extends T[p] ? never : p)]-?: T[p] };

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