implab/implabjs-core Commit - r135:03e32ec7c20b

Completely removed IoC annotations...

cin -

r135:03e32ec7c20b ioc ts support

parent child

Context file:

r135:03e32ec7c20b

Collapse all files

src/main/ts/di/fluent/DescriptorImpl.ts created 644 +63 0

@@ -0,0 +1,63
	1	import { Descriptor, PartialServiceMap, ILifetime, ContainerKeys } from "../interfaces";
	2	import { ActivationContext } from "../ActivationContext";
	3	import { each } from "../../safe";
	4	import { DependencyOptions, LazyDependencyOptions, Resolver } from "./interfaces";
	5
	6	export interface DescriptorImplArgs<S extends object, T> {
	7	lifetime: ILifetime;
	8
	9	factory: (resolve: Resolver<S>) => T;
	10
	11	cleanup?: (item: T) => void;
	12
	13	overrides?: PartialServiceMap<S>;
	14	}
	15
	16	export class DescriptorImpl<S extends object, T> implements Descriptor<S, T> {
	17
	18	private readonly _overrides?: PartialServiceMap<S>;
	19
	20	private readonly _lifetime: ILifetime;
	21
	22	private readonly _factory: (resolve: Resolver<S>) => T;
	23
	24	private readonly _cleanup?: (item: T) => void;
	25
	26	constructor(args: DescriptorImplArgs<S, T>) {
	27	this._lifetime = args.lifetime;
	28	this._factory = args.factory;
	29	if (args.cleanup)
	30	this._cleanup = args.cleanup;
	31	if (args.overrides)
	32	this._overrides = args.overrides;
	33	}
	34
	35	activate(context: ActivationContext<S>): T {
	36
	37	if (this._lifetime.has())
	38	return this._lifetime.get();
	39
	40	this._lifetime.initialize(context);
	41
	42	if (this._overrides)
	43	each(this._overrides, (v, k) => context.register(k, v));
	44
	45	const resolve = (name: ContainerKeys<S>, opts?: DependencyOptions \| LazyDependencyOptions) => {
	46	if (opts && "lazy" in opts && opts.lazy) {
	47	const c2 = context.clone();
	48	return () => {
	49	return opts.optional ? c2.resolve(name, opts.default) : c2.resolve(name);
	50	};
	51	} else {
	52	return opts && opts.optional ? context.resolve(name, opts.default) : context.resolve(name);
	53	}
	54	};
	55
	56	const instance = this._factory.call(undefined, resolve);
	57
	58	this._lifetime.store(instance, this._cleanup);
	59
	60	return instance;
	61	}
	62
	63	}

src/main/ts/di/fluent/FluentConfiguration.ts created 644 +58 0

@@ -0,0 +1,58
	1	import { Container } from "../Container";
	2	import { argumentNotNull, each, isPrimitive, isPromise } from "../../safe";
	3	import { DescriptorBuilder } from "./DescriptorBuilder";
	4	import { RegistrationBuilder, FluentRegistrations } from "./interfaces";
	5	import { Cancellation } from "../../Cancellation";
	6
	7	export class FluentConfiguration<S extends object, Y extends keyof S = keyof S> {
	8
	9	_builders: { [k in keyof S]?: RegistrationBuilder<S, S[k]> } = {};
	10
	11	register<K extends Y>(name: K, builder: RegistrationBuilder<S, S[K]>): FluentConfiguration<S, Exclude<Y, K>>;
	12	register<K extends Y>(config: FluentRegistrations<K, S>): FluentConfiguration<S, Exclude<Y, K>>;
	13	register<K extends Y>(nameOrConfig: K \| FluentRegistrations<K, S>, builder?: RegistrationBuilder<S, S[K]>): FluentConfiguration<S, Exclude<Y, K>> {
	14	if (isPrimitive(nameOrConfig)) {
	15	argumentNotNull(builder, "builder");
	16	this._builders[nameOrConfig] = builder;
	17	} else {
	18	each(nameOrConfig, (v, k) => this.register(k, v));
	19	}
	20
	21	return this;
	22	}
	23
	24	apply(target: Container<S>, ct = Cancellation.none) {
	25
	26	let pending = 1;
	27
	28	return new Promise((resolve, reject) => {
	29	function guard(v: void \| Promise<void>) {
	30	if (isPromise(v))
	31	v.catch(reject);
	32	}
	33
	34	function complete() {
	35	if (!--pending)
	36	resolve();
	37	}
	38	each(this._builders, (v, k) => {
	39	pending++;
	40	const d = new DescriptorBuilder<S, any>(target,
	41	result => {
	42	target.register(k, result);
	43	complete();
	44	},
	45	reject
	46	);
	47
	48	try {
	49	guard(v(d, ct));
	50	} catch (e) {
	51	reject(e);
	52	}
	53	});
	54	complete();
	55	});
	56	}
	57
	58	}

src/test/ts/tests/FluentContainerTests.ts created 644 +54 0

@@ -0,0 +1,54
	1	import { test } from "./TestTraits";
	2	import { fluent } from "../di/traits";
	3	import { Bar } from "../mock/Bar";
	4	import { Container } from "../di/Container";
	5	import { Foo } from "../mock/Foo";
	6	import { Box } from "../mock/Box";
	7	import { delay } from "../safe";
	8
	9	test("Simple fluent config", async t => {
	10	const config = fluent<{ host: string; bar: Bar; foo: Foo }>()
	11	.register({
	12	host: it => it.value("example.com"),
	13	bar: it => it.factory(resolve => new Bar({ host: resolve("host") }, "s-bar")),
	14	foo: it => import("../mock/Foo").then(m => it.lifetime("container").factory(() => new m.Foo()))
	15	});
	16
	17	const container = new Container<{ host: string; bar: Bar; foo: Foo; }>();
	18	await config.apply(container);
	19
	20	t.equal(container.resolve("host"), "example.com", "The value should be resolved");
	21	t.assert(container.resolve("bar"), "The service should de activated");
	22	t.equal(container.resolve("foo"), container.resolve("foo"), "The service should be activated once");
	23	});
	24
	25	test("Nested async configuration", async t => {
	26	const container = await new Container<{
	27	foo: Foo;
	28	box: Box<Foo>
	29	}>().fluent({
	30	foo: it => delay(0).then(() => it.factory(() => new Foo())),
	31	box: it => it.lifetime("context").factory($dependency => new Box($dependency("foo")))
	32	});
	33
	34	t.assert(container.resolve("box").getValue(), "The dependency should be set");
	35	t.equals(container.resolve("box").getValue(), container.resolve("box").getValue(), "The service should be activated once")
	36	});
	37
	38	test("Bad fluent config", async t => {
	39	try {
	40	await new Container<{
	41	foo: Foo;
	42	box: Box<Foo>
	43	}>().fluent({
	44	foo: it => delay(0).then(() => it.factory(() => new Foo())),
	45	box: it => it.lifetime("context")
	46	.override("foo", () => { throw new Error("bad override"); })
	47	.factory($dependency => new Box($dependency("foo")))
	48	});
	49	t.fail("Should throw");
	50	} catch (e) {
	51	t.pass("The configuration should fail");
	52	t.equal(e.message, "bad override", "the error should pass");
	53	}
	54	});

src/main/ts/di/ActivationContext.ts +30 0

             import { TraceSource } from "../log/TraceSource";
             import { argumentNotEmptyString } from "../safe";
             import { Descriptor, ContainerServiceMap, ContainerKeys, TypeOfService, ILifetime } from "./interfaces";
             import { Container } from "./Container";
             import { MapOf } from "../interfaces";
             const trace = TraceSource.get("@implab/core/di/ActivationContext");
             export interface ActivationContextInfo {
                 name: string;
                 service: string;
             }
             let nextId = 1;
+            /** This class 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.
+             */
             export class ActivationContext<S extends object> {
                 _cache: MapOf<any>;
                 _services: ContainerServiceMap<S>;
                 _visited: MapOf<any>;
                 _name: string;
                 _service: Descriptor<S, any>;
                 _container: Container<S>;
                 _parent: ActivationContext<S> | undefined;
+                /** Creates a new activation context with the specified parameters.
+                 * @param container 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: Container<S>, services: ContainerServiceMap<S>, name: string, service: Descriptor<S, any>) {
                     this._name = name;
                     this._service = service;
                     this._visited = {};
                     this._cache = {};
                     this._services = services;
                     this._container = container;
                 }
+                /** the name of the current resolving dependency */
                 getName() {
                     return this._name;
                 }
+                /** Returns the container for which 'resolve' method was called */
                 getContainer() {
                     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>;
+                /** 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 ContainerKeys<S>, T>(name: K, def: T): TypeOfService<S, K> | T;
+                /** Resolves the specified dependency and returns undefined in case if the
+                 * 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) {
                         return this.activate(d, name.toString());
                     } else {
                         if (arguments.length > 1)
                             return def;
                         else
                             throw new Error(`Service ${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 keyof S>(name: K, service: Descriptor<S, S[K]>) {
                     argumentNotEmptyString(name, "name");
                     this._services[name] = service as any;
                 }
                 createLifetime(): ILifetime {
                     const id = nextId++;
                     const me = this;
                     return {
                         initialize() {
                         },
                         has() {
                             return id in me._cache;
                         },
                         get() {
                             return me._cache[id];
                         },
                         store(item: any) {
                             me._cache[id] = item;
                         }
                     };
                 }
                 activate<T>(d: Descriptor<S, T>, name: string) {
                     if (trace.isLogEnabled())
                         trace.log(`enter ${name} ${d}`);
                     const ctx = this.enter(d, name);
                     const v = d.activate(ctx);
                     if (trace.isLogEnabled())
                         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,
                         service: this._service.toString()
                     }];
                     return this._parent ?
                         stack.concat(this._parent.getStack()) :
                         stack;
                 }
                 private enter(service: Descriptor<S, any>, name: string): this {
                     const clone = Object.create(this);
                     clone._name = name;
                     clone._services = Object.create(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);
                     clone._services = Object.create(this._services);
                     return clone;
                 }
             }

src/main/ts/di/Container.ts +9 -2

             import { ActivationContext } from "./ActivationContext";
             import { ValueDescriptor } from "./ValueDescriptor";
             import { ActivationError } from "./ActivationError";
-            import { ServiceMap, Descriptor, PartialServiceMap, ContainerProvided, ServiceLocator, ContainerServiceMap, ContainerKeys, TypeOfService, ILifetimeManager } from "./interfaces";
+            import { ServiceMap, Descriptor, PartialServiceMap, ServiceLocator, ContainerServiceMap, ContainerKeys, TypeOfService } from "./interfaces";
             import { TraceSource } from "../log/TraceSource";
             import { Configuration, RegistrationMap } from "./Configuration";
             import { Cancellation } from "../Cancellation";
             import { MapOf, IDestroyable } from "../interfaces";
             import { isDescriptor } from "./traits";
             import { LifetimeManager } from "./LifetimeManager";
             import { each } from "../safe";
+            import { FluentRegistrations } from "./fluent/interfaces";
+            import { FluentConfiguration } from "./fluent/FluentConfiguration";
             const trace = TraceSource.get("@implab/core/di/ActivationContext");
             export class Container<S extends object = any> implements ServiceLocator<S>, IDestroyable {
                 readonly _services: ContainerServiceMap<S>;
-                readonly _lifetimeManager: ILifetimeManager;
+                readonly _lifetimeManager: LifetimeManager;
                 readonly _cleanup: (() => void)[];
                 readonly _root: Container<S>;
                 readonly _parent?: Container<S>;
                 _disposed: boolean;
                 constructor(parent?: Container<S>) {
                     this._parent = parent;
                     this._services = parent ? Object.create(parent._services) : {};
                     this._cleanup = [];
                     this._root = parent ? parent.getRootContainer() : this;
                     this._services.container = new ValueDescriptor(this) as any;
                     this._disposed = false;
                     this._lifetimeManager = new LifetimeManager();
                 }
                 getRootContainer() {
                     return this._root;
                 }
                 getParent() {
                     return this._parent;
                 }
                 getLifetimeManager() {
                     return this._lifetimeManager;
                 }
                 resolve<K extends ContainerKeys<S>>(name: K, def?: TypeOfService<S, K>): TypeOfService<S, K> {
                     trace.debug("resolve {0}", name);
                     const d = this._services[name];
                     if (d === undefined) {
                         if (def !== undefined)
                             return def;
                         else
                             throw new Error("Service '" + name + "' isn't found");
                     } else {
                         const context = new ActivationContext<S>(this, this._services, String(name), d);
                         try {
                             return d.activate(context);
                         } catch (error) {
                             throw new ActivationError(name.toString(), context.getStack(), error);
                         }
                     }
                 }
                 /**
                  * @deprecated use resolve() method
                  */
                 getService<K extends ContainerKeys<S>>(name: K, def?: TypeOfService<S, K>) {
                     return this.resolve(name, def);
                 }
                 register<K extends keyof S>(name: K, service: Descriptor<S, S[K]>): this;
                 register(services: PartialServiceMap<S>): this;
                 register<K extends keyof S>(nameOrCollection: K | ServiceMap<S>, service?: Descriptor<S, S[K]>) {
                     if (arguments.length === 1) {
                         const data = nameOrCollection as ServiceMap<S>;
                         each(data, (v, k) => this.register(k, v));
                     } else {
                         if (!isDescriptor(service))
                             throw new Error("The service parameter must be a descriptor");
                         this._services[nameOrCollection as K] = service as any;
                     }
                     return this;
                 }
                 onDispose(callback: () => void) {
                     if (!(callback instanceof Function))
                         throw new Error("The callback must be a function");
                     this._cleanup.push(callback);
                 }
                 destroy() {
                     return this.dispose();
                 }
                 dispose() {
                     if (this._disposed)
                         return;
                     this._disposed = true;
                     for (const f of this._cleanup)
                         f();
                 }
                 /**
                  * @param{String|Object} config
                  *  The configuration of the contaier. Can be either a string or an object,
                  *  if the configuration is an object it's treated as a collection of
                  *  services which will be registed in the contaier.
                  *
                  * @param{Function} opts.contextRequire
                  *  The function which will be used to load a configuration or types for services.
                  *
                  */
                 async configure(config: string | RegistrationMap<S>, opts?: any, ct = Cancellation.none) {
                     const c = new Configuration<S>(this);
                     if (typeof (config) === "string") {
                         return c.loadConfiguration(config, opts && opts.contextRequire, ct);
                     } else {
                         return c.applyConfiguration(config, opts && opts.contextRequire, ct);
                     }
                 }
+                async fluent<K extends keyof S>(config: FluentRegistrations<K, S>, ct = Cancellation.none): Promise<this> {
+                    await new FluentConfiguration<S>().register(config).apply(this, ct);
+                    return this;
+                }
                 createChildContainer<S2 extends object = S>(): Container<S & S2> {
                     return new Container<S & S2>(this as any);
                 }
             }

src/main/ts/di/LifetimeManager.ts +33 -11

             import { IDestroyable, MapOf } from "../interfaces";
-            import { argumentNotNull, isDestroyable } from "../safe";
+            import { argumentNotNull, isDestroyable, primitive, isNull, argumentNotEmptyString } from "../safe";
-            import { ILifetimeManager, ILifetime } from "./interfaces";
+            import { ILifetime } from "./interfaces";
             import { ActivationContext } from "./ActivationContext";
             import { Container } from "./Container";
             function safeCall(item: () => void) {
                 try {
                     item();
                 } catch {
                     // silence!
                 }
             }
-            const emptyLifetime: ILifetime = {
+            const emptyLifetime: ILifetime = Object.freeze({
                 has() {
                     return false;
                 },
                 initialize() {
                 },
                 get() {
                     throw new Error("The specified item isn't registered with this lifetime manager");
                 },
                 store() {
                     // does nothing
                 }
-            };
+            });
-            const unknownLifetime: ILifetime = {
+            const unknownLifetime: ILifetime = Object.freeze({
                 has() {
-                    throw new Error("The lifetime is unknown");
+                    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");
                 }
+            });
             let nextId = 0;
-            export class LifetimeManager implements IDestroyable, ILifetimeManager {
+            const singletons: { [k in keyof any]: any; } = {};
+            export class LifetimeManager implements IDestroyable {
                 private _cleanup: (() => void)[] = [];
                 private _cache: MapOf<any> = {};
                 private _destroyed = false;
                 private _pending: MapOf<boolean> = {};
                 create(): ILifetime {
                     const self = this;
                     const id = ++nextId;
                     return {
                         has() {
                             return (id in self._cache);
                         },
                         get() {
                             const t = self._cache[id];
                             if (t === undefined)
                                 throw new Error(`The item with with the key ${id} isn't found`);
                             return t;
                         },
                         initialize() {
                             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())
                                 throw new Error(`The item with with the key ${id} already registered with this lifetime manager`);
                             delete self._pending[id];
                             self._cache[id] = item;
                             if (self._destroyed)
                                 throw new Error("Lifetime manager is destroyed");
                             if (cleanup) {
                                 self._cleanup.push(() => cleanup(item));
                             } else if (isDestroyable(item)) {
                                 self._cleanup.push(() => item.destroy());
                             }
                         }
                     };
                 }
                 destroy() {
                     if (!this._destroyed) {
                         this._destroyed = true;
                         this._cleanup.forEach(safeCall);
                         this._cleanup.length = 0;
                     }
                 }
                 static empty(): ILifetime {
                     return emptyLifetime;
                 }
                 static hierarchyLifetime(): ILifetime {
                     let _lifetime = unknownLifetime;
                     return {
                         initialize(context: ActivationContext<any>) {
                             if (_lifetime !== unknownLifetime)
                                 throw new Error("Cyclic reference activation detected");
-                            _lifetime = context.getContainer().getLifetimeManager().create(context);
+                            _lifetime = context.getContainer().getLifetimeManager().create();
                         },
                         get() {
                             return _lifetime.get();
                         },
                         has() {
                             return _lifetime.has();
                         },
                         store(item: any, cleanup?: (item: any) => void) {
                             return _lifetime.store(item, cleanup);
                         }
                     };
                 }
                 static contextLifetime(): ILifetime {
                     let _lifetime = unknownLifetime;
                     return {
                         initialize(context: ActivationContext<any>) {
                             if (_lifetime !== unknownLifetime)
                                 throw new Error("Cyclic reference detected");
                             _lifetime = context.createLifetime();
                         },
                         get() {
                             return _lifetime.get();
                         },
                         has() {
                             return _lifetime.has();
                         },
                         store(item: any) {
                             _lifetime.store(item);
                         }
                     };
                 }
                 static singletonLifetime(typeId: string): ILifetime {
-                    return emptyLifetime;
+                    argumentNotEmptyString(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];
+                        },
+                        initialize() {
+                            if (pending)
+                                throw new Error("Cyclic reference detected");
+                            pending = true;
+                        },
+                        store(item: any) {
+                            singletons[typeId] = item;
+                            pending = false;
+                        }
+                    };
                 }
                 static containerLifetime(container: Container<any>) {
                     let _lifetime = unknownLifetime;
                     return {
                         initialize(context: ActivationContext<any>) {
                             if (_lifetime !== unknownLifetime)
                                 throw new Error("Cyclic reference detected");
-                            _lifetime = container.getLifetimeManager().create(context);
+                            _lifetime = container.getLifetimeManager().create();
                         },
                         get() {
                             return _lifetime.get();
                         },
                         has() {
                             return _lifetime.has();
                         },
                         store(item: any) {
                             _lifetime.store(item);
                         }
                     };
                 }
             }

src/main/ts/di/ServiceDescriptor.ts +1 -1

             import { ActivationContext } from "./ActivationContext";
-            import { Descriptor, ServiceMap, PartialServiceMap, ILifetimeManager, ILifetime } from "./interfaces";
+            import { Descriptor, ServiceMap, PartialServiceMap, ILifetime } from "./interfaces";
             import { isPrimitive, keys, isNull } from "../safe";
             import { TraceSource } from "../log/TraceSource";
             import { isDescriptor } from "./traits";
             import { LifetimeManager } from "./LifetimeManager";
             import { MatchingMemberKeys } from "../interfaces";
             const trace = TraceSource.get("@implab/core/di/ActivationContext");
             function injectMethod<T, M extends keyof T, S extends object, A>(target: T, method: M, context: ActivationContext<S>, args: A) {
                 const m = target[method];
                 if (!m || typeof m !== "function")
                     throw new Error("Method '" + method + "' not found");
                 if (args instanceof Array)
                     return m.apply(target, _parse(args, context, "." + method));
                 else
                     return m.call(target, _parse(args, context, "." + method));
             }
             function makeCleanupCallback<T>(method: Cleaner<T>) {
                 if (typeof (method) === "function") {
                     return (target: T) => {
                         method(target);
                     };
                 } else {
                     return (target: T) => {
                         const m = target[method] as any;
                         m.apply(target);
                     };
                 }
             }
             function _parse(value: any, context: ActivationContext<any>, path: string): any {
                 if (isPrimitive(value))
                     return value as any;
                 trace.debug("parse {0}", path);
                 if (isDescriptor(value))
                     return context.activate(value, path);
                 if (value instanceof Array)
                     return value.map((x, i) => _parse(x, context, `${path}[${i}]`)) as any;
                 const t: any = {};
                 keys(value).forEach(p => t[p] = _parse(value[p], context, `${path}.${p}`));
                 return t;
             }
             export type Cleaner<T> = ((x: T) => void) | MatchingMemberKeys<() => void, T>;
             export type InjectionSpec<T> = {
                 [m in keyof T]?: any;
             };
             export interface ServiceDescriptorParams<S extends object, T, P extends any[]> {
                 lifetime?: ILifetime;
                 params?: P;
                 inject?: InjectionSpec<T>[];
                 services?: PartialServiceMap<S>;
                 cleanup?: Cleaner<T>;
             }
             export class ServiceDescriptor<S extends object, T, P extends any[]> implements Descriptor<S, T> {
                 _services: ServiceMap<S>;
                 _params: P | undefined;
                 _inject: InjectionSpec<T>[];
                 _cleanup: ((item: T) => void) | undefined;
                 _lifetime = LifetimeManager.empty();
                 _objectLifetime: ILifetime | undefined;
                 constructor(opts: ServiceDescriptorParams<S, T, P>) {
                     if (opts.lifetime)
                         this._lifetime = opts.lifetime;
                     if (!isNull(opts.params))
                         this._params = opts.params;
                     this._inject = opts.inject || [];
                     this._services = (opts.services || {}) as ServiceMap<S>;
                     if (opts.cleanup) {
                         if (!(typeof (opts.cleanup) === "string" || opts.cleanup instanceof Function))
                             throw new Error(
                                 "The cleanup parameter must be either a function or a function name");
                         this._cleanup = makeCleanupCallback(opts.cleanup);
                     }
                 }
                 activate(context: ActivationContext<S>) {
                     const lifetime = this._lifetime;
                     if (lifetime.has()) {
                         return lifetime.get();
                     } else {
                         lifetime.initialize(context);
                         const instance = this._create(context);
                         lifetime.store(instance, this._cleanup);
                         return instance;
                     }
                 }
                 _factory(...params: any[]): T {
                     throw Error("Not implemented");
                 }
                 _create(context: ActivationContext<S>) {
                     trace.debug(`constructing ${context._name}`);
                     if (this._services) {
                         keys(this._services).forEach(p => context.register(p, this._services[p]));
                     }
                     let instance: T;
                     if (this._params === undefined) {
                         instance = this._factory();
                     } else if (this._params instanceof Array) {
                         instance = this._factory.apply(this, _parse(this._params, context, "args"));
                     } else {
                         instance = this._factory(_parse(this._params, context, "args"));
                     }
                     if (this._inject) {
                         this._inject.forEach(spec => {
                             for (const m in spec)
                                 injectMethod(instance, m, context, spec[m]);
                         });
                     }
                     return instance;
                 }
                 clone() {
                     return Object.create(this);
                 }
             }

src/main/ts/di/fluent/DescriptorBuilder.ts +122 -29

@@ -1,54 +1,147
1	import { Resolver, ~~LazyDependencyOptions~~, ~~DependencyOptions~~ } from "./interfaces";	1	import { Resolver, RegistrationBuilder } from "./interfaces";
2	import { Container } from "../Container";	2	import { Container } from "../Container";
3	import { Descriptor, ILifetime, ~~ContainerKeys~~ } from "../interfaces";	3	import { Descriptor, ILifetime, ActivationType, PartialServiceMap } from "../interfaces";
4	import { ActivationContext } from "../ActivationContext";	4	import { DescriptorImpl } from "./DescriptorImpl";
		5	import { LifetimeManager } from "../LifetimeManager";
		6	import { isString, each, isPrimitive, isPromise, oid } from "../../safe";
		7
		8	export class DescriptorBuilder<S extends object, T> {
		9	private readonly _container: Container<S>;
		10	private readonly _cb: (d: Descriptor<S, T>) => void;
		11
		12	private readonly _eb: (err: any) => void;
5		13
6	export class DescriptorBuilder<T, S extends object> {	14	private _lifetime = LifetimeManager.empty();
7	readonly _container: Container<S>;	15
8	readonly _cb: (d: Descriptor<S, T>) => void;	16	private _overrides?: PartialServiceMap<S>;
		17
		18	private _cleanup?: (item: T) => void;
9		19
10	constructor(container: Container<S>, cb: (d: Descriptor<S, T>) => void) {	20	private _factory?: (resolve: Resolver<S>) => T;
		21
		22	private _pending = 1;
		23
		24	private _failed = false;
		25
		26	constructor(container: Container<S>, cb: (d: Descriptor<S, T>) => void, eb: (err: any) => void) {
11	this._container = container;	27	this._container = container;
12	this._cb = cb;	28	this._cb = cb;
		29	this._eb = eb;
		30	}
		31
		32	build<T2>(): DescriptorBuilder<S, T2> {
		33	this._defer();
		34	return new DescriptorBuilder<S, T2>(this._container, () => this._complete(), err => this._fail(err));
13	}	35	}
14		36
15	factory(f: (resolve: Resolver<S>, activate: (lifetime: ILifetime, factory: () => any, cleanup?: (item: any) => void) => any) => T): void {	37	override<K extends keyof S>(name: K, builder: RegistrationBuilder<S, S[K]>): this;
16	this._cb({	38	override<K extends keyof S>(services: { [name in K]: RegistrationBuilder<S, S[K]> }): this;
17	activate(context: ActivationContext<S>) {	39	override<K extends keyof S>(nameOrServices: K \| { [name in K]: RegistrationBuilder<S, S[K]> }, builder?: RegistrationBuilder<S, S[K]>): this {
18	const resolve = (name: ContainerKeys<S>, opts?: DependencyOptions \| LazyDependencyOptions) => {	40	const overrides: PartialServiceMap<S> = this._overrides ?
19	if (opts && "lazy" in opts && opts.lazy) {	41	this._overrides :
20	const c2 = context.clone();	42	(this._overrides = {});
21	return () => {	43
22	return opts.optional ? c2.resolve(name, opts.default) : c2.resolve(name);	44	const guard = (v: void \| Promise<void>) => {
23	};	45	if (isPromise(v))
24	} else {	46	v.catch(err => this._fail(err));
25	return opts && opts.optional ? context.resolve(name, opts.default) : context.resolve(name);
26	}
27	};	47	};
28		48
29	const activate = (lifetime: ILifetime, factory: () => any, cleanup?: (item: any) => void) => {	49	if (isPrimitive(nameOrServices)) {
30	if (~~lifetime~~.~~has~~()) {	50	if (builder) {
31	return lifetime.get();	51	this._defer();
		52	const d = new DescriptorBuilder<S, S[K]>(
		53	this._container,
		54	result => {
		55	overrides[nameOrServices] = result;
		56	this._complete();
		57	},
		58	err => this._fail(err)
		59	);
		60
		61	try {
		62	guard(builder(d));
		63	} catch (err) {
		64	this._fail(err);
		65	}
		66	}
32	} else {	67	} else {
33	lifetime.initialize(context);	68	each(nameOrServices, (v, k) => this.override(k, v));
34	const instance = factory();	69	}
35	lifetime.store(instance, cleanup);	70	return this;
36	return instance;
37	}	71	}
38		72
39	};	73	lifetime(lifetime: "singleton", typeId: string): this;
		74	lifetime(lifetime: ILifetime \| Exclude<ActivationType, "singleton">): this;
		75	lifetime(lifetime: ILifetime \| ActivationType, typeId?: string): this {
		76	if (isString(lifetime)) {
		77	this._lifetime = this._resolveLifetime(lifetime, typeId);
		78	} else {
		79	this._lifetime = lifetime;
		80	}
		81	return this;
		82	}
40		83
41	return f(resolve, activate);	84	cleanup(cb: (item: T) => void): this {
		85	this._cleanup = cb;
		86	return this;
42	}	87	}
43	});	88
		89	factory(f: (resolve: Resolver<S>) => T): void {
		90	this._factory = f;
		91	this._complete();
44	}	92	}
45		93
46	value(v: T): void {	94	value(v: T): void {
47	this._cb({	95	this._cb({
48	activate() {	96	activate() {
49	return v;	97	return v;
50	}	98	}
51	});	99	});
52	}	100	}
53		101
		102	_resolveLifetime(activation: ActivationType, typeId?: string \| object) {
		103	switch (activation) {
		104	case "container":
		105	return LifetimeManager.containerLifetime(this._container);
		106	case "hierarchy":
		107	return LifetimeManager.hierarchyLifetime();
		108	case "context":
		109	return LifetimeManager.contextLifetime();
		110	case "singleton":
		111	if (!typeId)
		112	throw Error("The singleton activation requires a typeId");
		113
		114	const _oid = isString(typeId) ? typeId : oid(typeId);
		115
		116	return LifetimeManager.singletonLifetime(_oid);
		117	default:
		118	return LifetimeManager.empty();
54	}	119	}
		120	}
		121
		122	_defer() {
		123	this._pending++;
		124	}
		125
		126	_complete() {
		127	if (--this._pending === 0) {
		128	if (!this._factory)
		129	throw new Error("The factory must be specified");
		130
		131	this._cb(new DescriptorImpl<S, T>({
		132	lifetime: this._lifetime,
		133	factory: this._factory,
		134	overrides: this._overrides,
		135	cleanup: this._cleanup
		136	}));
		137	}
		138	}
		139
		140	_fail(err: any) {
		141	if (!this._failed) {
		142	this._failed = true;
		143	this._eb.call(undefined, err);
		144	}
		145	}
		146
		147	}

src/main/ts/di/fluent/interfaces.ts +16 -12

             import { primitive } from "../../safe";
-            import { AnnotationBuilder } from "../Annotations";
+            import { TypeOfService, ContainerKeys, ActivationType, ILifetime } from "../interfaces";
-            import { ILifetime, TypeOfService, ContainerKeys } from "../interfaces";
+            import { ICancellation } from "../../interfaces";
             export interface DependencyOptions {
                 optional?: boolean;
                 default?: any;
             }
             export interface LazyDependencyOptions extends DependencyOptions {
                 lazy: true;
             }
             export type ExtractService<K, S> = K extends keyof S ? S[K] : never;
             export type ExtractDependency<D, S> = D extends { $dependency: infer K } ?
                 D extends { lazy: true } ? () => ExtractService<K, S> : ExtractService<K, S> :
                 D extends { $type: new (...args: any[]) => infer I } ? I :
                 D extends { $factory: (...args: any[]) => infer R } ? R :
                 WalkDependencies<D, S>;
             export type WalkDependencies<D, S> = D extends primitive ? D :
                 { [K in keyof D]: ExtractDependency<D[K], S> };
-            export type ServiceModule<T, S extends object, M extends keyof any = "service"> = {
-                [m in M]: AnnotationBuilder<T, S>;
-            };
             export type InferReferenceType<S extends object, K extends ContainerKeys<S>, O> = O extends { default: infer X } ? (TypeOfService<S, K> | X) :
                 O extends { optional: true } ? (TypeOfService<S, K> | undefined) :
                 TypeOfService<S, K>;
             export interface Resolver<S extends object> {
                 <K extends ContainerKeys<S>, O extends LazyDependencyOptions>(this: void, name: K, opts: O): () => InferReferenceType<S, K, O>;
                 <K extends ContainerKeys<S>, O extends DependencyOptions>(this: void, name: K, opts?: O): InferReferenceType<S, K, O>;
             }
-            export interface DescriptorBuilder<T, S extends object> {
+            export interface DescriptorBuilder<S extends object, T> {
-                service(service: AnnotationBuilder<T, S> | ServiceModule<T, S>): void;
+                factory(f: (resolve: Resolver<S>) => T): void;
+                build<T2>(): DescriptorBuilder<S, T2>;
-                factory(f: (resolve: Resolver<S>, activate: <T2>(lifetime: ILifetime, factory: () => T2, cleanup?: (item: T2) => void) => T2) => T): void;
+                override<K extends keyof S>(name: K, builder: RegistrationBuilder<S, S[K]>): this;
+                override<K extends keyof S>(services: { [name in K]: RegistrationBuilder<S, S[K]> }): this;
+                lifetime(lifetime: "singleton", typeId: any): this;
+                lifetime(lifetime: ILifetime | Exclude<ActivationType, "singleton">): this;
+                cleanup(cb: (item: T) => void): this;
                 value(v: T): void;
             }
-            export interface Configuration<S extends object, Y extends keyof S = keyof S> {
+            export type RegistrationBuilder<S extends object, T> = (d: DescriptorBuilder<S, T>, ct?: ICancellation) => void | Promise<void>;
-                register<K extends Y>(name: K, builder: (d: DescriptorBuilder<S[K], S>) => void): Configuration<S, Exclude<Y, K>>;
+            export type FluentRegistrations<K extends keyof S, S extends object> = { [k in K]: RegistrationBuilder<S, S[k]> };

src/main/ts/di/interfaces.ts 0 -4

             import { ActivationContext } from "./ActivationContext";
             export interface Descriptor<S extends object = any, T = any> {
                 activate(context: ActivationContext<S>): T;
             }
             export type ServiceMap<S extends object> = {
                 [k in keyof S]: Descriptor<S, S[k]>;
             };
             export type ContainerKeys<S extends object> = keyof S | keyof ContainerProvided<S>;
             export type TypeOfService<S extends object, K> =
                 K extends keyof ContainerProvided<S> ? ContainerProvided<S>[K] :
                 K extends keyof S ? S[K] : never;
             export type ContainerServiceMap<S extends object> = {
                 [K in ContainerKeys<S>]: Descriptor<S, TypeOfService<S, K>>;
             };
             export type PartialServiceMap<S extends object> = {
                 [k in keyof S]?: Descriptor<S, S[k]>;
             };
             export interface ServiceLocator<S extends object> {
                 resolve<K extends ContainerKeys<S>>(name: K, def?: TypeOfService<S, K>): TypeOfService<S, K>;
             }
             export interface ContainerProvided<S extends object> {
                 container: ServiceLocator<S>;
             }
             export type ContainerRegistered<S extends object> = /*{
                 [K in Exclude<keyof S, keyof ContainerProvided<S>>]: S[K];
             };*/
                 Exclude<S, ContainerProvided<S>>;
             export type ActivationType = "singleton" | "container" | "hierarchy" | "context" | "call";
-            export interface ILifetimeManager {
-                create(context: ActivationContext<any>): ILifetime;
             /**
              * Интерфейс для управления жизнью экземпляра объекта. Каждая регистрация имеет
              * свой собственный объект `ILifetime`, который создается при первой активации
              */
             export interface ILifetime {
                 /** Проверяет, что уже создан экземпляр объекта */
                 has(): boolean;
                 get(): any;
                 initialize(context: ActivationContext<any>): void;
                 store(item: any, cleanup?: (item: any) => void): void;
             }

src/main/ts/di/traits.ts +3 -4

             import { isPrimitive } from "../safe";
             import { Descriptor } from "./interfaces";
-            import { Configuration } from "./fluent/Configuration";
+            import { FluentConfiguration } from "./fluent/FluentConfiguration";
             export function isDescriptor(x: any): x is Descriptor {
                 return (!isPrimitive(x)) &&
                     (x.activate instanceof Function);
             }
-            export function configure<S extends object>() {
+            export function fluent<S extends object>() {
-                return new Configuration<S>();
+                return new FluentConfiguration<S>();
             }

src/main/ts/safe.ts +3 -1

-            import { ICancellable, Constructor, IDestroyable } from "./interfaces";
+            import { ICancellable, Constructor, IDestroyable, PromiseOrValue } from "./interfaces";
             import { Cancellation } from "./Cancellation";
             let _nextOid = 0;
             const _oid = typeof Symbol === "function" ?
                 Symbol("__implab__oid__") :
                 "__implab__oid__";
+            export function oid(instance: null | undefined): undefined;
+            export function oid(instance: NonNullable<any>): string;
             export function oid(instance: any): string | undefined {
                 if (isNull(instance))
                     return undefined;
                 if (_oid in instance)
                     return instance[_oid];
                 else
                     return (instance[_oid] = "oid_" + (++_nextOid));
             }
             export function keys<T>(arg: T): (Extract<keyof T, string>)[] {
                 return isObject(arg) && arg ? Object.keys(arg) as (Extract<keyof T, string>)[] : [];
             }
             export function isKeyof<T>(k: string, target: T): k is Extract<keyof T, string> {
                 return target && typeof target === "object" && k in target;
             }
             export function argumentNotNull(arg: any, name: string) {
                 if (arg === null || arg === undefined)
                     throw new Error("The argument " + name + " can't be null or undefined");
             }
             export function argumentNotEmptyString(arg: any, name: string) {
                 if (typeof (arg) !== "string" || !arg.length)
                     throw new Error("The argument '" + name + "' must be a not empty string");
             }
             export function argumentNotEmptyArray(arg: any, name: string) {
                 if (!(arg instanceof Array) || !arg.length)
                     throw new Error("The argument '" + name + "' must be a not empty array");
             }
             export function argumentOfType(arg: any, type: Constructor<{}>, name: string) {
                 if (!(arg instanceof type))
                     throw new Error("The argument '" + name + "' type doesn't match");
             }
             export function isObject(val: any): val is object {
                 return typeof val === "object";
             }
             export function isNull(val: any): val is null | undefined {
                 return (val === null || val === undefined);
             }
             export type primitive = symbol | string | number | boolean | undefined | null;
             export function isPrimitive(val: any): val is primitive {
                 return (val === null || val === undefined || typeof (val) === "string" ||
                     typeof (val) === "number" || typeof (val) === "boolean");
             }
             export function isInteger(val: any): val is number {
                 return parseInt(val, 10) === val;
             }
             export function isNumber(val: any): val is number {
                 return parseFloat(val) === val;
             }
             export function isString(val: any): val is string {
                 return typeof (val) === "string" || val instanceof String;
             }
             export function isPromise<T = any>(val: any): val is PromiseLike<T> {
                 return val && typeof val.then === "function";
             }
             export function isCancellable(val: any): val is ICancellable {
                 return val && typeof val.cancel === "function";
             }
             export function isNullOrEmptyString(val: any): val is ("" | null | undefined) {
                 return (val === null || val === undefined ||
                     ((typeof (val) === "string" || val instanceof String) && val.length === 0));
             }
             export function isNotEmptyArray<T = any>(arg: any): arg is T[] {
                 return (arg instanceof Array && arg.length > 0);
             }
             function _isStrictMode(this: any) {
                 return !this;
             }
             function _getNonStrictGlobal(this: any) {
                 return this;
             }
             export function getGlobal() {
                 // in es3 we can't use indirect call to eval, since it will
                 // be executed in the current call context.
                 if (!_isStrictMode()) {
                     return _getNonStrictGlobal();
                 } else {
                     // tslint:disable-next-line:no-eval
                     return eval.call(null, "this");
                 }
             }
             export function get(member: string, context?: object) {
                 argumentNotEmptyString(member, "member");
                 let that = context || getGlobal();
                 const parts = member.split(".");
                 for (const m of parts) {
                     if (!m)
                         continue;
                     if (isNull(that = that[m]))
                         break;
                 }
                 return that;
             }
             /**
              * Выполняет метод для каждого элемента массива, останавливается, когда
              * либо достигнут конец массива, либо функция <c>cb</c> вернула
              * значение.
              *
              * @param {Array | Object} obj массив элементов для просмотра
              * @param {Function} cb функция, вызываемая для каждого элемента
              * @param {Object} thisArg значение, которое будет передано в качестве
              *                <c>this</c> в <c>cb</c>.
              * @returns {void}
              */
             export function each<T>(obj: T, cb: <X extends keyof T>(v: NonNullable<T[X]>, k: X) => void): void;
             export function each<T>(array: T[], cb: (v: T, i: number) => void): void;
             export function each(obj: any, cb: any, thisArg?: any): any;
             export function each(obj: any, cb: any, thisArg?: any) {
                 argumentNotNull(cb, "cb");
                 if (obj instanceof Array) {
                     let v: any;
                     for (let i = 0; i < obj.length; i++) {
                         v = obj[i];
                         if (v !== undefined)
                             cb.call(thisArg, v, i);
                     }
                 } else {
                     Object.keys(obj).forEach(k => obj[k] !== undefined && cb.call(thisArg, obj[k], k));
                 }
             }
             /** Copies property values from a source object to the destination and returns
              * the destination onject.
              *
              * @param dest The destination object into which properties from the source
              *  object will be copied.
              * @param source The source of values which will be copied to the destination
              *  object.
              * @param template An optional parameter specifies which properties should be
              *  copied from the source and how to map them to the destination. If the
              *  template is an array it contains the list of property names to copy from the
              *  source to the destination. In case of object the templates contains the map
              *  where keys are property names in the source and the values are property
              *  names in the destination object. If the template isn't specified then the
              *  own properties of the source are entirely copied to the destination.
              *
              */
             export function mixin<T extends object, S extends object>(dest: T, source: S, template?: keyof S[]): T & S;
             export function mixin<T extends object, S extends object, R extends object = T>(dest: T, source: S, template: { [p in keyof S]?: keyof R; }): T & R;
             export function mixin<T extends object, S extends object>(dest: T, source: S, template?: any): any {
                 argumentNotNull(dest, "dest");
                 const _res: any = dest as any;
                 if (isPrimitive(source))
                     return _res;
                 if (template instanceof Array) {
                     template.forEach(p => {
                         if (isKeyof(p, source))
                             _res[p] = source[p];
                     });
                 } else if (template) {
                     keys(source).forEach(p => {
                         if (isKeyof(p, template))
                             _res[template[p]] = source[p];
                     });
                 } else {
                     keys(source).forEach(p => _res[p] = source[p]);
                 }
                 return _res;
             }
             /** Wraps the specified function to emulate an asynchronous execution.
              * @param{Object} thisArg [Optional] Object which will be passed as 'this' to the function.
              * @param{Function|String} fn [Required] Function wich will be wrapped.
              */
             export function async<T, F extends (...args: any[]) => T | PromiseLike<T>>(
                 fn: F,
                 thisArg?: ThisParameterType<F>
             ): (...args: Parameters<F>) => PromiseLike<T>;
             export function async<T, M extends string, O extends { [m in M]?: (...args: any[]) => T | PromiseLike<T> }>(
                 fn: M,
                 thisArg: O
             ): (...args: Parameters<NonNullable<O[M]>>) => PromiseLike<T>;
             export function async(_fn: any, thisArg: any): (...args: any[]) => PromiseLike<any> {
                 let fn = _fn;
                 if (arguments.length === 2 && !(fn instanceof Function))
                     fn = thisArg[fn];
                 if (fn == null)
                     throw new Error("The function must be specified");
                 function wrapresult(x: any, e?: any): PromiseLike<any> {
                     if (e) {
                         return {
                             then(cb, eb) {
                                 try {
                                     return eb ? wrapresult(eb(e)) : this;
                                 } catch (e2) {
                                     return wrapresult(null, e2);
                                 }
                             }
                         };
                     } else {
                         if (x && x.then)
                             return x;
                         return {
                             then(cb) {
                                 try {
                                     return cb ? wrapresult(cb(x)) : this;
                                 } catch (e2) {
                                     return wrapresult(e2);
                                 }
                             }
                         };
                     }
                 }
                 return (...args) => {
                     try {
                         return wrapresult(fn.apply(thisArg, args));
                     } catch (e) {
                         return wrapresult(null, e);
                     }
                 };
             }
             export function delegate<T extends object, F extends (this: T, ...args: any[]) => any>(
                 target: T,
                 method: F
             ): OmitThisParameter<F>;
             export function delegate<M extends string, T extends { [m in M]?: (...args: any[]) => any; }>(
                 target: T,
                 method: M
             ): OmitThisParameter<T[M]>;
             export function delegate(target: any, _method: any): (...args: any[]) => any {
                 let method: any;
                 if (!(_method instanceof Function)) {
                     argumentNotNull(target, "target");
                     method = target[_method];
                     if (!(method instanceof Function))
                         throw new Error("'method' argument must be a Function or a method name");
                 } else {
                     method = _method;
                 }
                 return (...args) => {
                     return method.apply(target, args);
                 };
             }
             export function delay(timeMs: number, ct = Cancellation.none) {
                 ct.throwIfRequested();
                 return new Promise((resolve, reject) => {
                     const h = ct.register(e => {
                         clearTimeout(id);
                         reject(e);
                         // we don't nedd to unregister h, since ct is already disposed
                     });
                     const id = setTimeout(() => {
                         h.destroy();
                         resolve();
                     }, timeMs);
                 });
             }
             /** Returns resolved promise, awaiting this method will cause the asynchronous
              * completion of the rest of the code.
              */
             export function fork() {
                 return Promise.resolve();
             }
             /** Always throws Error, can be used as a stub for the methods which should be
              * assigned later and are required to be not null.
              */
             export function notImplemented(): never {
                 throw new Error("Not implemeted");
             }
             /**
              * Iterates over the specified array of items and calls the callback `cb`, if
              * the result of the callback is a promise the next item from the array will be
              * proceeded after the promise is resolved.
              *
              */
             export function pmap<T, T2>(
                 items: ArrayLike<T> | PromiseLike<ArrayLike<T>>,
                 cb: (item: T, i: number) => T2 | PromiseLike<T2>
             ): T2[] | PromiseLike<T2[]> {
                 argumentNotNull(cb, "cb");
                 if (isPromise(items)) {
                     return items.then(data => pmap(data, cb));
                 } else {
                     if (isNull(items) || !items.length)
                         return [];
                     let i = 0;
                     const result = new Array<T2>();
                     const next = (): any => {
                         while (i < items.length) {
                             const r = cb(items[i], i);
                             const ri = i;
                             i++;
                             if (isPromise(r)) {
                                 return r.then(x => {
                                     result[ri] = x;
                                     return next();
                                 });
                             } else {
                                 result[ri] = r;
                             }
                         }
                         return result;
                     };
                     return next();
                 }
             }
             export function pfor<T>(
                 items: ArrayLike<T> | PromiseLike<ArrayLike<T>>,
                 cb: (item: T, i: number) => any
             ): void | PromiseLike<void> {
                 argumentNotNull(cb, "cb");
                 if (isPromise(items)) {
                     return items.then(data => pfor(data, cb));
                 } else {
                     if (isNull(items) || !items.length)
                         return;
                     let i = 0;
                     const next = (): any => {
                         while (i < items.length) {
                             const r = cb(items[i], i);
                             i++;
                             if (isPromise(r))
                                 return r.then(next);
                         }
                     };
                     return next();
                 }
             }
             export function first<T>(sequence: ArrayLike<T>): T;
             export function first<T>(sequence: PromiseLike<ArrayLike<T>>): PromiseLike<T>;
             export function first<T>(
                 sequence: ArrayLike<T> | PromiseLike<ArrayLike<T>>,
                 cb?: (x: T) => void,
                 err?: (x: Error) => void
             ): void;
             /**
              * Выбирает первый элемент из последовательности, или обещания, если в
              * качестве параметра используется обещание, оно должно вернуть массив.
              *
              * @param {Function} cb обработчик результата, ему будет передан первый
              *                  элемент последовательности в случае успеха
              * @param {Function} err обработчик исключения, если массив пустой, либо
              *                  не массив
              *
              * @remarks Если не указаны ни cb ни err, тогда функция вернет либо
              *          обещание, либо первый элемент.
              * @async
              */
             export function first<T>(
                 sequence: ArrayLike<T> | PromiseLike<ArrayLike<T>>,
                 cb?: (x: T) => void,
                 err?: (x: Error) => void
             ) {
                 if (isPromise(sequence)) {
                     return sequence.then(res => first(res, cb as any /* force to pass undefined cb */, err));
                 } else if (sequence && "length" in sequence) {
                     if (sequence.length === 0) {
                         if (err)
                             return err(new Error("The sequence is empty"));
                         else
                             throw new Error("The sequence is empty");
                     } else if (cb) {
                         return cb(sequence[0]);
                     } else {
                         return sequence[0];
                     }
                 } else {
                     if (err)
                         return err(new Error("The sequence is required"));
                     else
                         throw new Error("The sequence is required");
                 }
             }
             export function firstWhere<T>(
                 sequence: ArrayLike<T>,
                 predicate: (x: T) => boolean
             ): T;
             export function firstWhere<T>(
                 sequence: PromiseLike<ArrayLike<T>>,
                 predicate: (x: T) => boolean
             ): PromiseLike<T>;
             export function firstWhere<T>(
                 sequence: ArrayLike<T> | PromiseLike<ArrayLike<T>>,
                 predicate: (x: T) => boolean,
                 cb: (x: T) => void,
                 err?: (x: Error) => void
             ): void;
             export function firstWhere<T>(
                 sequence: ArrayLike<T> | PromiseLike<ArrayLike<T>>,
                 predicate?: (x: T) => boolean,
                 cb?: (x: T) => any,
                 err?: (x: Error) => any
             ) {
                 if (isPromise(sequence)) {
                     return sequence.then(res => firstWhere(
                         res,
                         predicate as any /* force to pass undefined predicate */,
                         cb as any /* force to pass undefined cb */,
                         err)
                     );
                 } else if (sequence && "length" in sequence) {
                     if (sequence.length === 0) {
                         if (err)
                             err(new Error("The sequence is empty"));
                         else
                             throw new Error("The sequence is empty");
                     } else {
                         if (!predicate) {
                             return cb ? cb(sequence[0]) && void (0) : sequence[0];
                         } else {
                             for (let i = 0; i < sequence.length; i++) {
                                 const v = sequence[i];
                                 if (predicate(v))
                                     return cb ? cb(v) : v;
                             }
                             if (err)
                                 err(new Error("The sequence doesn't contain matching items"));
                             else
                                 throw new Error("The sequence doesn't contain matching items");
                         }
                     }
                 } else {
                     if (err)
                         err(new Error("The sequence is required"));
                     else
                         throw new Error("The sequence is required");
                 }
             }
             export function isDestroyable(d: any): d is IDestroyable {
                 if (d && "destroy" in d && typeof (destroy) === "function")
                     return true;
                 return false;
             }
             export function destroy(d: any) {
                 if (d && "destroy" in d)
                     d.destroy();
             }
             /**
              * Used to mark that the async operation isn't awaited intentionally.
              * @param p The promise which represents the async operation.
              */
             export function nowait(p: Promise<any>) {
             }
             /** represents already destroyed object.
              */
             export const destroyed = {
                 /** Calling to this method doesn't affect anything, noop.
                  */
                 destroy() {
                 }
             };

src/test/ts/mock/config.ts +15 -12

@@ -1,23 +1,26
1	import { Services } from "./services";	1	import { Services } from "./services";
2	import { ~~configure~~ } from "../di/traits";	2	import { fluent } from "../di/traits";
3	import { LifetimeManager } from "../di/LifetimeManager";	3
		4	export default fluent<Services>().register({
		5	host: it => it.value("example.com"),
4		6
5	export const config = configure<Services>()	7	bar2: it => Promise.all([import("./Foo"), import("./Bar")])
6	.register("host", s => s.value("example.com"))	8	.then(([{ Foo }, { Bar }]) => it
7	.register("bar2", bar2 => Promise.all([import("./Foo"), import("./Bar")])	9	.lifetime("container")
8	.then(([{ Foo }, { Bar }]) => {	10	.override({
9	const lifetime = LifetimeManager.hierarchyLifetime();	11	host: it2 => it2.value("simple.org"),
10		12	foo: it2 => it2.value(new Foo())
11	bar2.factory((resolve, activate) => {	13	})
		14	.factory(resolve => {
12	const bar = new Bar({	15	const bar = new Bar({
13	foo: ~~activate~~(~~lifetime~~, () => new Foo()),	16	foo: new Foo(),
14	nested: {	17	nested: {
15	lazy: resolve("foo", { lazy: true })	18	lazy: resolve("foo", { lazy: true })
16	},	19	},
17	host: resolve("host")	20	host: resolve("host")
18	}, "some text");	21	}, "some text");
19	bar.setName(resolve("host"));	22	bar.setName(resolve("host"));
20	return bar;	23	return bar;
		24	})
		25	)
21	});	26	});
22	})
23	);

src/test/ts/tests/ContainerTests.ts 0 -1

             import { test } from "./TestTraits";
             import { Container } from "../di/Container";
             import { ReferenceDescriptor } from "../di/ReferenceDescriptor";
             import { AggregateDescriptor } from "../di/AggregateDescriptor";
             import { ValueDescriptor } from "../di/ValueDescriptor";
             import { Foo } from "../mock/Foo";
             import { Bar } from "../mock/Bar";
             import { isNull } from "../safe";
-            import { Box } from "ts/mock/Box";
             test("Container register/resolve tests", async t => {
                 const container = new Container<{
                     "bla-bla": string;
                     "connection": string;
                     "dbParams": {
                         timeout: number;
                         connection: string;
                     }
                 }>();
                 const connection1 = "db://localhost";
                 t.throws(
                     () => container.register("bla-bla", "bla-bla" as any),
                     "Do not allow to register anything other than descriptors"
                 );
                 t.doesNotThrow(
                     () => container.register("connection", new ValueDescriptor(connection1)),
                     "register ValueDescriptor"
                 );
                 t.equals(container.resolve("connection"), connection1, "resolve string value");
                 t.doesNotThrow(
                     () => container.register(
                         "dbParams",
                         new AggregateDescriptor({
                             timeout: 10,
                             connection: new ReferenceDescriptor({ name: "connection" })
                         })
                     ),
                     "register AggregateDescriptor"
                 );
                 const dbParams = container.resolve("dbParams");
                 t.equals(dbParams.connection, connection1, "should get string value 'dbParams.connection'");
             });
             test("Container configure/resolve tests", async t => {
                 const container = new Container<{
                     foo: Foo;
                     box: Bar;
                     bar: Bar;
                     db: any;
                 }>();
                 await container.configure({
                     foo: {
                         $type: Foo
                     },
                     box: {
                         $type: Bar,
                         params: {
                             $dependency: "foo"
                         }
                     },
                     bar: {
                         $type: Bar,
                         params: [{
                             db: {
                                 provider: {
                                     $dependency: "db"
                                 }
                             }
                         }]
                     }
                 });
                 t.pass("should configure from js object");
                 const f1 = container.resolve("foo");
                 t.assert(!isNull(f1), "foo should be not null");
                 t.throws(() => container.resolve("bar"), "should not resolve dependency 'db'");
             });
             test("Load configuration from module", async t => {
                 const container = new Container();
                 await container.configure("../mock/config1", { contextRequire: require });
                 t.pass("The configuration should load");
                 const f1 = container.resolve("foo");
                 t.assert(!isNull(f1), "foo should be not null");
                 const b1 = container.resolve("bar") as Bar;
                 t.assert(!isNull(b1), "bar should not be null");
                 t.assert(!isNull(b1._v), "bar.foo should not be null");
             });

src/test/tsconfig.json 0 -2

             {
                 "extends": "../tsconfig",
                 "compilerOptions": {
-                    //"rootDir": "ts",
-                    "baseUrl": ".",
                     "rootDirs": [
                         "ts",
                         "../main/ts"
                     ]
                 },
                 "include" : [
                     "ts/**/*.ts"
                 ]
             }

src/testAmd/js/tests/plan.js +2 -1

             define([
                 "./ActivatableTests",
                 "./trace-test",
                 "./TraceSourceTests",
                 "./CancellationTests",
                 "./ObservableTests",
                 "./ContainerTests",
                 "./SafeTests",
-                "./TextTests"
+                "./TextTests",
+                "./FluentContainerTests"
             ]);

src/main/ts/di/Annotations.ts removed 0 -25

NO CONTENT: file was removed

src/main/ts/di/fluent/Configuration.ts removed 0 -59

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