implab/implabjs-di Commit - r1:a51ea59f0423

working on fluent configuration

cin -

r1:a51ea59f0423 default

parent child

Context file:

r1:a51ea59f0423

Expand all files

The requested changes are too big and content was truncated. Show full diff

.vscode/settings.json created 644 +3 0

@@ -0,0 +1,3
	1	{
	2	"java.configuration.updateBuildConfiguration": "automatic"
	3	} No newline at end of file

package-lock.json created 644 0 0

	1	NO CONTENT: new file 100644			NO CONTENT: new file 100644
The requested commit or file is too big and content was truncated. Show full diff

src/main/ts/ContextResolver.ts created 644 +19 0

@@ -0,0 +1,19
	1	import { ActivationContext } from "./ActivationContext";
	2
	3	export class ContextResolver<S extends object> {
	4	private readonly _context: ActivationContext<S>;
	5
	6	constructor(context: ActivationContext<S>) {
	7	this._context = context;
	8	}
	9
	10	resolve<K extends keyof S, O extends { lazy: true}>(name: K, opts?: O): () => (O extends { default: infer T } ? T : never) \| NonNullable<S[K]>;
	11	resolve<K extends keyof S, O extends { lazy?: false}>(name: K, opts?: O): (O extends { default: infer T } ? T : never) \| NonNullable<S[K]>;
	12	resolve(name: keyof S, opts?: {lazy?: boolean, default?: unknown}) {
	13	if (opts && opts.lazy) {
	14	return () => "default" in opts ? this._context.resolve(name, opts.default) : this._context.resolve(name);
	15	} else {
	16	return opts && "default" in opts ? this._context.resolve(name, opts.default) : this._context.resolve(name);
	17	}
	18	}
	19	}

src/test/ts/index.ts created 644 +1 0

	@@ -0,0 +1,1
				1	import "./t/container"; No newline at end of file

src/test/ts/t/container.ts created 644 +58 0

@@ -0,0 +1,58
	1	/* eslint max-classes-per-file: ["error", 20] */
	2	import { describe, it } from "mocha";
	3	import {LifetimeManager} from "../LifetimeManager";
	4	import {Container} from "../Container";
	5	import { fluent } from "../traits";
	6
	7	class Foo {
	8	foo = "foo";
	9	}
	10
	11	class Bar {
	12	bar = "bar";
	13
	14	constructor(foo?: () => Foo) {}
	15	}
	16
	17	interface Services {
	18	foo: Foo;
	19
	20	bar?: Bar;
	21
	22	baz: Foo;
	23	}
	24
	25	interface ServicesB {
	26	// will give errors
	27	// baz: Bar;
	28
	29	baz: Foo;
	30
	31	zoo?: Foo;
	32	}
	33
	34	interface SharedServices {
	35	foo: Foo;
	36
	37	bar?: Bar;
	38
	39	baz: Bar;
	40	}
	41
	42	const config = fluent()
	43	.declare<Services>()
	44	.declare<ServicesB>()
	45	.register({
	46	bar: it => it
	47	.lifetime("context")
	48	.factory($ => new Bar($("zoo", {lazy: true, default: new Foo()}))),
	49	foo: it => it.factory($ => new Foo()),
	50	baz: it => it.value(new Foo())
	51	})
	52	.done();
	53
	54	declare const container: Container<SharedServices>;
	55
	56	const c2 = config.apply(container);
	57
	58	c2.resolve("baz"); No newline at end of file

src/test/tsconfig.json created 644 +9 0

@@ -0,0 +1,9
	1	{
	2	"extends": "../tsconfig",
	3	"compilerOptions": {
	4	"rootDirs": [
	5	"ts",
	6	"../main/ts"
	7	]
	8	}
	9	} No newline at end of file

src/tsconfig.eslint.json created 644 +10 0

@@ -0,0 +1,10
	1	{
	2	"extends": "./tsconfig.json",
	3	"compilerOptions": {
	4	// ensure that nobody can accidentally use this config for a build
	5	"noEmit": true
	6	},
	7	"include": [
	8	"ts"
	9	]
	10	} No newline at end of file

.eslintrc.json +24 -19

@@ -1,27 +1,32
1	{	1	{
2	"env": {	2	"root": true,
3	"browser": true,	3	"extends": [
4	"commonjs": true,	4	"plugin:react/recommended",
5	"amd": true,	5	"eslint:recommended",
6	"node": true	6	"plugin:@typescript-eslint/eslint-recommended",
7	},	7	"plugin:@typescript-eslint/recommended",
		8	"plugin:@typescript-eslint/recommended-requiring-type-checking"
		9	],
		10	"parser": "@typescript-eslint/parser",
8	"parserOptions": {	11	"parserOptions": {
9	"ecmaFeatures": {	12	"ecmaFeatures": {
10	"jsx": true	13	"jsx": true
11	},	14	},
12	"sourceType": "script"	15	"ecmaVersion": 5,
		16	"tsconfigRootDir": "src",
		17	"project": ["tsconfig.eslint.json", "*/tsconfig.json"]
13	},	18	},
14	"extends": "eslint:recommended",	19	"plugins": [
		20	"@typescript-eslint"
		21	],
15	"rules": {	22	"rules": {
16	"no-const-assign": "warn",	23	"@typescript-eslint/no-empty-function": "off",
17	"no-this-before-super": "warn",	24	"max-classes-per-file": [
18	~~"no-undef"~~: "error",	25	"error",
19	"no-unreachable": "warn",	26	{ "ignoreExpressions": true, "max": 1 }
20	"no-unused-vars": "warn",	27	],
21	"constructor-super": "warn",	28	"@typescript-eslint/prefer-readonly": ["error"],
22	"valid-typeof": "warn",	29	"@typescript-eslint/semi": ["error"]
23	"semi" : "warn",	30
24	"no-invalid-this" : "error",
25	"no-console": "off"
26	}	31	}
27	} No newline at end of file	32	}

.hgignore +1 0

             syntax: glob
             .gradle/
             build/
+            node_modules/

build.gradle +9 -15

                     declaration = true
                     experimentalDecorators = true
                     strict = true
-                    // dojo-typings are sick
-                    skipLibCheck = true
-                    if(symbols != 'none') {
-                        sourceMap = true
-                        sourceRoot = "pack:${packageName}"
-                    if (flavour == 'node') {
                     module = "commonjs"
-                        target = "es2017"
-                        lib = ["es2017", "dom", "scripthost"]
-                    } else if (flavour == 'browser') {
-                        module = "amd"
                     target = "es5"
-                        lib = ["es5", "dom", "scripthost", "es2015.promise", "es2015.symbol", "es2015.iterable" ]
+                    lib = ["es2015", "dom", "scripthost"]
                 }
                 tscCmd = "$projectDir/node_modules/.bin/tsc"
                 tsLintCmd = "$projectDir/node_modules/.bin/tslint"
                 }
             }
+            task packSources {
+            }
             printVersion {
                 doLast {
                     println "packageName: $packageName";
                     println "symbols: $symbols";
                 }
             }
+            test {
+                commandLine "npx", "mocha", "${->typescript.testDir.get()}";
+            }
  No newline at end of file

package.json +18 -17

@@ -1,31 +1,32
1	{	1	{
2	"name": "@implab/di",	2	"name": "@implab/di",
3	"version": "0.0.1-dev",	3	"version": "0.0.1-dev",
4	"description": "Dependency injection, logging, simple and fast text template engine",	4	"description": "The lightweight dependency injection IoC",
5	"main": "main.js",	5	"main": "main.js",
6	"keywords": [	6	"keywords": [
7	"di",	7	"di",
8	"ioc",	8	"ioc",
9	"logging",
10	"template engine",
11	"dependency injection"	9	"dependency injection"
12	],	10	],
13	"author": "Implab team",	11	"author": "Implab team",
14	"license": "BSD-2-Clause",	12	"license": "BSD-2-Clause",
15	"repository": "https://~~bitbucket~~.org/implab/implabjs",	13	"repository": "https://code.implab.org/implab/implabjs-di",
16	"peerDependencies": {
17	"dojo": "^1.10.0"
18	},
19	"devDependencies": {	14	"devDependencies": {
20	"@types/~~node~~": "~~^8.0.0~~",	15	"@types/chai": "4.3.1",
21	"@types/~~requirejs~~": "~~~2.1.3~~1",	16	"@types/mocha": "9.1.1",
22	"@types/~~tap~~e": "~~~4.2.33~~",	17	"@types/node": "~8.0.0",
23	"dojo": "~1.10.0",	18	"@types/tape": "~4.13.2",
24	"dojo-typings": "^1.11.9",	19	"@typescript-eslint/eslint-plugin": "^5.23.0",
25	"eslint": "~~6.1~~.0",	20	"@typescript-eslint/parser": "^5.23.0",
26	"requirejs": "latest",	21	"chai": "~4.3.6",
27	"~~tap~~e": "~~~4.11~~.0",	22	"eslint": "^8.15.0",
28	"~~tslint~~": "~~5.18~~.0",	23	"eslint-config-standard": "^17.0.0",
29	"typescript": "~4.1.5"	24	"eslint-plugin-import": "^2.26.0",
		25	"eslint-plugin-n": "^15.2.0",
		26	"eslint-plugin-promise": "^6.0.0",
		27	"eslint-plugin-react": "^7.29.4",
		28	"mocha": "~10.0.0",
		29	"tape": "~5.5.3",
		30	"typescript": "~4.6.4"
30	}	31	}
31	}	32	}

readme.md +2 -26

@@ -1,27 +1,3
1	# Implabjs-~~core~~	1	# Implabjs-di
2
3	Набор стандартных библиотек для создания приложений со сложным функционалом.
4	Данную библиотеку можно использовать как для разработки приложений, которые
5	будут работать в среде браузеров, так и в серверных средах.
6
7	Библиотека написана на TypeScript, некоторая часть на JavaScript, но постепенно
8	планируется перейти полностью на использование TypeScript
9
10	Более подробная документация доступна по ссылке: <https://bitbucket.org/implab/implabjs-core/src/default/docs/ru/>
11
12	## Основные компоненты
13		2
14	### DI	3	Простой контейнер для внедрения зависимостей
15
16	Контейнер для внедрения зависимостей, позволяет гибко описывать структуру
17	приложения и создавать слабосвязанные компоненты.
18
19	### LOG
20
21	Средства журналирования похожие на JLog, позволяют эффективно вести журнал
22	выполнения программы.
23
24	### Cancellations
25
26	Специальные маркеры для отмены асинхронных операций, по аналогии с .NET
27	CancelationToken.

src/main/ts/ActivationContext.ts +36 -61

-            import { TraceSource } from "../log/TraceSource";
+            import { Descriptor, ILifetime, RegistrationMap, LifetimeContainer, ConfigurableKeys } from "./interfaces";
-            import { argumentNotEmptyString } from "../safe";
+            import { argumentNotNull } from "./traits";
-            import { Descriptor, ContainerServiceMap, ContainerKeys, TypeOfService, ILifetime, ServiceContainer } from "./interfaces";
-            import { MapOf } from "../interfaces";
-            const trace = TraceSource.get("@implab/core/di/ActivationContext");
             export interface ActivationContextInfo {
                 name: string;
              * tracks services with `context` activation type.
              */
             export class ActivationContext<S extends object> {
-                _cache: MapOf<any>;
+                private _cache: { [K: string]: unknown };
-                _services: ContainerServiceMap<S>;
+                private _services: Partial<RegistrationMap<S>>;
-                _visited: MapOf<any>;
+                private _name: string;
-                _name: string;
+                private _service: Descriptor<S, unknown>;
-                _service: Descriptor<S, any>;
-                _container: ServiceContainer<S>;
+                private readonly _containerLifetimeManager: LifetimeContainer;
-                _parent: ActivationContext<S> | undefined;
+                private _parent: ActivationContext<S> | undefined;
                 /** Creates a new activation context with the specified parameters.
-                 * @param container the container which starts the activation process
+                 * @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(container: ServiceContainer<S>, services: ContainerServiceMap<S>, name: string, service: Descriptor<S, any>) {
+                constructor(containerLifetimeManager: LifetimeContainer, services: Partial<RegistrationMap<S>>, name: string, service: Descriptor<S, unknown>) {
                     this._name = name;
                     this._service = service;
-                    this._visited = {};
                     this._cache = {};
                     this._services = services;
-                    this._container = container;
+                    this._containerLifetimeManager = containerLifetimeManager;
                 }
                 /** the name of the current resolving dependency */
                     return this._name;
                 }
-                /** Returns the container for which 'resolve' method was called */
+                createContainerLifetime<T>() {
-                getContainer() {
+                    return this._containerLifetimeManager.createLifetime<T>();
-                    return this._container;
                 }
                 /** Resolves the specified dependency in the current context
                  * @param name The name of the dependency being resolved
                  */
-                resolve<K extends ContainerKeys<S>>(name: K): TypeOfService<S, K>;
+                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 def A default value to return in case of the specified dependency
                  *   is missing.
                  */
-                resolve<K extends ContainerKeys<S>, T>(name: K, def: T): TypeOfService<S, K> | T;
+                resolve<K extends keyof S, T>(name: K, def: T): NonNullable<S[K]> | T;
-                /** Resolves the specified dependency and returns undefined in case if the
+                resolve<K extends keyof S, T>(name: K, def?: T): S[K] | T | undefined {
-                 * dependency is missing.
-                 * @param name The name of the dependency being resolved
-                 */
-                resolve<K extends ContainerKeys<S>>(name: K, def: undefined): TypeOfService<S, K> | undefined;
-                resolve<K extends ContainerKeys<S>, T>(name: K, def?: T): TypeOfService<S, K> | T | undefined {
                     const d = this._services[name];
                     if (d !== undefined) {
                         if (arguments.length > 1)
                             return def;
                         else
-                            throw new Error(`Service ${name} not found`);
+                            throw new Error(`Service ${String(name)} not found`);
                     }
                 }
                  * @name{string} the name of the service
                  * @service{string} the service descriptor to register
                  */
-                register<K extends keyof S>(name: K, service: Descriptor<S, S[K]>) {
+                register<K extends ConfigurableKeys<S>>(name: K, service: RegistrationMap<S>[K]) {
-                    argumentNotEmptyString(name, "name");
+                    argumentNotNull(name, "name");
-                    this._services[name] = service as any;
+                    this._services[name] = service;
                 }
-                createLifetime(): ILifetime {
+                createLifetime<T>(): ILifetime<T> {
                     const id = nextId++;
-                    const me = this;
                     return {
-                        initialize() {
+                        initialize() {},
-                        },
+                        has: () => id in this._cache,
-                        has() {
+                        get: () => this._cache[id] as T,
-                            return id in me._cache;
+                        store: item => {
-                        },
+                            this._cache[id] = item;
-                        get() {
-                            return me._cache[id];
-                        },
-                        store(item: any) {
-                            me._cache[id] = item;
                         }
                     };
                 }
                 activate<T>(d: Descriptor<S, T>, name: string) {
-                    if (trace.isLogEnabled())
+                    // TODO: add logging
-                        trace.log("enter {0} {1}", name, d);
+                    // if (trace.isLogEnabled())
+                    //    trace.log("enter {0} {1}", name, d);
                     const ctx = this.enter(d, name);
                     const v = d.activate(ctx);
-                    if (trace.isLogEnabled())
+                    // if (trace.isLogEnabled())
-                        trace.log(`leave ${name}`);
+                    //    trace.log(`leave ${name}`);
                     return v;
                 }
-                visit(id: string) {
-                    const count = this._visited[id] || 0;
-                    this._visited[id] = count + 1;
-                    return count;
                 getStack(): ActivationContextInfo[] {
                     const stack = [{
                         name: this._name,
                         stack;
                 }
-                private enter(service: Descriptor<S, any>, name: string): this {
+                private enter(service: Descriptor<S, unknown>, name: string): this {
-                    const clone = Object.create(this);
+                    const clone = Object.create(this) as this;
                     clone._name = name;
-                    clone._services = Object.create(this._services);
+                    clone._services = Object.create(this._services) as typeof this._services;
                     clone._parent = this;
                     clone._service = service;
                     return clone;
                 /** Creates a clone for the current context, used to protect it from modifications */
                 clone(): this {
-                    const clone = Object.create(this);
+                    const clone = Object.create(this) as this;
-                    clone._services = Object.create(this._services);
+                    clone._services = Object.create(this._services) as typeof this._services;
                     return clone;
                 }
             }

src/main/ts/ActivationError.ts +7 -5

                 service: string;
-                innerException: any;
+                innerException: unknown;
                 message: string;
-                constructor(service: string, activationStack: ActivationItem[], innerException: any) {
+                constructor(service: string, activationStack: ActivationItem[], innerException: unknown) {
                     this.message = "Failed to activate the service";
                     this.activationStack = activationStack;
                     this.service = service;
                 toString() {
                     const parts = [this.message];
                     if (this.service)
-                        parts.push("when activating: " + this.service.toString());
+                        parts.push(`when activating: ${String(this.service)}`);
                     if (this.innerException)
-                        parts.push("caused by: " + this.innerException.toString());
+                        parts.push(`caused by: ${String(this.innerException)}`);
                     if (this.activationStack) {
                         parts.push("at");
+                        parts.push.apply(null,
                             this.activationStack
-                            .forEach(x => parts.push(`    ${x.name} ${x.service}`));
+                                .map(({ name, service }) => `    ${name} ${service}`)
+                        );
                     }

src/main/ts/Container.ts +30 -127

@@ -1,67 +1,58
1	import { ActivationContext } from "./ActivationContext";	1	import { ActivationContext } from "./ActivationContext";
2	import { ActivationError } from "./ActivationError";	2	import { ActivationError } from "./ActivationError";
3	import { ServiceMap, Descriptor, PartialServiceMap, ContainerServiceMap, ContainerKeys, TypeOfService, ServiceContainer } from "./interfaces";	3	import { RegistrationMap, ContainerKeys, ServiceContainer, ContainerServices, ConfigurableServices, ConfigurableKeys, ServiceLocator, Descriptor} from "./interfaces";
4	import { TraceSource } from "../log/TraceSource";
5	import { Configuration, RegistrationMap } from "./Configuration";
6	import { Cancellation } from "../Cancellation";
7	import { ICancellation } from "../interfaces";
8	import { isDescriptor } from "./traits";
9	import { LifetimeManager } from "./LifetimeManager";	4	import { LifetimeManager } from "./LifetimeManager";
10	import { each, is~~String~~ } from "../s~~afe~~";	5	import { each, isKey } from "./traits";
11	import { ContainerConfiguration, FluentRegistrations } from "./fluent/interfaces";
12	import { FluentConfiguration } from "./fluent/FluentConfiguration";
13
14	const trace = TraceSource.get("@implab/core/di/ActivationContext");
15		6
16	export class Container<S extends object = ~~any~~> implements ServiceContainer<S> {	7	export class Container<S extends object > implements ServiceContainer<S> {
17	readonly _services: ContainerService~~Map~~<S>;	8	private readonly _services: Partial<RegistrationMap<ContainerServices<S>>>;
18
19	readonly _lifetimeManager: LifetimeManager;
20		9
21	readonly _cleanup: (() => void)[];	10	private readonly _lifetimeManager: LifetimeManager;
22
23	readonly _root: Container<S>;
24		11
25	readonly _parent?: Container<S>;	12	private readonly _cleanup: (() => void)[];
26		13
27	_disposed: boolean;	14	private _disposed: boolean;
28		15
29	constructor(parent?: Container<S>) {	16	constructor(parent?: Container<S>) {
30	this._parent = parent;	17	this._services = Object.create(parent ? parent._services : null) as typeof this._services;
31	this._services = Object.create(parent ? parent._services : null);
32	this._cleanup = [];	18	this._cleanup = [];
33	this._root = parent ? parent.getRootContainer() : this;	19	this._services.container = { activate: () => this as ServiceLocator<ContainerServices<S>>};
34	this._services.container = { activate: () => this };
35	this._services.childContainer = { activate: () => this.createChildContainer() };	20	this._services.childContainer = { activate: () => this.createChildContainer() };
36	this._disposed = false;	21	this._disposed = false;
37	this._lifetimeManager = new LifetimeManager();	22	this._lifetimeManager = new LifetimeManager();
38	}	23	}
39		24
40	getRootContainer() {	25	register<K extends ConfigurableKeys<S>>(name: K, service: Descriptor<ContainerServices<S>, ConfigurableServices<S>[K]>): void;
41	return this._root;	26	register<K extends ConfigurableKeys<S>>(services: {[k in K]: Descriptor<ContainerServices<S>, ConfigurableServices<S>[k]>}): void;
		27	register<K extends ConfigurableKeys<S>>(nameOrCollection: K \| {[k in K]: Descriptor<ContainerServices<S>, ConfigurableServices<S>[k]>}, service?: RegistrationMap<ContainerServices<S>>[K]) {
		28	if (!isKey(nameOrCollection)) {
		29	each(nameOrCollection, (v, k) => this.register(k, v));
		30	} else {
		31	if (!service)
		32	throw new Error("The service parameter must be a descriptor");
		33
		34	this._services[nameOrCollection] = service;
42	}	35	}
43
44	getParent() {
45	return this._parent;
46	}	36	}
47		37
48	getLifetimeManager() {	38	createChildContainer(): ServiceContainer<S> {
49	return this._lifetimeManager;	39	return new Container(this);
50	}	40	}
51		41
52	resolve<K extends ContainerKeys<S>>(name: K, ~~def?~~: ~~TypeOfService~~<S, K>): ~~TypeOf~~Service<S, K>;	42	resolve<K extends ContainerKeys<S>>(name: K): NonNullable<ContainerServices<S>[K]>;
53	resolve<K extends ContainerKeys<S>>(name: K, def: ~~undefined~~): ~~TypeOf~~Service<S, K> \| ~~undefined~~;	43	resolve<K extends ContainerKeys<S>>(name: K, def: ContainerServices<S>[K]): ContainerServices<S>[K];
54	resolve<K extends ContainerKeys<S>>(name: K, def?: ~~TypeOf~~Service<S, K>): ~~TypeOf~~Service<S, K> \| undefined {	44	resolve<K extends ContainerKeys<S>>(name: K, def?: ContainerServices<S>[K]): ContainerServices<S>[K] \| undefined {
55	trace.debug("resolve {0}", name);	45	// TODO: add logging
		46	// trace.debug("resolve {0}", name);
56	const d = this._services[name];	47	const d = this._services[name];
57	if (d === undefined) {	48	if (d === undefined) {
58	if (arguments.length > 1)	49	if (arguments.length > 1)
59	return def;	50	return def;
60	else	51	else
61	throw new Error(~~"Service '"~~ + name + "' isn't found");	52	throw new Error(`Service '${String(name)}' isn't found`);
62	} else {	53	} else {
63		54
64	const context = new ActivationContext<S>(this, this._services, String(name), d);	55	const context = new ActivationContext(this, this._services, String(name), d);
65	try {	56	try {
66	return d.activate(context);	57	return d.activate(context);
67	} catch (error) {	58	} catch (error) {
@@ -70,34 +61,8 export class Container<S extends object
70	}	61	}
71	}	62	}
72		63
73	/**	64	createLifetime<T>() {
74	* @deprecated use resolve() method	65	return this._lifetimeManager.create<T>();
75	*/
76	getService<K extends ContainerKeys<S>>(name: K, def?: TypeOfService<S, K>) {
77	return arguments.length === 1 ? this.resolve(name) : this.resolve(name, def);
78	}
79
80	register<K extends keyof S>(name: K, service: Descriptor<S, S[K]>): this;
81	register(services: PartialServiceMap<S>): this;
82	register<K extends keyof S>(nameOrCollection: K \| ServiceMap<S>, service?: Descriptor<S, S[K]>) {
83	if (arguments.length === 1) {
84	const data = nameOrCollection as ServiceMap<S>;
85
86	each(data, (v, k) => this.register(k, v));
87	} else {
88	if (!isDescriptor(service))
89	throw new Error("The service parameter must be a descriptor");
90
91	this._services[nameOrCollection as K] = service as any;
92	}
93	return this;
94	}
95
96	/** @deprecated use getLifetimeManager() */
97	onDispose(callback: () => void) {
98	if (!(callback instanceof Function))
99	throw new Error("The callback must be a function");
100	this._cleanup.push(callback);
101	}	66	}
102		67
103	destroy() {	68	destroy() {
@@ -111,66 +76,4 export class Container<S extends object
111	f();	76	f();
112	this._lifetimeManager.destroy();	77	this._lifetimeManager.destroy();
113	}	78	}
114
115	/**
116	* @param{String\|Object} config
117	* The configuration of the container. Can be either a string or an object,
118	* if the configuration is an object it's treated as a collection of
119	* services which will be registered in the container.
120	*
121	* @param{Function} opts.contextRequire
122	* The function which will be used to load a configuration or types for services.
123	*
124	*/
125	async configure(config: string \| RegistrationMap<S>, opts?: { contextRequire: any; baseModule?: string }, ct = Cancellation.none) {
126	const _opts = Object.create(opts \|\| null);
127
128	if (typeof (config) === "string") {
129	_opts.baseModule = config;
130
131	const module = await import(config);
132	if (module && module.default && typeof (module.default.apply) === "function")
133	return module.default.apply(this);
134	else
135	return this._applyLegacyConfig(module, _opts, ct);
136	} else {
137	return this._applyLegacyConfig(config, _opts, ct);
138	}	79	}
139	}
140
141	applyConfig<S2 extends object>(config: Promise<{ default: ContainerConfiguration<S2>; }>, ct?: ICancellation): Promise<ServiceContainer<S & S2>>;
142	applyConfig<S2 extends object, P extends string>(config: Promise<{ [p in P]: ContainerConfiguration<S2>; }>, prop: P, ct?: ICancellation): Promise<ServiceContainer<S & S2>>;
143	async applyConfig<S2 extends object, P extends string>(
144	config: Promise<{ [p in P \| "default"]: ContainerConfiguration<S2>; }>,
145	propOrCt?: P \| ICancellation,
146	ct?: ICancellation
147	): Promise<ServiceContainer<S & S2>> {
148	const mod = await config;
149
150	let _ct: ICancellation;
151	let _prop: P \| "default";
152
153	if (isString(propOrCt)) {
154	_prop = propOrCt;
155	_ct = ct \|\| Cancellation.none;
156	} else {
157	_ct = propOrCt \|\| Cancellation.none;
158	_prop = "default";
159	}
160
161	return mod[_prop].apply(this, _ct);
162	}
163
164	async _applyLegacyConfig(config: RegistrationMap<S>, opts: { contextRequire: any; baseModule?: string }, ct = Cancellation.none) {
165	return new Configuration<S>(this).applyConfiguration(config, opts);
166	}
167
168	async fluent<K extends keyof S>(config: FluentRegistrations<K, S>, ct = Cancellation.none): Promise<this> {
169	await new FluentConfiguration<S>().register(config).apply(this, ct);
170	return this;
171	}
172
173	createChildContainer<S2 extends object = S>(): Container<S & S2> {
174	return new Container<S & S2>(this as any);
175	}
176	}

src/main/ts/DescriptorBuilder.ts +52 -28

-            import { Resolver, RegistrationBuilder } from "./interfaces";
+            import { Resolver, RegistrationBuilder, LifetimeContainer, ConfigurableKeys } from "./interfaces";
-            import { Descriptor, ILifetime, ActivationType, PartialServiceMap, ServiceContainer } from "./interfaces";
+            import { Descriptor, ILifetime, ActivationType } from "./interfaces";
-            import { DescriptorImpl } from "./DescriptorImpl";
+            import { DescriptorImpl, RegistrationOverridesMap } from "./DescriptorImpl";
             import { LifetimeManager } from "./LifetimeManager";
+            import { each, isKey, isPromise, isString, oid } from "./traits";
+            /**
+             * @template {S} Карта доступных зависимостей, как правило `ContainerServices`
+             * @template {T} Тип сервиса
+             */
             export class DescriptorBuilder<S extends object, T> {
-                private readonly _container: ServiceContainer<S>;
+                private readonly _lifetimeContainer: LifetimeContainer;
                 private readonly _cb: (d: Descriptor<S, T>) => void;
-                private readonly _eb: (err: any) => void;
+                private readonly _eb: (err: unknown) => void;
-                private _lifetime = LifetimeManager.empty();
+                private _lifetime = LifetimeManager.empty<T>();
-                private _overrides?: PartialServiceMap<S>;
+                private _overrides: RegistrationOverridesMap<S>;
                 private _cleanup?: (item: T) => void;
                 private _failed = false;
-                constructor(container: ServiceContainer<S>, cb: (d: Descriptor<S, T>) => void, eb: (err: any) => void) {
+                private _finalized = false;
-                    this._container = container;
+                /**
+                 * Creates new DescriptorBuilder. Accepts a lifetime container for resolving "container"
+                 * lifetime.
+                 *
+                 * @param container 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(container: LifetimeContainer, cb: (d: Descriptor<S, T>) => void, eb: (err: unknown) => void) {
+                    this._lifetimeContainer = container;
                     this._cb = cb;
                     this._eb = eb;
+                    this._overrides = {};
                 }
-                build<T2>(): DescriptorBuilder<S, T2> {
+                private _assertBuilding() {
-                    this._defer();
+                    if (this._finalized)
-                    return new DescriptorBuilder<S, T2>(this._container, () => this._complete(), err => this._fail(err));
+                        throw new Error("The descriptor builder is finalized");
                 }
-                override<K extends keyof S>(name: K, builder: RegistrationBuilder<S, S[K]>): this;
+                private _finalize() {
-                override<K extends keyof S>(services: { [name in K]: RegistrationBuilder<S, S[K]> }): this;
+                    this._finalized = true;
-                override<K extends keyof S>(nameOrServices: K | { [name in K]: RegistrationBuilder<S, S[K]> }, builder?: RegistrationBuilder<S, S[K]>): this {
-                    const overrides: PartialServiceMap<S> = this._overrides ?
-                        this._overrides :
-                        (this._overrides = {});
+                override<K extends ConfigurableKeys<S>>(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 ConfigurableKeys<S>>(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 (isPrimitive(nameOrServices)) {
+                    if (isKey(nameOrServices)) {
                         if (builder) {
                             this._defer();
-                            const d = new DescriptorBuilder<S, S[K]>(
+                            const d = new DescriptorBuilder<S, NonNullable<S[K]>>(
-                                this._container,
+                                this._lifetimeContainer,
                                 result => {
-                                    overrides[nameOrServices] = result;
+                                    this._overrides[nameOrServices] = result;
                                     this._complete();
                                 },
                                 err => this._fail(err)
                 }
                 lifetime(lifetime: "singleton", typeId: string): this;
-                lifetime(lifetime: ILifetime | Exclude<ActivationType, "singleton">): this;
+                lifetime(lifetime: ILifetime<T> | Exclude<ActivationType, "singleton">): this;
-                lifetime(lifetime: ILifetime | ActivationType, typeId?: string): this {
+                lifetime(lifetime: ILifetime<T> | ActivationType, typeId?: string): this {
+                    this._assertBuilding();
                     if (isString(lifetime)) {
                         this._lifetime = this._resolveLifetime(lifetime, typeId);
                     } else {
                 }
                 cleanup(cb: (item: T) => void): this {
+                    this._assertBuilding();
                     this._cleanup = cb;
                     return this;
                 }
                 factory(f: (resolve: Resolver<S>) => T): void {
+                    this._assertBuilding();
                     this._factory = f;
+                    this._finalize();
                     this._complete();
                 }
                 value(v: T): void {
+                    this._assertBuilding();
                     this._cb({
                         activate() {
                             return v;
                         }
                     });
+                    this._finalize();
                 }
-                _resolveLifetime(activation: ActivationType, typeId?: string | object) {
+                _resolveLifetime<T>(activation: ActivationType, typeId?: string | object): ILifetime<T> {
                     switch (activation) {
                         case "container":
-                            return LifetimeManager.containerLifetime(this._container);
+                            return LifetimeManager.containerLifetime(this._lifetimeContainer);
                         case "hierarchy":
                             return LifetimeManager.hierarchyLifetime();
                         case "context":
                             return LifetimeManager.contextLifetime();
-                        case "singleton":
+                        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();
                     }
                     }
                 }
-                _fail(err: any) {
+                _fail(err: unknown) {
                     if (!this._failed) {
                         this._failed = true;
                         this._eb.call(undefined, err);

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

-            import { Descriptor, PartialServiceMap, ILifetime, ContainerKeys } from "../interfaces";
+            import { Descriptor, ILifetime, ConfigurableKeys, Resolver } from "./interfaces";
-            import { ActivationContext } from "../ActivationContext";
+            import { ActivationContext } from "./ActivationContext";
-            import { each } from "../../safe";
+            import { ContextResolver } from "./ContextResolver";
-            import { DependencyOptions, LazyDependencyOptions, Resolver } from "./interfaces";
+            import { each } from "./traits";
+            export type RegistrationOverridesMap<S extends object> = { [k in ConfigurableKeys<S>]?: Descriptor<S, NonNullable<S[k]>> };
             export interface DescriptorImplArgs<S extends object, T> {
-                lifetime: ILifetime;
+                lifetime: ILifetime<T>;
                 factory: (resolve: Resolver<S>) => T;
                 cleanup?: (item: T) => void;
-                overrides?: PartialServiceMap<S>;
+                overrides?: RegistrationOverridesMap<S>;
             }
             export class DescriptorImpl<S extends object, T> implements Descriptor<S, T> {
-                private readonly _overrides?: PartialServiceMap<S>;
+                private readonly _overrides?: RegistrationOverridesMap<S>;
-                private readonly _lifetime: ILifetime;
+                private readonly _lifetime: ILifetime<T>;
                 private readonly _factory: (resolve: Resolver<S>) => T;
                     if (this._overrides)
                         each(this._overrides, (v, k) => context.register(k, v));
-                    const resolve = (name: ContainerKeys<S>, opts?: DependencyOptions | LazyDependencyOptions) => {
-                        if (opts && "lazy" in opts && opts.lazy) {
+                    const resolver = new ContextResolver(context);
-                            const c2 = context.clone();
-                            return () => {
-                                return opts.optional ? c2.resolve(name, opts.default) : c2.resolve(name);
-                            };
-                        } else {
-                            return opts && opts.optional ? context.resolve(name, opts.default) : context.resolve(name);
-                    };
-                    const instance = this._factory.call(undefined, resolve);
+                    const instance = this._factory.call(undefined, resolver.resolve.bind(resolver));
                     this._lifetime.store(instance, this._cleanup);
                     return instance;
                 }
                 toString() {
-                    return `[object DescriptorImpl, lifetime=${this._lifetime}]`;
+                    return `[object DescriptorImpl, lifetime=${String(this._lifetime)}]`;
                 }
             }

src/main/ts/FluentConfiguration.ts +33 -34

-            import { argumentNotNull, each, isPrimitive, isPromise } from "../../safe";
             import { DescriptorBuilder } from "./DescriptorBuilder";
-            import { RegistrationBuilder, FluentRegistrations, ContainerConfiguration } from "./interfaces";
+            import { ConfigurableKeys, ContainerServices, ConfigurableServices, RegistrationBuildersMap, RequiredKeys } from "./interfaces";
-            import { Cancellation } from "../../Cancellation";
+            import { ServiceContainer } from "./interfaces";
-            import { ServiceContainer } from "../interfaces";
+            import { argumentNotNull, each, isKey } from "./traits";
-            export class FluentConfiguration<S extends object, Y extends keyof S = keyof S> {
+            export class FluentConfiguration<S extends object, Y extends ConfigurableKeys<S> = ConfigurableKeys<S>> {
-                _builders: { [k in keyof S]?: RegistrationBuilder<S, S[k]> } = {};
+                _builders: Partial<RegistrationBuildersMap<S>> = {};
-                provided<K extends Y>(): FluentConfiguration<S, Exclude<Y, K>> {
+                declare<D extends Partial<Pick<S, keyof D & keyof S>>>(): FluentConfiguration<S & D, Y | ConfigurableKeys<D>> {
-                    return this;
+                    return this as FluentConfiguration<S & D, Y | ConfigurableKeys<D>>;
                 }
-                register<K extends Y>(name: K, builder: RegistrationBuilder<S, S[K]>): FluentConfiguration<S, Exclude<Y, K>>;
+                provided<P extends Pick<S, keyof P & keyof S>>(): FluentConfiguration<S & P, Exclude<Y, keyof P>> {
-                register<K extends Y>(config: FluentRegistrations<K, S>): FluentConfiguration<S, Exclude<Y, K>>;
+                    return this as FluentConfiguration<S & P, Exclude<Y, keyof P>>;
-                register<K extends Y>(nameOrConfig: K | FluentRegistrations<K, S>, builder?: RegistrationBuilder<S, S[K]>): FluentConfiguration<S, Exclude<Y, K>> {
-                    if (isPrimitive(nameOrConfig)) {
+                register<K extends Y>(name: K, builder: RegistrationBuildersMap<S>[K]): FluentConfiguration<S, Exclude<Y, K>>;
+                register<K extends Y>(config: RegistrationBuildersMap<S, K>): FluentConfiguration<S, Exclude<Y, K>>;
+                register<K extends Y>(nameOrConfig: K | RegistrationBuildersMap<S, K>, builder?: RegistrationBuildersMap<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>>;
+                }
+                done(missing: RequiredKeys<S, Y> extends never ? void : RequiredKeys<S, Y>) {
+                    if (missing !== undefined)
+                        throw new Error("The configuration isn't complete");
                     return this;
                 }
-                configure(config: FluentRegistrations<Y, S>): ContainerConfiguration<S> {
-                    return this.register(config);
-                apply<S2 extends object>(target: ServiceContainer<S2>, ct = Cancellation.none) {
+                apply<A extends Partial<S>>(target: ServiceContainer<A>) {
                     let pending = 1;
-                    const _t2 = target as unknown as ServiceContainer<S2 & S>;
+                    const _t2 = target as ServiceContainer<S>;
-                    return new Promise<ServiceContainer<S2 & S>>((resolve, reject) => {
+                    const reject = (ex: unknown) => { throw ex; };
-                        function guard(v: void | Promise<void>) {
-                            if (isPromise(v))
-                                v.catch(reject);
-                        function complete() {
+                    const complete = () => !--pending;
-                            if (!--pending)
-                                resolve(_t2);
                     each(this._builders, (v, k) => {
                         pending++;
-                            const d = new DescriptorBuilder<S2 & S, any>(_t2,
+                        const d = new DescriptorBuilder<ContainerServices<S>, NonNullable<ConfigurableServices<S>[typeof k]>>(_t2,
                             result => {
                                 _t2.register(k, result);
                                 complete();
                             reject
                         );
-                            try {
-                                guard(v(d, ct));
+                        v(d);
-                            } catch (e) {
-                                reject(e);
                     });
-                        complete();
+                    if (!complete())
-                    });
+                        throw new Error("The configuration didn't complete.");
+                    return _t2 as ServiceContainer<A & S>;
                 }
             }

src/main/ts/LifetimeManager.ts +51 -56

-            import { IDestroyable, MapOf } from "../interfaces";
+            import { IDestroyable, ILifetime } from "./interfaces";
-            import { argumentNotNull, isDestroyable, argumentNotEmptyString, isRemovable } from "../safe";
-            import { ILifetime, ServiceContainer } from "./interfaces";
             import { ActivationContext } from "./ActivationContext";
+            import { argumentNotNull, isDestroyable } from "./traits";
-            function safeCall(item: () => void) {
+            const safeCall = (item: () => void) => {
                 try {
                     item();
                 } catch {
                     // silence!
                 }
+            };
-            const emptyLifetime: ILifetime = Object.freeze({
+            const emptyLifetime = Object.freeze({
                 has() {
                     return false;
                 },
                 initialize() {
                 },
                 get() {
             });
-            const unknownLifetime: ILifetime = Object.freeze({
+            const unknownLifetime = Object.freeze({
                 has() {
                     return false;
                 },
             let nextId = 0;
-            const singletons: any = {};
+            const singletons: { [K:string]: unknown} = {};
             export class LifetimeManager implements IDestroyable {
                 private _cleanup: (() => void)[] = [];
-                private _cache: MapOf<any> = {};
+                private readonly _cache: {[K: string]: unknown} = {};
                 private _destroyed = false;
-                private _pending: MapOf<boolean> = {};
+                private readonly _pending: {[K: string]: unknown} = {};
-                create(): ILifetime {
+                create<T>(): ILifetime<T> {
-                    const self = this;
                     const id = ++nextId;
                     return {
-                        has() {
+                        has: () => id in this._cache,
-                            return (id in self._cache);
+                        get: () => {
+                            const t = this._cache[id];
+                            if (t === undefined)
+                                throw new Error(`The item with with the key ${id} isn't found`);
+                            return t as T;
                         },
-                        get() {
+                        initialize: () => {
-                            const t = self._cache[id];
+                            if (this._pending[id])
-                            if (t === undefined)
+                                throw Error(`Cyclic reference detected: the item with the key ${id} is already activating.`);
-                                throw new Error(`The item with with the key ${id} isn't found`);
+                            this._pending[id] = true;
-                            return t;
                         },
-                        initialize() {
+                        store: (item: T, cleanup?: (item: T) => void) => {
-                            if (self._pending[id])
-                                throw Error(`Cyclic reference detected: the item with the key ${id} is already activating.`);
-                            self._pending[id] = true;
-                        },
-                        store(item: any, cleanup?: (item: any) => void) {
                             argumentNotNull(id, "id");
                             argumentNotNull(item, "item");
-                            if (this.has())
+                            if (id in this._cache)
                                 throw new Error(`The item with with the key ${id} already registered with this lifetime manager`);
-                            delete self._pending[id];
+                            delete this._pending[id];
-                            self._cache[id] = item;
+                            this._cache[id] = item;
-                            if (self._destroyed)
+                            if (this._destroyed)
                                 throw new Error("Lifetime manager is destroyed");
                             if (cleanup) {
-                                self._cleanup.push(() => cleanup(item));
+                                this._cleanup.push(() => cleanup(item));
                             } else if (isDestroyable(item)) {
-                                self._cleanup.push(() => item.destroy());
+                                this._cleanup.push(() => item.destroy());
                             }
                         }
                     };
                     }
                 }
-                static empty(): ILifetime {
+                static empty<T>(): ILifetime<T> {
                     return emptyLifetime;
                 }
-                static hierarchyLifetime() {
+                static hierarchyLifetime<T>() {
-                    let _lifetime = unknownLifetime;
+                    let _lifetime: ILifetime<T> = unknownLifetime;
                     return {
-                        initialize(context: ActivationContext<any>) {
+                        initialize(context: ActivationContext<object>) {
                             if (_lifetime !== unknownLifetime)
                                 throw new Error("Cyclic reference activation detected");
-                            _lifetime = context.getContainer().getLifetimeManager().create();
+                            _lifetime = context.createContainerLifetime<T>();
                         },
                         get() {
                             return _lifetime.get();
                         has() {
                             return _lifetime.has();
                         },
-                        store(item: any, cleanup?: (item: any) => void) {
+                        store(item: T, cleanup?: (item: T) => void) {
                             return _lifetime.store(item, cleanup);
                         },
                         toString() {
-                            return `[object HierarchyLifetime, has=${this.has()}]`;
+                            return `[object HierarchyLifetime, has=${String(this.has())}]`;
                         }
                     };
                 }
-                static contextLifetime() {
+                static contextLifetime<T>() {
-                    let _lifetime = unknownLifetime;
+                    let _lifetime: ILifetime<T> = unknownLifetime;
                     return {
-                        initialize(context: ActivationContext<any>) {
+                        initialize(context: ActivationContext<object>) {
                             if (_lifetime !== unknownLifetime)
                                 throw new Error("Cyclic reference detected");
                             _lifetime = context.createLifetime();
                         has() {
                             return _lifetime.has();
                         },
-                        store(item: any) {
+                        store(item: T) {
                             _lifetime.store(item);
                         },
                         toString() {
-                            return `[object ContextLifetime, has=${this.has()}]`;
+                            return `[object ContextLifetime, has=${String(this.has())}]`;
                         }
                     };
                 }
-                static singletonLifetime(typeId: string) {
+                static singletonLifetime<T>(typeId: string) {
-                    argumentNotEmptyString(typeId, "typeId");
+                    argumentNotNull(typeId, "typeId");
                     let pending = false;
                     return {
                         has() {
                         get() {
                             if (!this.has())
                                 throw new Error(`The instance ${typeId} doesn't exists`);
-                            return singletons[typeId];
+                            return singletons[typeId] as T;
                         },
                         initialize() {
                             if (pending)
                                 throw new Error("Cyclic reference detected");
                             pending = true;
                         },
-                        store(item: any) {
+                        store(item: T) {
                             singletons[typeId] = item;
                             pending = false;
                         },
                         toString() {
-                            return `[object SingletonLifetime, has=${this.has()}, typeId=${typeId}]`;
+                            return `[object SingletonLifetime, has=${String(this.has())}, typeId=${typeId}]`;
                         }
                     };
                 }
-                static containerLifetime(container: ServiceContainer<any>) {
+                static containerLifetime<T>(container: { createLifetime<X>(): ILifetime<X>}) {
-                    let _lifetime = unknownLifetime;
+                    let _lifetime: ILifetime<T> = unknownLifetime;
                     return {
-                        initialize(context: ActivationContext<any>) {
+                        initialize() {
                             if (_lifetime !== unknownLifetime)
                                 throw new Error("Cyclic reference detected");
-                            _lifetime = container.getLifetimeManager().create();
+                            _lifetime = container.createLifetime();
                         },
                         get() {
                             return _lifetime.get();
                         has() {
                             return _lifetime.has();
                         },
-                        store(item: any) {
+                        store(item: T) {
                             _lifetime.store(item);
                         },
                         toString() {
-                            return `[object ContainerLifetime, has=${_lifetime.has()}]`;
+                            return `[object ContainerLifetime, has=${String(_lifetime.has())}]`;
                         }
                     };
                 }

src/main/ts/interfaces.ts +74 -71

@@ -1,104 +1,104
		1	import { ActivationContext } from "./ActivationContext";
		2
1	export type primitive = number \| string \| null \| undefined \| symbol;	3	export type primitive = number \| string \| null \| undefined \| symbol;
2		4
3	export interface IDestroyable {	5	export interface IDestroyable {
4	destroy(): void;	6	destroy(): void;
5	}	7	}
6		8
7		9	/**
8	export interface DependencyOptions {	10	* @template S Карта доступных зависимостей
9	optional?: boolean;	11	*/
10	default?: any;
11	}
12
13	export interface LazyDependencyOptions extends DependencyOptions {
14	lazy: true;
15	}
16
17	export type ExtractService<K, S> = K extends keyof S ? S[K] : never;
18
19	export type ExtractDependency<D, S> = D extends { $dependency: infer K } ?
20	D extends { lazy: true } ? () => ExtractService<K, S> : ExtractService<K, S> :
21	D extends { $type: new (...args: any[]) => infer I } ? I :
22	D extends { $factory: (...args: any[]) => infer R } ? R :
23	WalkDependencies<D, S>;
24
25	export type WalkDependencies<D, S> = D extends primitive ? D :
26	{ [K in keyof D]: ExtractDependency<D[K], S> };
27
28	export type InferReferenceType<S extends object, K extends ContainerKeys<S>, O> = O extends { default: infer X } ? (TypeOfService<S, K> \| X) :
29	O extends { optional: true } ? (TypeOfService<S, K> \| undefined) :
30	TypeOfService<S, K>;
31
32	export interface Resolver<S extends object> {	12	export interface Resolver<S extends object> {
33	<K extends ContainerKeys<S>, O extends LazyDependencyOptions>(this: void, name: K, opts: O): () => InferReferenceType<S, K, O>;	13	/**
34	<K extends ContainerKeys<S>, O extends DependencyOptions>(this: void, name: K, opts?: O): InferReferenceType<S, K, O>;	14	* Функция для разрешения зависимостей, поддерживает создание фабричных методов,
		15	* отложенную активацию и значение по-умолчанию для сервисов
		16	* @template K Ключ сервиса из {@link S}
		17	* @template O Тип параметра {@link opts} используется для выведения типа
		18	* возвращаемого значения.
		19	* @param name Ключ сервиса, который будет разрешен.
		20	* @param {boolean=} opts.lazy Признак того, что требуется отложенная активация,
		21	* будет возвращен фабричный метод для получения зависимости. Если не указан,
		22	* то считается `false`.
		23	* @param {any=} opts.default Значение по умолчанию, если в контейнере указанный
		24	* сервис не зарегистрирован
		25	* @returns Либо фабричный метод для получения зависимости, либо значение зависимости
		26	* @throws Error Если зависимость не найдена и не предоставлено значение по-умолчанию
		27	*/
		28	<K extends keyof S, O extends { lazy: true; default?: unknown }>(name: K, opts?: O): () => (O extends { default: infer T } ? T : never) \| NonNullable<S[K]>;
		29	<K extends keyof S, O extends { lazy?: false; default?: unknown }>(name: K, opts?: O): (O extends { default: infer T } ? T : never) \| NonNullable<S[K]>;
35	}	30	}
36		31
37	export interface DescriptorBuilder<S extends object, T> {	32	export interface DescriptorBuilder<S extends object, T> {
		33
		34	/**
		35	*
		36	* @param f
		37	*/
38	factory(f: (resolve: Resolver<S>) => T): void;	38	factory(f: (resolve: Resolver<S>) => T): void;
39		39
40	build<T2>(): DescriptorBuilder<S, T2>;	40	override<K extends ConfigurableKeys<S>>(name: K, builder: RegistrationBuilder<S, NonNullable<S[K]>>): this;
		41	override<K extends ConfigurableKeys<S>>(services: { [name in K]: RegistrationBuilder<S, NonNullable<S[K]>> }): this;
41		42
42	override<K extends keyof S>(name: K, builder: RegistrationBuilder<S, S[K]>): this;	43	lifetime(lifetime: "singleton", typeId: string \| number \| object): this;
43	override<K extends keyof S>(services: { [name in K]: RegistrationBuilder<S, S[K]> }): this;	44	lifetime(lifetime: ILifetime<T> \| Exclude<ActivationType, "singleton">): this;
44
45	lifetime(lifetime: "singleton", typeId: any): this;
46	lifetime(lifetime: ILifetime \| Exclude<ActivationType, "singleton">): this;
47		45
48	cleanup(cb: (item: T) => void): this;	46	cleanup(cb: (item: T) => void): this;
49		47
50	value(v: T): void;	48	value(v: T): void;
51	}	49	}
52		50
53	export type RegistrationBuilder<S extends object, T> = (d: DescriptorBuilder<S, T>, ~~ct?~~: ~~ICancellation~~) => void \| ~~Promise~~<~~void~~>;	51	export type RegistrationBuilder<S extends object, T> = (d: DescriptorBuilder<S, T>) => void;
54		52
55	export type FluentRegistrations<K extends keyof S, S extends object> = { [k in K]: RegistrationBuilder<S, S[k]> };	53	export type RegistrationBuildersMap<S extends object, K extends ConfigurableKeys<S> = ConfigurableKeys<S>> = {
		54	[k in K]-?: RegistrationBuilder<ContainerServices<S>, NonNullable<ConfigurableServices<S>[k]>>
		55	};
56		56
57	export interface Descriptor<S extends object = ~~any~~, T = ~~any~~> {	57	export interface Descriptor<S extends object, T> {
58	activate(context: ActivationContext<S>): T;	58	activate(context: ActivationContext<S>): T;
59	}	59	}
60		60
61	export type ServiceMap<S extends object> = {	61	export type ConfigurableDescriptor<S extends object, K extends ConfigurableKeys<S>> = Descriptor<ContainerServices<S>, ConfigurableServices<S>[K]>;
62	[k in keyof S]: Descriptor<S, S[k]>;
63	};
64
65	export type ContainerKeys<S extends object> = keyof S \| keyof ContainerProvided<S>;
66		62
67	export type TypeOfService<S extends object, K> =	63	export type RegistrationMap<S extends object, K extends keyof S = keyof S> = {
68	K extends keyof ContainerProvided<S> ? ContainerProvided<S>[K] :	64	[k in K]-?: Descriptor<S, S[k]>;
69	K extends keyof S ? S[K] : never;
70
71	export type ContainerServiceMap<S extends object> = {
72	[K in ContainerKeys<S>]: Descriptor<S, TypeOfService<S, K>>;
73	};	65	};
74		66
75	export ~~typ~~e P~~artialServiceMap~~<S extends object> = {	67	export interface ProvidedServices<S extends object> {
76	[k in keyof S]?: Descriptor<S, S[k]>;	68	container: ServiceLocator<ContainerServices<S>>;
77	};	69
		70	childContainer: ServiceContainer<S>;
		71	}
		72
		73	export type ProvidedKeys = keyof ProvidedServices<object>;
		74
		75	export type ContainerKeys<S extends object> = keyof ContainerServices<S>;
		76
		77	export type Mix<S, X> = { [k in keyof (S & X)]: k extends keyof X ? X[k] : S[k & keyof S] };
		78
		79	export type ContainerServices<S extends object> = Mix<S, ProvidedServices<S>>;
		80
		81	export type ConfigurableKeys<S extends object> = Exclude<keyof S, ProvidedKeys>;
		82
		83	export type ConfigurableServices<S extends object> = Pick<S, ConfigurableKeys<S>>;
78		84
79	export interface ServiceLocator<S extends object> {	85	export interface ServiceLocator<S extends object> {
80	resolve<K extends ContainerKeys<S>>(name: K, def?: TypeOfService<S, K>): TypeOfService<S, K>;	86	resolve<K extends keyof S>(name: K): NonNullable<S[K]>;
81	resolve<K extends ~~ContainerKeys~~<S>>(name: K, def?: ~~undefined~~): ~~TypeOfServic~~e<S, K> \| ~~undefined~~;	87	resolve<K extends keyof S, T>(name: K, def: T): NonNullable<S[K]> \| T;
82	}	88	}
83		89
84	export interface ServiceContainer<S extends object> extends ServiceLocator<S>, IDestroyable {	90	export interface LifetimeContainer {
85	~~getLifetimeManager~~(): Lifetime~~Manager~~;	91	createLifetime<T>(): ILifetime<T>;
86	register<K extends keyof S>(name: K, service: Descriptor<S, S[K]>): this;	92	}
87	register(services: PartialServiceMap<S>): this;	93
		94	export interface ServiceContainer<S extends object> extends ServiceLocator<ContainerServices<S>>, LifetimeContainer, IDestroyable {
		95
		96	register<K extends ConfigurableKeys<S>>(name: K, service: ConfigurableDescriptor<S, K>): void;
		97	register<K extends ConfigurableKeys<S>>(services: { [k in K]: ConfigurableDescriptor<S, K> }): void;
88		98
89	createChildContainer(): ServiceContainer<S>;	99	createChildContainer(): ServiceContainer<S>;
90	}	100	}
91		101
92	export interface ContainerProvided<S extends object> {
93	container: ServiceLocator<S>;
94
95	childContainer: ServiceContainer<S>;
96	}
97
98	export type ContainerRegistered<S extends object> = /*{
99	[K in Exclude<keyof S, keyof ContainerProvided<S>>]: S[K];
100	};*/
101	Exclude<S, ContainerProvided<S>>;
102		102
103	export type ActivationType = "singleton" \| "container" \| "hierarchy" \| "context" \| "call";	103	export type ActivationType = "singleton" \| "container" \| "hierarchy" \| "context" \| "call";
104		104
@@ -106,13 +106,16 export type ActivationType = "singleton"
106	* Интерфейс для управления жизнью экземпляра объекта. Каждая регистрация имеет	106	* Интерфейс для управления жизнью экземпляра объекта. Каждая регистрация имеет
107	* свой собственный объект `ILifetime`, который создается при первой активации	107	* свой собственный объект `ILifetime`, который создается при первой активации
108	*/	108	*/
109	export interface ILifetime {	109	export interface ILifetime<T> {
110	/** Проверяет, что уже создан экземпляр объекта */	110	/** Проверяет, что уже создан экземпляр объекта */
111	has(): boolean;	111	has(): boolean;
112		112
113	get(): ~~any~~;	113	get(): T;
		114
		115	initialize(context: ActivationContext<object>): void;
114		116
115	initialize(context: ActivationContext<any>): void;	117	store(item: T, cleanup?: (item: T) => void): void;
		118	}
116		119
117	store(item: any, cleanup?: (item: any) => void): void;	120	export type RequiredKeys<T, K extends keyof T = keyof T> = keyof { [p in K as (T[p] extends undefined ? never : p)]-?: T[p] };
118	}	121

src/main/ts/traits.ts +48 -5

@@ -1,6 +1,49
1	import { primitive } from "./interfaces";	1	import { FluentConfiguration } from "./FluentConfiguration";
		2	import { IDestroyable } from "./interfaces";
		3
		4	export function fluent<S extends object = object>() {
		5	return new FluentConfiguration<S>();
		6	}
		7
		8	export type key = string \| number \| symbol;
		9
		10	export const isKey = (v: unknown): v is key =>
		11	typeof v === "string" \|\| typeof v === "number" \|\| typeof v === "symbol";
		12
		13	export const isString = (v: unknown): v is string =>
		14	typeof v === "string";
		15
		16
		17	export const isNotNull = <T>(v: T): v is NonNullable<T> => v !== null && v !== undefined;
		18
		19	export const each = <T extends object>(obj: T, cb: <X extends Extract<keyof T, string>>(v: NonNullable<T[X]>, k: X) => void) =>
		20	(Object.keys(obj) as (Extract<keyof T, string>)[])
		21	.forEach(k => {
		22	const v = obj[k];
		23	isNotNull(v) && cb(v, k);
		24	});
2		25
3	export function isPrimitive(val: any): val is primitive {	26	export const argumentNotNull = (arg: unknown, name: string) => {
4	~~return~~ (~~val~~ === null \|\| ~~val~~ === undefined \|\| ~~typeof~~ (~~val~~) ~~===~~ ~~"string"~~ \|\|	27	if (arg === null \|\| arg === undefined)
5	typeof (val) === "number" \|\| typeof (val) === "boolean");	28	throw new Error("The argument " + name + " can't be null or undefined");
6	} No newline at end of file	29	};
		30
		31	export const isPromise = <T = unknown>(val: unknown): val is PromiseLike<T> =>
		32	isNotNull(val) && typeof (val as PromiseLike<T>).then === "function";
		33
		34	export const isDestroyable = (d: unknown): d is IDestroyable =>
		35	isNotNull(d) && typeof (d as IDestroyable).destroy === "function";
		36
		37	let _nextOid = 0;
		38	const _oid = typeof Symbol === "function" ?
		39	Symbol.for("__implab__oid__") :
		40	"__implab__oid__";
		41
		42	type OidSlot = { [k in typeof _oid]?: string };
		43
		44	export const oid = <T extends object>(instance: T): string => {
		45	argumentNotNull(instance, "instance");
		46	const val = (instance as OidSlot)[_oid];
		47
		48	return val ? val : ((instance as OidSlot)[_oid] = `oid_${++_nextOid}`);
		49	}; No newline at end of file

src/main/tsconfig.json 0 -6

@@ -1,9 +1,3
1	{	1	{
2	"extends": "../tsconfig",	2	"extends": "../tsconfig",
3	"compilerOptions": {
4	"rootDir": "ts"
5	},
6	"include": [
7	"ts/*/.ts"
8	]
9	} No newline at end of file	3	}

src/main/ts/LazyReferenceDescriptor.ts removed 0 -83

NO CONTENT: file was removed

src/main/ts/ReferenceDescriptor.ts removed 0 -88

NO CONTENT: file was removed

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