implab/implabjs-di Commit - r9:988f0f6aab67

almost woking typings

cin -

r9:988f0f6aab67 default

parent child

Context file:

r9:988f0f6aab67

Collapse all files

.vscode/settings.json +4 -1

@@ -1,3 +1,6
1	{	1	{
2	"java.configuration.updateBuildConfiguration": "automatic"	2	"java.configuration.updateBuildConfiguration": "automatic",
		3	"cSpell.words": [
		4	"linkcode"
		5	]
3	} No newline at end of file	6	}

src/main/ts/ActivationContext.ts +26 -21

-            import { Descriptor, ILifetime, RegistrationMap, LifetimeContainer, ConfigurableKeys } from "./interfaces";
+            import { Descriptor, ILifetime, IActivationContext, DescriptorMap, ILifetimeManager } from "./interfaces";
-            import { LifetimeManager } from "./LifetimeManager";
             import { argumentNotNull } from "./traits";
             export interface ActivationContextInfo {
                 name: string;
                 service: string;
             }
             let nextId = 1;
-            /** This class is created once per `Container.resolve` method call and used to
+            /** This object is created once per `Container.resolve` method call and used to
              * cache dependencies and to track created instances. The activation context
              * tracks services with `context` activation type.
+             *
+             * @template S The service map used in the activation context, services from
+             *   this map are available to resolution.
+             * @template U A set of keys from the service map which can be overridden in
+             *   this activation context.
              */
-            export class ActivationContext<S extends object> {
+            export class ActivationContext<S> implements IActivationContext<S> {
                 private readonly _cache: Record<string, unknown>;
-                private readonly _services: Partial<RegistrationMap<S>>;
+                private readonly _services: DescriptorMap<S>;
                 private readonly _name: string;
                 private readonly _service: Descriptor<S, unknown>;
-                private readonly _containerLifetimeManager: LifetimeManager;
+                private readonly _containerLifetimeManager: ILifetimeManager;
                 private readonly _parent: ActivationContext<S> | undefined;
                 /** Creates a new activation context with the specified parameters.
                  * @param containerLifetimeManager the container which starts the activation process
                  * @param services the initial service registrations
                  * @param name the name of the service being activated, this parameter is
                  *  used for the debug purpose.
                  * @param service the service to activate, this parameter is used for the
                  *  debug purpose.
                  */
-                constructor(containerLifetimeManager: LifetimeManager, services: Partial<RegistrationMap<S>>, name: string, service: Descriptor<S, unknown>, cache = {}) {
+                constructor(containerLifetimeManager: ILifetimeManager, services: DescriptorMap<S>, name: string, service: Descriptor<S, unknown>, cache = {}) {
                     this._name = name;
                     this._service = service;
                     this._cache = cache;
                     this._services = services;
                     this._containerLifetimeManager = containerLifetimeManager;
                 }
                 /** the name of the current resolving dependency */
                 getName() {
                     return this._name;
                 }
                 createContainerLifetime<T>() {
                     return this._containerLifetimeManager.create<T>();
                 }
-                /** Resolves the specified dependency in the current context
-                 * @param name The name of the dependency being resolved
-                 */
                 resolve<K extends keyof S>(name: K): NonNullable<S[K]>;
-                /** Resolves the specified dependency with the specified default value if
-                 * the dependency is missing.
-                 * @param name The name of the dependency being resolved
-                 * @param def A default value to return in case of the specified dependency
-                 *   is missing.
-                 */
                 resolve<K extends keyof S, T>(name: K, def: T): NonNullable<S[K]> | T;
-                resolve<K extends keyof S, T>(name: K, def?: T): S[K] | T | undefined {
+                resolve<K extends keyof S, T>(name: K, def?: T): NonNullable<S[K]> | T | undefined {
                     const d = this._services[name];
                     if (d !== undefined) {
                         return this.activate(d, name.toString());
                     } else {
                         if (arguments.length > 1)
                             return def;
                         else
                             throw new Error(`Service ${String(name)} not found`);
                     }
                 }
                 /**
                  * registers services local to the the activation context
                  *
                  * @name{string} the name of the service
                  * @service{string} the service descriptor to register
                  */
-                register<K extends ConfigurableKeys<S>>(name: K, service: RegistrationMap<S>[K]) {
+                register<K extends keyof S>(name: K, service: DescriptorMap<S>[K]) {
                     argumentNotNull(name, "name");
+                    const d = this._services[name];
+                    if (d !== undefined && !d.configurable)
+                        throw new Error(`Service ${String(name)} can't be overridden`);
                     this._services[name] = service;
                 }
                 createLifetime<T>(): ILifetime<T> {
                     const id = nextId++;
                     return {
                         initialize() { },
                         has: () => id in this._cache,
-                        get: () => this._cache[id] as T,
+                        get: () => {
+                            const v = this._cache[id] as T;
+                            if (v === undefined || v === null)
+                                throw new Error("The value isn't present in the activation context");
+                            return v;
+                        },
                         store: item => {
                             this._cache[id] = item;
                         }
                     };
                 }
                 activate<T>(d: Descriptor<S, T>, name: string) {
                     // TODO: add logging
                     // if (trace.isLogEnabled())
                     //    trace.log("enter {0} {1}", name, d);
                     const ctx = this.enter(d, name);
                     const v = d.activate(ctx);
                     // if (trace.isLogEnabled())
                     //    trace.log(`leave ${name}`);
                     return v;
                 }
                 getStack(): ActivationContextInfo[] {
                     const stack = [{
                         name: this._name,
                         service: this._service.toString()
                     }];
                     return this._parent ?
                         stack.concat(this._parent.getStack()) :
                         stack;
                 }
                 private enter(service: Descriptor<S, unknown>, name: string) {
                     return new ActivationContext(
                         this._containerLifetimeManager,
-                        Object.create(this._services) as typeof this._services,
+                        service.hasOverrides ?
+                            Object.create(this._services) as typeof this._services :
+                            this._services,
                         name,
                         service,
                         this._cache
                     );
                 }
             }

src/main/ts/ActivationError.ts +19 0

             export interface ActivationItem {
                 name: string;
                 service: 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) {
                     this.message = "Failed to activate the service";
                     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.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 +38 -18

             import { ActivationContext } from "./ActivationContext";
             import { ActivationError } from "./ActivationError";
             import { ContainerBuilder } from "./ContainerBuilder";
-            import { RegistrationMap, ServiceContainer, ContainerServices, ServiceLocator, IContainerBuilder, Configurable, ContainerKeys} from "./interfaces";
+            import { DescriptorMap, IContainerBuilder, IDestroyable, ILifetimeManager, ServiceLocator } from "./interfaces";
-            import { LifetimeManager } from "./LifetimeManager";
-            export class Container<S extends Configurable<S>> implements ServiceContainer<S> {
+            export class Container<S> implements ServiceLocator<S>, IDestroyable {
-                private readonly _services: Partial<RegistrationMap<ContainerServices<S>>>;
+                private readonly _services: DescriptorMap<S>;
-                private readonly _lifetimeManager: LifetimeManager;
+                private readonly _lifetimeManager: ILifetimeManager;
                 private _disposed: boolean;
-                constructor(services: Partial<RegistrationMap<ContainerServices<S>>>, lifetimeManager: LifetimeManager) {
+                private readonly _onDestroyed: () => void;
-                    this._services = services;
-                    this._services.container = { activate: () => this as ContainerServices<S>["container"]};
+                constructor(services: DescriptorMap<S>, lifetimeManager: ILifetimeManager, destroyed: () => void) {
-                    this._services.childContainer = { activate: () => this.createChildContainer() as ContainerServices<S>["childContainer"] };
+                    this._services = {
+                        ...services,
+                        container: {
+                            configurable: false,
+                            activate: () => this
+                        },
+                        childContainer: {
+                            configurable: false,
+                            activate: () => this.createChildBuilder(),
+                        }
+                    };
                     this._disposed = false;
                     this._lifetimeManager = lifetimeManager;
+                    this._onDestroyed = destroyed;
                 }
-                createChildContainer(): IContainerBuilder<S> {
+                private _assertNotDestroyed() {
-                    return new ContainerBuilder(this._services);
+                    if (this._disposed)
+                        throw new Error("The container is destroyed");
                 }
-                resolve<K extends keyof ContainerServices<S>>(name: K): NonNullable<ContainerServices<S>[K]>;
+                createChildBuilder(): IContainerBuilder<S, keyof S> {
-                resolve<K extends keyof ContainerServices<S>, T>(name: K, def: T): NonNullable<ContainerServices<S>[K]> | T;
+                    this._assertNotDestroyed();
-                resolve<K extends keyof ContainerServices<S>, T>(name: K, def?: T) {
-                    // TODO: add logging
+                    const lifetime = this._lifetimeManager.create<IDestroyable>();
-                    // trace.debug("resolve {0}", name);
+                    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];
                     if (d === undefined) {
                         if (arguments.length > 1)
                             return def;
                         else
                             throw new Error(`Service '${String(name)}' isn't found`);
                     } else {
                         const context = new ActivationContext(this._lifetimeManager, 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)();
                 }
             }

src/main/ts/ContainerBuilder.ts +35 -14

             import { Container } from "./Container";
             import { DescriptorBuilder } from "./DescriptorBuilder";
-            import { Configurable, ConfigurableKeys, ContainerServices, Descriptor, IContainerBuilder, IDescriptorBuilder, RegistrationMap, ServiceContainer } from "./interfaces";
+            import { Descriptor, IContainerBuilder, IDescriptorBuilder, DescriptorMap, ServiceLocator, ILifetime, IDestroyable } from "./interfaces";
-            import { LifetimeManager } from "./LifetimeManager";
+            import { emptyLifetime, LifetimeManager } from "./LifetimeManager";
+            import { isDestroyable } from "./traits";
-            export class ContainerBuilder<S extends Configurable<S>> implements IContainerBuilder<S>{
+            /**
+             * 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: Partial<RegistrationMap<ContainerServices<S>>>;
+                private readonly _services: DescriptorMap<S>;
                 private readonly _lifetimeManager = new LifetimeManager();
-                constructor(parentServices?: object) {
+                private readonly _lifetime: ILifetime<IDestroyable>;
-                    this._services = Object.create(parentServices ? parentServices : null) as object;
+                constructor(parentServices?: DescriptorMap<S>, lifetime?: ILifetime<IDestroyable>) {
+                    this._services = Object.create(parentServices ? parentServices : null) as DescriptorMap<S>;
+                    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);
                 }
-                createServiceBuilder<K extends keyof S>(name: K): IDescriptorBuilder<ContainerServices<S>, NonNullable<S[K]>, object, keyof S> {
+                build(): ServiceLocator<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);
+                    const lifetime = this._lifetime;
+                    const detach = isDestroyable(lifetime) ? () => lifetime.destroy() : () => void (0);
+                    const container = new Container(this._services, this._lifetimeManager, detach);
+                    lifetime.store(container);
+                    return container;
                 }
-                private readonly _register = <K extends ConfigurableKeys<S>>(name: K) => (descriptor: Descriptor<S, NonNullable<S[K]>>) => {
+                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 +39 -35

-            import { RegistrationBuilder, LifetimeContainer, ConfigurableKeys, IDescriptorBuilder, Ref, Resolved, DepsMap } from "./interfaces";
+            import { BuildDescriptorFn, IDescriptorBuilder, DepsMap, Resolve, DescriptorMap } from "./interfaces";
             import { Descriptor, ILifetime, ActivationType } from "./interfaces";
-            import { DescriptorImpl, RegistrationOverridesMap } from "./DescriptorImpl";
+            import { DescriptorImpl } from "./DescriptorImpl";
-            import { LifetimeManager } from "./LifetimeManager";
+            import { contextLifetime, emptyLifetime, hierarchyLifetime, LifetimeManager, singletonLifetime } from "./LifetimeManager";
-            import { each, isKey, isPromise, isString, key, oid } from "./traits";
+            import { each, isPromise, isString, key, oid } from "./traits";
             /**
              * @template {S} Карта доступных зависимостей, как правило `ContainerServices`
              * @template {T} Тип сервиса
              */
-            export class DescriptorBuilder<S extends object, T, R extends object, O extends keyof S> implements IDescriptorBuilder<S, T, R, O> {
+            export class DescriptorBuilder<S, T, R, U extends keyof S> implements IDescriptorBuilder<S, T, R, U> {
                 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 readonly _refs: DepsMap<R>;
-                private _lifetime = LifetimeManager.empty<T>();
+                private _lifetime = emptyLifetime<T>();
-                private _overrides: RegistrationOverridesMap<S>;
+                private _overrides: DescriptorMap<S>;
                 private _cleanup?: (item: T) => void;
-                private _factory?: (refs: R) => T;
+                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 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 & {
+                /** Declares dependencies to be consumed in the factory method */
-                        [k in keyof X]:
+                wants<X extends DepsMap<S> & Record<keyof R & keyof X, never>>(refs: X):
-                        X[k] extends keyof S ? NonNullable<S[X[k]]> :
+                    IDescriptorBuilder<S, T, R & { [k in keyof X]: Resolve<S, X[k]>; }, U> {
-                        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]:
+                        [k in keyof X]: Resolve<S, X[k]>;
-                        X[k] extends keyof S ? NonNullable<S[X[k]]> :
+                    }, U>;
-                        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 {
+                /** 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 O>(name: K, builder: RegistrationBuilder<S, NonNullable<S[K]>>): this;
+                override<K extends U>(name: K, builder: BuildDescriptorFn<S, NonNullable<S[K]>, U>): this;
-                override<K extends O>(services: { [k in K]: RegistrationBuilder<S, NonNullable<S[k]>> }): this;
+                override<K extends U>(services: { [k in K]: BuildDescriptorFn<S, NonNullable<S[k]>, U> }): this;
-                override<K extends O>(nameOrServices: K | { [name in K]: RegistrationBuilder<S, NonNullable<S[K]>> }, builder?: RegistrationBuilder<S, NonNullable<S[K]>>): 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 (isKey(nameOrServices)) {
+                    if (typeof nameOrServices !== "object") {
                         if (builder) {
                             this._defer();
-                            const d = new DescriptorBuilder<S, NonNullable<S[K]>, object, O>(
+                            const d = new DescriptorBuilder<S, NonNullable<S[K]>, object, U>(
                                 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;
                 }
+                /** 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;
                 }
-                value(v: T): void {
+                /** 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 this._lifetimeManager.create();
                         case "hierarchy":
-                            return LifetimeManager.hierarchyLifetime();
+                            return hierarchyLifetime();
                         case "context":
-                            return LifetimeManager.contextLifetime();
+                            return contextLifetime();
                         case "singleton": {
                             if (!typeId)
                                 throw Error("The singleton activation requires a typeId");
                             const _oid = isString(typeId) ? typeId : oid(typeId);
+                            return singletonLifetime(_oid);
-                            return LifetimeManager.singletonLifetime(_oid);
                         }
                         default:
-                            return LifetimeManager.empty();
+                            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,
+                            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 +21 -19

-            import { Descriptor, ILifetime, DepsMap, Ref, IActivationContext } from "./interfaces";
+            import { Descriptor, ILifetime, DepsMap, IActivationContext, DescriptorMap } from "./interfaces";
-            import { each, isKey, key } from "./traits";
+            import { each, key } from "./traits";
-            export type RegistrationOverridesMap<S extends object> = { [k in keyof S]?: Descriptor<S, NonNullable<S[k]>> };
+            export interface DescriptorImplArgs<S, T> {
-            export interface DescriptorImplArgs<S extends object, T> {
                 lifetime: ILifetime<T>;
-                factory: (refs: Record<key, never>) => T;
+                factory: (refs: Record<key, unknown>) => NonNullable<T>;
-                cleanup?: (item: T) => void;
+                cleanup?: (item: NonNullable<T>) => void;
-                overrides?: RegistrationOverridesMap<S>;
+                overrides?: DescriptorMap<S>;
-                dependencies?: DepsMap<key, keyof S>;
+                dependencies?: DepsMap<S>;
             }
-            export class DescriptorImpl<S extends object, T> implements Descriptor<S, T> {
+            export class DescriptorImpl<S, T> implements Descriptor<S, T> {
-                private readonly _overrides?: RegistrationOverridesMap<S>;
+                private readonly _overrides?: DescriptorMap<S>;
                 private readonly _lifetime: ILifetime<T>;
-                private readonly _factory: (refs: Record<key, never>) => T;
+                private readonly _factory: (refs: Record<key, unknown>) => NonNullable<T>;
+                private readonly _cleanup?: (item: NonNullable<T>) => void;
-                private readonly _cleanup?: (item: T) => void;
+                private readonly _deps?: DepsMap<S>;
-                private readonly _deps?: DepsMap<key, keyof 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>): T {
+                activate(context: IActivationContext<S>): NonNullable<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>) => {
+                    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 makeRefs = (deps: typeof this._deps) => deps ?
                         Object.keys(deps)
                             .map(k => {
                                 const ref = deps[k];
-                                return isKey(ref) ?
+                                return typeof ref !== "object" ?
                                     { [k]: resolve({ name: ref }) } :
                                     { [k]: resolve(ref) };
                             })
-                            .reduce((a, p) => ({ ...a, ...p }), {} ) as Record<key, never>:
+                            .reduce((a, p) => ({ ...a, ...p }), {} ):
-                        {} 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/FluentConfiguration.ts +16 -15

-            import { DescriptorBuilder } from "./DescriptorBuilder";
+            import {  ConfigurationMap, ConfigurationMapConstraint, ContainerServices, ContainerServicesConstraint, ExtractRequiredKeys, IContainerBuilder } from "./interfaces";
-            import { ConfigurableKeys, ContainerServices, RegistrationBuildersMap, ExtractRequired, IContainerBuilder } from "./interfaces";
-            import { ServiceContainer } from "./interfaces";
             import { argumentNotNull, each, isKey } from "./traits";
-            export class FluentConfiguration<S, Y extends ConfigurableKeys<S> = ConfigurableKeys<S>> {
+            type ContainerExtensionConstraint<X, S> = ContainerServicesConstraint<Pick<S, keyof X & keyof S>>;
-                private _builders: Partial<RegistrationBuildersMap<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 Pick<S, keyof D & keyof S>>(): FluentConfiguration<S & D, Y | ConfigurableKeys<D>> {
+                declare<D extends ContainerExtensionConstraint<D,S>>(): FluentConfiguration<S & D, Y | keyof D> {
-                    return this as FluentConfiguration<S & D, Y | ConfigurableKeys<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 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: RegistrationBuildersMap<S>[K]): FluentConfiguration<S, Exclude<Y, K>>;
+                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<K extends Y>(config: RegistrationBuildersMap<S, K>): FluentConfiguration<S, Exclude<Y, K>>;
+                register<X extends ConfigurationMapConstraint<ContainerServices<S>, Y, keyof X>>(config: X): FluentConfiguration<S, Exclude<Y, keyof X>>;
-                register<K extends Y>(nameOrConfig: K | RegistrationBuildersMap<S, K>, builder?: RegistrationBuildersMap<S>[K]) {
+                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>>;
+                    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<M extends ExtractRequired<S,Y>>(missing: M) {
+                done(...args: ExtractRequiredKeys<S, Y> extends never ? [] : [services: {[ k in ExtractRequiredKeys<S, Y>]: "required"}]) {
+                //done() {
                     return this;
                 }
-                configure<T extends IContainerBuilder<S>>(builder: T) {
+                configure<C extends IContainerBuilder<ContainerServices<S>, keyof S>>(builder: C) {
                     each(this._builders, (v, k) => {
                         v(builder.createServiceBuilder(k));
                     });
-                    builder.build() as T & ServiceContainer<S>;
+                    return builder.build();
                 }
             }

src/main/ts/LifetimeManager.ts +42 -36

-            import { IActivationContext, IDestroyable, ILifetime } from "./interfaces";
+            import { IActivationContext, ILifetime, ILifetimeManager } from "./interfaces";
             import { ActivationContext } from "./ActivationContext";
             import { argumentNotNull, isDestroyable } from "./traits";
             const safeCall = (item: () => void) => {
                 try {
                     item();
                 } catch {
                     // silence!
                 }
             };
-            const emptyLifetime = Object.freeze({
+            const _emptyLifetime = Object.freeze({
                 has() {
                     return false;
                 },
                 initialize() {
                 },
                 get() {
                     throw new Error("The specified item isn't registered with this lifetime manager");
                 },
                 store() {
                     // does nothing
                 },
                 toString() {
                     return `[object EmptyLifetime]`;
                 }
             });
-            const unknownLifetime = Object.freeze({
+            const _unknownLifetime = Object.freeze({
                 has() {
                     return false;
                 },
                 initialize() {
                     throw new Error("Can't call initialize on the unknown lifetime object");
                 },
                 get() {
                     throw new Error("The lifetime object isn't initialized");
                 },
                 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 IDestroyable {
+            export class LifetimeManager implements ILifetimeManager {
                 private _cleanup: (() => void)[] = [];
                 private readonly _cache: { [K: string]: unknown } = {};
                 private _destroyed = false;
                 private readonly _pending: { [K: string]: unknown } = {};
-                create<T>(): ILifetime<T> {
+                create<T>(): ILifetime<T> & { remove(): void; } {
                     const id = ++nextId;
                     return {
                         has: () => id in this._cache,
                         get: () => {
-                            const t = this._cache[id];
+                            const t = this._cache[id] as T;
-                            if (t === undefined)
+                            if (t === undefined || t === null)
                                 throw new Error(`The item with with the key ${id} isn't found`);
-                            return t as T;
+                            return t;
                         },
                         initialize: () => {
                             if (this._pending[id])
                                 throw Error(`Cyclic reference detected: the item with the key ${id} is already activating.`);
                             this._pending[id] = true;
                         },
-                        store: (item: T, cleanup?: (item: T) => void) => {
+                        store: (item: NonNullable<T>, cleanup?: (item: NonNullable<T>) => void) => {
-                            argumentNotNull(id, "id");
-                            argumentNotNull(item, "item");
                             if (id in this._cache)
                                 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];
                             this._cache[id] = item;
-                            if (this._destroyed)
-                                throw new Error("Lifetime manager is destroyed");
                             if (cleanup) {
                                 this._cleanup.push(() => cleanup(item));
                             } else if (isDestroyable(item)) {
                                 this._cleanup.push(() => item.destroy());
                             }
+                        },
+                        remove: () => {
+                            if (this._pending[id])
+                                throw new Error(`The item '${id}' can't be removed before it has been stored`);
+                            delete this._cache[id];
                         }
                     };
                 }
                 destroy() {
                     if (!this._destroyed) {
                         this._destroyed = true;
                         this._cleanup.forEach(safeCall);
                         this._cleanup.length = 0;
                     }
                 }
-                static empty<T>(): ILifetime<T> {
-                    return emptyLifetime;
             }
-                static hierarchyLifetime<T>() {
+            export const emptyLifetime = <T>(): ILifetime<T> => {
-                    let _lifetime: ILifetime<T> = unknownLifetime;
+                return _emptyLifetime;
+            };
+            export const hierarchyLifetime = <T>(): ILifetime<T> => {
+                let _lifetime: ILifetime<T> = _unknownLifetime;
                 return {
                     initialize(context: IActivationContext<object>) {
-                            if (_lifetime !== unknownLifetime)
+                        if (_lifetime !== _unknownLifetime)
                             throw new Error("Cyclic reference activation detected");
                         _lifetime = context.createContainerLifetime<T>();
                     },
                     get() {
                         return _lifetime.get();
                     },
                     has() {
                         return _lifetime.has();
                     },
-                        store(item: T, cleanup?: (item: T) => void) {
+                    store(item: NonNullable<T>, cleanup?: (item: NonNullable<T>) => void) {
                         return _lifetime.store(item, cleanup);
                     },
                     toString() {
                         return `[object HierarchyLifetime, has=${String(this.has())}]`;
                     }
                 };
+            };
-                static contextLifetime<T>() {
+            export const contextLifetime = <T>(): ILifetime<T> => {
-                    let _lifetime: ILifetime<T> = unknownLifetime;
+                let _lifetime: ILifetime<T> = _unknownLifetime;
                 return {
                     initialize(context: ActivationContext<object>) {
-                            if (_lifetime !== unknownLifetime)
+                        if (_lifetime !== _unknownLifetime)
                             throw new Error("Cyclic reference detected");
                         _lifetime = context.createLifetime();
                     },
                     get() {
                         return _lifetime.get();
                     },
                     has() {
                         return _lifetime.has();
                     },
-                        store(item: T) {
+                    store(item: NonNullable<T>) {
                         _lifetime.store(item);
                     },
                     toString() {
                         return `[object ContextLifetime, has=${String(this.has())}]`;
                     }
                 };
+            };
-                static singletonLifetime<T>(typeId: string) {
+            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 T;
+                        return singletons[typeId] as NonNullable<T>;
                     },
                     initialize() {
                         if (pending)
                             throw new Error("Cyclic reference detected");
                         pending = true;
                     },
-                        store(item: T) {
+                    store(item: NonNullable<T>) {
                         singletons[typeId] = item;
                         pending = false;
                     },
                     toString() {
                         return `[object SingletonLifetime, has=${String(this.has())}, typeId=${typeId}]`;
                     }
                 };
+            };
-                static containerLifetime<T>(container: { createLifetime<X>(): ILifetime<X>}) {
+            export const containerLifetime = <T>(container: { createLifetime<X>(): ILifetime<X> }) => {
-                    let _lifetime: ILifetime<T> = unknownLifetime;
+                let _lifetime: ILifetime<T> = _unknownLifetime;
                 return {
                     initialize() {
-                            if (_lifetime !== unknownLifetime)
+                        if (_lifetime !== _unknownLifetime)
                             throw new Error("Cyclic reference detected");
                         _lifetime = container.createLifetime();
                     },
                     get() {
                         return _lifetime.get();
                     },
                     has() {
                         return _lifetime.has();
                     },
-                        store(item: T) {
+                    store(item: NonNullable<T>) {
                         _lifetime.store(item);
                     },
                     toString() {
                         return `[object ContainerLifetime, has=${String(_lifetime.has())}]`;
                     }
                 };
+            };

src/main/ts/interfaces.ts +126 -51

             import { key } from "./traits";
             export interface IDestroyable {
                 destroy(): void;
             }
             /**
              * @template S Карта доступных зависимостей
              */
             export interface Resolver<S> {
                 /**
                  * Функция для разрешения зависимостей, поддерживает создание фабричных методов,
                  * отложенную активацию и значение по-умолчанию для сервисов
-                 * @template K Ключ сервиса из {@link S}
+                 * @template K Ключ сервиса из {@linkcode S}
-                 * @template O Тип параметра {@link opts} используется для выведения типа
+                 * @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; default?: unknown }>(name: K, opts?: O): () => (O extends { default: infer T } ? T : never) | NonNullable<S[K]>;
+                <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; default?: unknown }>(name: K, opts?: O): (O extends { default: infer T } ? T : never) | NonNullable<S[K]>;
+                <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, boolean, S[k]>;
+                [k in keyof S]: Ref<k, S[k]>;
             }[keyof S];
-            export type Ref<K extends key, L extends boolean, D> = { name: K, lazy?: L, default?: D | null };
+            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, infer L, unknown> ?
+                R extends Ref<infer K, unknown> ?
-                K extends keyof S ? Lazy<NonNullable<S[K]> | InferDefault<R>, L> :
+                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, O extends keyof S> {
+            export interface IDescriptorBuilder<S, T, R, U extends keyof S> {
                 /** Указывает фабрика для создания экземпляра сервиса, фабрика передается
                  * в виде параметра. При вызове фабрике будет передан объект с зависимостями,
                  * которые были предварительно указаны вызовами метода `wants(...)`
                  *
                  * Вызов данного метода завершает конфигурирование сервиса.
                  *
-                 * @param f Фабрика для создания экземпляра сервиса
+                 * @param f Фабрика для создания экземпляра сервиса.
                  */
-                factory(f: (refs: R) => T): void;
+                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]>;
-                    }, O>
+                    }, U>
-                override<K extends O>(name: K, builder: RegistrationBuilder<S, NonNullable<S[K]>>): this;
+                override<K extends U>(name: K, builder: BuildDescriptorFn<S, S[K], U>): this;
-                override<K extends O>(services: { [name in K]: RegistrationBuilder<S, NonNullable<S[K]>> }): 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: T): void;
+                value(v: NonNullable<T>): void;
             }
-            export type RegistrationBuilder<S, T> = (d: IDescriptorBuilder<S, T, object, ConfigurableKeys<S>>) => void;
+            export type BuildDescriptorFn<S, T, U extends keyof S> = (d: IDescriptorBuilder<S, T, Record<never, never>, U>) => void;
-            export type RegistrationBuildersMap<S extends Configurable<S>, K extends keyof S = keyof S> = {
+            /**
-                [k in K]-?: RegistrationBuilder<ContainerServices<S>, NonNullable<S[k]>>
+             * Конфигурация контейнера, состоит из набора функций, которые выполняют конфигурацию.
+             *
+             * Все параметры конфигурации являются обязательными, если требуется ввести
+             * необязательные параметры, то нужно ограничить параметр типа {@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> {
-                activate(context: IActivationContext<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> {
                 createLifetime<T>(): ILifetime<T>;
                 createContainerLifetime<T>(): ILifetime<T>;
-            export type RegistrationMap<S, K extends keyof S = keyof S> = {
+                register<K extends keyof S>(name: K, service: DescriptorMap<S>[K]): void;
-                [k in K]-?: Descriptor<S, S[k]>;
-            };
-            export interface ContainerProvided<S> {
-                container: ServiceLocator<ContainerServices<S>>;
-                childContainer: IContainerBuilder<S>;
             }
-            export type Configurable<S> = { [k in keyof S]: k extends ProvidedKeys ? never : S[k]; };
+            /**
+             * 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]>;
+            };
-            export type ProvidedKeys = keyof ContainerProvided<never>;
+            type ContainerKeys = keyof ContainerProvided<object>;
+            export type ContainerProvided<S extends ContainerServicesConstraint<S>> = {
+                container: ServiceLocator<ContainerServices<S>>;
+                childContainer: IContainerBuilder<ContainerServices<S>, Exclude<keyof S, ContainerKeys>>;
+            };
-            export type ContainerServices<S> =
-                { [k in keyof S as k extends ProvidedKeys ? never: k]: S[k] } &
-                ContainerProvided<S>;
-            export type ConfigurableKeys<S> = Exclude<keyof S, ProvidedKeys>;
+            /**
+             * Таблица сервисов, которые предоставляет контейнер.
+             *
+             * Сервисы, предоставляемые контейнером не могут быть 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
+            };
-            export type ConfigurableServices<S> = Pick<S, ConfigurableKeys<S>>;
-            export type ContainerKeys<S> = keyof S | ProvidedKeys;
+            /**
+             * 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 ServiceContainer<S> extends
+            export interface IContainerBuilder<S, U extends keyof S> {
-                ServiceLocator<ContainerServices<S>>,
+                createServiceBuilder<K extends U>(name: K):
-                IDestroyable {
+                    IDescriptorBuilder<S, S[K], Record<never, never>, U>;
-                createChildContainer(): IContainerBuilder<S>;
+                build(): ServiceLocator<S>;
-            export interface IContainerBuilder<S> {
-                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;
+                get(): NonNullable<T>;
+                initialize(context: IActivationContext<unknown>): void;
+                store(item: NonNullable<T>, cleanup?: (item: NonNullable<T>) => void): void;
-                initialize(context: IActivationContext<object>): void;
+                toString(): string;
+            }
-                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];
  No newline at end of file

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

             import { FluentConfiguration } from "./FluentConfiguration";
-            import { IDestroyable } from "./interfaces";
+            import { ContainerServices, ContainerServicesConstraint, IDestroyable } from "./interfaces";
-            export function fluent<S = {}>() {
+            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}`);
             };

src/test/ts/t/container.ts +26 -19

             /* eslint max-classes-per-file: ["error", 20] */
             import { describe, it } from "mocha";
             import { Container } from "../Container";
             import { ContainerBuilder } from "../ContainerBuilder";
-            import { ConfigurableKeys, ContainerProvided, ContainerServices, DepsMap, Refs, Resolver } from "../interfaces";
+            import { ContainerServices, DepsMap, IContainerBuilder, Refs, Resolver } from "../interfaces";
             import { fluent } from "../traits";
             class Foo {
                 foo = "foo";
             }
             class Bar {
                 bar = "bar";
                 constructor(foo?: () => Foo) { }
             }
             interface Services {
                 foo: Foo;
                 bar?: Bar;
                 baz: Foo;
-                container: string;
+                box?: Foo;
+                //container: string;
             }
             interface ServicesB {
                 // will give errors
                 // baz: Bar;
                 baz: Foo;
                 zoo?: Foo;
             }
             declare const resolver: Resolver<Services>;
-            const foo = resolver("foo", {lazy: true});
+            const foo = resolver("foo", { lazy: true, default: null });
             const mmap = <X extends DepsMap<Services>>(m: X) => { };
             declare const refs: Refs<Services>;
             if (refs && refs.name === "foo") {
                 refs.default;
             }
             declare const x: ContainerServices<Services>;
             x.container.resolve("container");
             mmap({
                 fooz: { name: "foo", lazy: false, default: undefined },
                 ooz: "bar"
             });
             interface SharedServices {
                 foo: Foo;
                 bar?: Bar;
                 baz: Bar;
             }
-            const config = fluent()
+            const config = fluent<Services>()
-                .declare<Services>()
                 .declare<ServicesB>()
                 .register({
-                    zoo: it => {},
+                    zoo: it => it.value(new Foo()),
                     bar: it => it
                         .lifetime("context") // тип активации, время жизни
                         .wants({
-                            zoo: "zoo", // зависимость
+                            self: "container",
+                            childContainer: "childContainer",
                             bar: "bar",
+                            foo$: { name: "foo", lazy: true } // отложенная активация, фабричный метод
-                            $zoo: { name: "foo", lazy: true, } // отложенная активация,
-                            //фабричный метод
                         })
-                        .wants({
+                        .override({ // переопределение сервиса
-                            zoom: "bar"
+                            box: it => it.factory(() => new Foo())
                         })
-                        .factory(({ $zoo, zoo }) => // фабрика получает объект с именованными зависимостями
+                        .factory(({ foo$, bar, self, childContainer }) => // фабрика получает объект с именованными зависимостями
-                            // удобно для деструктурирования
+                            new Bar(foo$) // создается экземпляр сервиса
-                            new Bar($zoo) // создается экземпляр сервиса
                         ),
                     foo: it => it.factory(() => new Foo()),
-                    baz: it => it.value(new Foo())
+                    baz: it => it.value(new Foo()),
+                    //box: it => it.factory(() => new Foo())
                 })
-                .done({});
+                .done();
+            declare const container: IContainerBuilder<ContainerServices<Services>, keyof Services>;
-            declare const container: ContainerBuilder<{}>;
+            const v = container.build().resolve("foo");
+            if (v) {
+                // noop
+            }
             const c2 = config.configure(container);
             c2.resolve("foo");
-            declare const m :ContainerServices<{foo: Foo}>["container"];
+            declare const m: ContainerServices<{ foo?: Foo }>["container"];
             m.resolve("container").resolve("container").resolve("foo");

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