implab/implabjs-core Commit - r134:511bcc634d65

working on fluent configuration, di annotations removed

cin -

r134:511bcc634d65 ioc ts support

parent child

Context file:

r134:511bcc634d65

Collapse all files

src/amd/js/data/StoreAdapter.js 0 -1

             define([
                 "dojo/_base/declare",
                 "../safe",
                 "dojo/when",
                 "dojo/store/util/QueryResults" ],
             function(declare, safe, when, QueryResults) {
                 "use strict";
                 /**
                  * Обертка вокруг произвольного хранилища, только для чтения. Используется
                  * для преобразования данных, например, отображения в списках элементов
                  * пространственных данных.
                  */
                 return declare(null, {
                     /**
                      * @type{String} Свойство, хранящее идентификатор
                      */
                     idProperty : null,
                     _store : null,
                     /**
                      * @param{String} opts.idProperty Имя свойства, в которое будет записан
                      *                идентификатор, если не указан, то идентификатор будет
                      *                взят из родительского хранилища или использоваться
                      *                строка <code>id</code>
                      * @param{dojo.store} opts.store Родительское хранилище
                      */
                     constructor : function(opts) {
                         safe.argumentNotNull(opts, "opts");
                         safe.argumentNotNull(opts.store, "opts.store");
                         this._store = opts.store;
                         delete opts.store;
                         declare.safeMixin(this, opts);
                         this.idProperty = opts.idProperty || this._store.idProperty || "id";
                     },
                     getParentStore : function() {
                         return this._store;
                     },
                     get : function(id) {
                         var me = this;
                         return when(me._store.get(id), function(x) {
                             var m = me.mapItem(x);
                             if (!(me.idProperty in m))
                                 m[me.idProperty] = id;
                             return m;
                         });
                     },
                     /**
                      * Выполняет запрос в родительском хранилище, для этого используется
                      * <code>translateQuery</code> для подготовки запроса, затем,
                      * <code>mapItem</code> для преобразования результатов.
                      */
                     query : function(q, options) {
                         var me = this, store = this._store;
                         return when(store.query(me.translateQuery(q), me
                             .translateOptions(options)), function(res) {
                             var total = res.total;
                             var mapped = res.map(function(x) {
                                 var m = me.mapItem(x);
                                 if (!(me.idProperty in m))
                                     m[me.idProperty] = store.getIdentity &&
                                         store.getIdentity(x);
                                 return m;
                             });
                             mapped.total = total;
                             var results = new QueryResults(mapped);
-                            console.log(results);
                             return results;
                         });
                     },
                     getIdentity : function(obj) {
                         return obj && obj[this.idProperty];
                     },
                     /**
                      * Преобразование запроса в формат родительского хранилища.
                      *
                      * @param{Object} q Запрос в формате текущего хранилища
                      * @returns{Object} Запрос в формате родительского хранилища
                      */
                     translateQuery : function(q) {
                         return q;
                     },
                     translateOptions : function(options) {
                         return options;
                     },
                     /**
                      * Преобразование объекта из родительского хранилища. При преобразовании
                      * в объекте можно задать идентификатор, иначе идентификатор будет
                      * автоматически получен и присвоен из родительского хранилища
                      *
                      * @param{Object} item Объект из родительского хранилища
                      * @returns{Object} результат преобразования
                      */
                     mapItem : function(item) {
                         return item;
                     }
                 });
             });

src/main/ts/components/AsyncComponent.ts +5 -4

             import { Cancellation } from "../Cancellation";
             import { IAsyncComponent, ICancellation, ICancellable, IDestroyable } from "../interfaces";
             import { destroy } from "../safe";
+            const noop = () => void (0);
             export class AsyncComponent implements IAsyncComponent, ICancellable {
-                _cancel: ((e: any) => void) | undefined;
+                _cancel: ((e: any) => void) = noop;
                 _completion: Promise<void> = Promise.resolve();
                 getCompletion() { return this._completion; }
                 runOperation(op: (ct: ICancellation) => any, ct: ICancellation = Cancellation.none) {
                     // create inner cancellation bound to the passed cancellation token
                     let h: IDestroyable;
                     const inner = new Cancellation(cancel => {
                         this._cancel = cancel;
                         h = ct.register(cancel);
                     });
                     // TODO create cancellation source here
                     const guard = async () => {
                         try {
                             await op(inner);
                         } finally {
                             // after the operation is complete we need to cleanup the
                             // resources
                             destroy(h);
-                            this._cancel = undefined;
+                            this._cancel = noop;
                         }
                     };
                     return this._completion = guard();
                 }
                 cancel(reason: any) {
-                    if (this._cancel)
+                    this._cancel(reason);
-                        this._cancel(reason);
                 }
             }

src/main/ts/di/ActivationContext.ts +19 -12

             import { TraceSource } from "../log/TraceSource";
             import { argumentNotEmptyString } from "../safe";
-            import { Descriptor, ContainerServiceMap, ContainerKeys, TypeOfService } from "./interfaces";
+            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;
             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;
                 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;
                 }
                 getName() {
                     return this._name;
                 }
                 getContainer() {
                     return this._container;
                 }
                 resolve<K extends ContainerKeys<S>>(name: K): TypeOfService<S, K>;
                 resolve<K extends ContainerKeys<S>, T>(name: K, def: T): TypeOfService<S, K> | T;
                 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;
                 }
-                has(id: string) {
+                createLifetime(): ILifetime {
-                    return id in this._cache;
+                    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;
+                        }
+                    };
                 }
-                get<T>(id: string) {
-                    return this._cache[id];
-                store(id: string, value: any) {
-                    return (this._cache[id] = value);
                 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/Configuration.ts +16 -12

             import {
                 PartialServiceMap,
                 ActivationType,
                 ContainerKeys,
                 TypeOfService,
-                ILifetimeManager
+                ILifetime
             } from "./interfaces";
             import { argumentNotEmptyString, isPrimitive, isPromise, delegate, argumentOfType, argumentNotNull, get, primitive } from "../safe";
             import { AggregateDescriptor } from "./AggregateDescriptor";
             import { ValueDescriptor } from "./ValueDescriptor";
             import { Container } from "./Container";
             import { ReferenceDescriptor } from "./ReferenceDescriptor";
             import { TypeServiceDescriptor } from "./TypeServiceDescriptor";
             import { FactoryServiceDescriptor } from "./FactoryServiceDescriptor";
             import { TraceSource } from "../log/TraceSource";
             import { ConfigError } from "./ConfigError";
             import { Cancellation } from "../Cancellation";
             import { makeResolver } from "./ResolverHelper";
             import { ICancellation } from "../interfaces";
             import { isDescriptor } from "./traits";
             import { LazyReferenceDescriptor } from "./LazyReferenceDescriptor";
             import { LifetimeManager } from "./LifetimeManager";
             export interface RegistrationScope<S extends object> {
                 /** сервисы, которые регистрируются в контексте активации и таким образом
                  * могут переопределять ранее зарегистрированные сервисы. за это свойство
                  * нужно платить, кроме того порядок активации будет влиять на результат
                  * разрешения зависимостей.
                  */
                 services?: RegistrationMap<S>;
             }
             /**
              * Базовый интерфейс конфигурации сервисов
              */
             export interface ServiceRegistration<T, S extends object> extends RegistrationScope<S> {
                 activation?: ActivationType;
                 params?: any;
                 /** Специальный идентификатор используется при активации singleton, если
                  * не указан для TypeRegistration вычисляется как oid($type)
                  */
                 typeId?: string;
                 inject?: object | object[];
                 cleanup?: ((instance: T) => void) | string;
             }
             export interface TypeRegistration<C extends new (...args: any[]) => any, S extends object> extends ServiceRegistration<InstanceType<C>, S> {
                 $type: string | C;
                 params?: Registration<ConstructorParameters<C>, S>;
             }
             export interface StrictTypeRegistration<C extends new (...args: any[]) => any, S extends object> extends ServiceRegistration<InstanceType<C>, S> {
                 $type: C;
                 params?: Registration<ConstructorParameters<C>, S>;
             }
             export interface FactoryRegistration<F extends (...args: any[]) => any, S extends object> extends ServiceRegistration<ReturnType<F>, S> {
                 $factory: string | F;
             }
             export interface ValueRegistration<T> {
                 $value: T;
                 parse?: boolean;
             }
             export interface DependencyRegistration<S extends object, K extends ContainerKeys<S> = ContainerKeys<S>> extends RegistrationScope<S> {
                 $dependency: K;
                 lazy?: boolean;
                 optional?: boolean;
                 default?: TypeOfService<S, K>;
             }
             export interface LazyDependencyRegistration<S extends object, K extends ContainerKeys<S> = ContainerKeys<S>> extends DependencyRegistration<S, K> {
                 lazy: true;
             }
             export type Registration<T, S extends object> = T extends primitive ? T :
                 (
                     T |
                     { [k in keyof T]: Registration<T[k], S> } |
                     TypeRegistration<new (...args: any[]) => T, S> |
                     FactoryRegistration<(...args: any[]) => T, S> |
                     ValueRegistration<any> |
                     DependencyRegistration<S, keyof S>
                 );
             export type RegistrationMap<S extends object> = {
                 [k in keyof S]?: Registration<S[k], S>;
             };
             const _activationTypes: { [k in ActivationType]: number; } = {
                 singleton: 1,
                 container: 2,
                 hierarchy: 3,
                 context: 4,
                 call: 5
             };
             export function isTypeRegistration(x: any): x is TypeRegistration<new () => any, any> {
                 return (!isPrimitive(x)) && ("$type" in x);
             }
             export function isFactoryRegistration(x: any): x is FactoryRegistration<() => any, any> {
                 return (!isPrimitive(x)) && ("$factory" in x);
             }
             export function isValueRegistration(x: any): x is ValueRegistration<any> {
                 return (!isPrimitive(x)) && ("$value" in x);
             }
             export function isDependencyRegistration<S extends object>(x: any): x is DependencyRegistration<S, keyof S> {
                 return (!isPrimitive(x)) && ("$dependency" in x);
             }
             export function isActivationType(x: string): x is ActivationType {
                 return typeof x === "string" && x in _activationTypes;
             }
             const trace = TraceSource.get("@implab/core/di/Configuration");
             async function mapAll(data: any[], map?: (v: any, k: number) => any): Promise<any[]>;
             async function mapAll(data: any, map?: (v: any, k: string) => any): Promise<any>;
             async function mapAll(data: any, map?: (v: any, k: any) => any): Promise<any> {
                 if (data instanceof Array) {
                     return Promise.all(map ? data.map(map) : data);
                 } else {
                     const keys = Object.keys(data);
                     const o: any = {};
                     await Promise.all(keys.map(async k => {
                         const v = map ? map(data[k], k) : data[k];
                         o[k] = isPromise(v) ? await v : v;
                     }));
                     return o;
                 }
             }
             export type ModuleResolver = (moduleName: string, ct?: ICancellation) => any;
             export class Configuration<S extends object> {
                 _hasInnerDescriptors = false;
                 readonly _container: Container<S>;
                 _path: Array<string>;
                 _configName: string | undefined;
                 _require: ModuleResolver | undefined;
                 constructor(container: Container<S>) {
                     argumentNotNull(container, "container");
                     this._container = container;
                     this._path = [];
                 }
                 async loadConfiguration(moduleName: string, contextRequire?: any, ct = Cancellation.none) {
                     argumentNotEmptyString(moduleName, "moduleName");
                     trace.log(
                         "loadConfiguration moduleName={0}, contextRequire={1}",
                         moduleName,
                         contextRequire ? typeof (contextRequire) : "<nil>"
                     );
                     this._configName = moduleName;
                     const r = await makeResolver(undefined, contextRequire);
                     const config = await r(moduleName, ct);
                     await this._applyConfiguration(
                         config,
                         await makeResolver(moduleName, contextRequire),
                         ct
                     );
                 }
                 async applyConfiguration(data: RegistrationMap<S>, contextRequire?: any, ct = Cancellation.none) {
                     argumentNotNull(data, "data");
                     await this._applyConfiguration(data, await makeResolver(void (0), contextRequire), ct);
                 }
                 async _applyConfiguration(data: RegistrationMap<S>, resolver?: ModuleResolver, ct = Cancellation.none) {
                     trace.log("applyConfiguration");
                     this._configName = "$";
                     if (resolver)
                         this._require = resolver;
                     let services: PartialServiceMap<S>;
                     try {
                         services = await this._visitRegistrations(data, "$");
                     } catch (e) {
                         throw this._makeError(e);
                     }
                     this._container.register(services);
                 }
                 _makeError(inner: any) {
                     const e = new ConfigError("Failed to load configuration", inner);
                     e.configName = this._configName || "<inline>";
                     e.path = this._makePath();
                     return e;
                 }
                 _makePath() {
                     return this._path
                         .reduce(
                             (prev, cur) => typeof cur === "number" ?
                                 `${prev}[${cur}]` :
                                 `${prev}.${cur}`
                         )
                         .toString();
                 }
                 async _resolveType(moduleName: string, localName: string) {
                     trace.log("resolveType moduleName={0}, localName={1}", moduleName, localName);
                     try {
                         const m = await this._loadModule(moduleName);
                         if (localName) {
                             return get(localName, m);
                         } else {
                             if (m instanceof Function)
                                 return m;
                             if ("default" in m)
                                 return m.default;
                             return m;
                         }
                     } catch (e) {
                         trace.error("Failed to resolve type moduleName={0}, localName={1}", moduleName, localName);
                         throw e;
                     }
                 }
                 _loadModule(moduleName: string) {
                     trace.debug("loadModule {0}", moduleName);
                     if (!this._require)
                         throw new Error("Module loader isn't specified");
                     return this._require(moduleName);
                 }
                 async _visitRegistrations(data: RegistrationMap<S>, name: string) {
                     this._enter(name);
                     if (data.constructor &&
                         data.constructor.prototype !== Object.prototype)
                         throw new Error("Configuration must be a simple object");
                     const services = await mapAll(data, async (v, k) => {
                         const d = await this._visit(v, k.toString());
                         return isDescriptor(d) ? d : new AggregateDescriptor(d);
                     }) as PartialServiceMap<S>;
                     this._leave();
                     return services;
                 }
                 _enter(name: string) {
                     this._path.push(name.toString());
                     trace.debug(">{0}", name);
                 }
                 _leave() {
                     const name = this._path.pop();
                     trace.debug("<{0}", name);
                 }
-                async _visit(data: any, name: string): Promise<any> {
+                _visit(data: any, name: string): Promise<any> {
-                    if (isPrimitive(data) || isDescriptor(data))
+                    if (isPrimitive(data))
-                        return data;
+                        return Promise.resolve(new ValueDescriptor(data));
+                    if (isDescriptor(data))
+                        return Promise.resolve(data);
                     if (isDependencyRegistration<S>(data)) {
                         return this._visitDependencyRegistration(data, name);
                     } else if (isValueRegistration(data)) {
                         return this._visitValueRegistration(data, name);
                     } else if (isTypeRegistration(data)) {
                         return this._visitTypeRegistration(data, name);
                     } else if (isFactoryRegistration(data)) {
                         return this._visitFactoryRegistration(data, name);
                     } else if (data instanceof Array) {
                         return this._visitArray(data, name);
                     }
                     return this._visitObject(data, name);
                 }
                 async _visitObject(data: any, name: string) {
                     if (data.constructor &&
                         data.constructor.prototype !== Object.prototype)
                         return new ValueDescriptor(data);
                     this._enter(name);
                     const v = await mapAll(data, delegate(this, "_visit"));
                     // TODO: handle inline descriptors properly
                     // const ex = {
                     //     activate(ctx) {
                     //         const value = ctx.activate(this.prop, "prop");
                     //         // some code
                     //     },
                     //     // will be turned to ReferenceDescriptor
                     //     prop: { $dependency: "depName" }
                     // };
                     this._leave();
                     return v;
                 }
                 async _visitArray(data: any[], name: string) {
                     if (data.constructor &&
                         data.constructor.prototype !== Array.prototype)
                         return new ValueDescriptor(data);
                     this._enter(name);
                     const v = await mapAll(data, delegate(this, "_visit"));
                     this._leave();
                     return v;
                 }
                 _makeServiceParams(data: ServiceRegistration<any, S>) {
                     const opts: any = {
                     };
                     if (data.services)
                         opts.services = this._visitRegistrations(data.services, "services");
                     if (data.inject) {
                         this._enter("inject");
                         opts.inject = mapAll(
                             data.inject instanceof Array ?
                                 data.inject :
                                 [data.inject],
                             delegate(this, "_visitObject")
                         );
                         this._leave();
                     }
                     if ("params" in data)
                         opts.params = data.params instanceof Array ?
                             this._visitArray(data.params, "params") :
                             this._visit(data.params, "params");
                     if (data.activation) {
                         opts.activation = this._getLifetimeManager(data.activation, data.typeId);
                     }
                     if (data.cleanup)
                         opts.cleanup = data.cleanup;
                     return opts;
                 }
                 async _visitValueRegistration<T>(data: ValueRegistration<T>, name: string) {
                     this._enter(name);
                     const d = data.parse ? new AggregateDescriptor(data.$value) : new ValueDescriptor(data.$value);
                     this._leave();
                     return d;
                 }
                 async _visitDependencyRegistration<K extends keyof S>(data: DependencyRegistration<S, K>, name: string) {
                     argumentNotEmptyString(data && data.$dependency, "data.$dependency");
                     this._enter(name);
                     const options = {
                         name: data.$dependency,
                         optional: data.optional,
                         default: data.default,
                         services: data.services && await this._visitRegistrations(data.services, "services")
                     };
                     const d = data.lazy ? new LazyReferenceDescriptor<S, K>(options) : new ReferenceDescriptor<S, K>(options);
                     this._leave();
                     return d;
                 }
                 async _visitTypeRegistration(data: TypeRegistration<new () => any, S>, name: string) {
                     argumentNotNull(data.$type, "data.$type");
                     this._enter(name);
                     const opts = this._makeServiceParams(data);
                     if (data.$type instanceof Function) {
                         opts.type = data.$type;
                     } else {
                         const [moduleName, typeName] = data.$type.split(":", 2);
-                        const t = opts.type = this._resolveType(moduleName, typeName);
+                        opts.type = this._resolveType(moduleName, typeName).then(t => {
-                        if (!(t instanceof Function))
+                            if (!(t instanceof Function))
-                            throw Error("$type (" + data.$type + ") is not a constructable");
+                                throw Error("$type (" + data.$type + ") is not a constructable");
+                            return t;
+                        });
                     }
                     const d = new TypeServiceDescriptor<S, any, any[]>(
                         await mapAll(opts)
                     );
                     this._leave();
                     return d;
                 }
                 async _visitFactoryRegistration(data: FactoryRegistration<() => any, S>, name: string) {
                     argumentOfType(data.$factory, Function, "data.$factory");
                     this._enter(name);
                     const opts = this._makeServiceParams(data);
                     opts.factory = data.$factory;
                     const d = new FactoryServiceDescriptor<S, any, any[]>(
                         await mapAll(opts)
                     );
                     this._leave();
                     return d;
                 }
-                _getLifetimeManager(activation: ActivationType, typeId: string | undefined): ILifetimeManager {
+                _getLifetimeManager(activation: ActivationType, typeId: string | undefined): ILifetime {
                     switch (activation) {
                         case "container":
-                            return this._container.getLifetimeManager();
+                            return LifetimeManager.containerLifetime(this._container);
                         case "hierarchy":
-                            return LifetimeManager.hierarchyLifetime;
+                            return LifetimeManager.hierarchyLifetime();
                         case "context":
-                            return LifetimeManager.contextLifetime;
+                            return LifetimeManager.contextLifetime();
                         case "singleton":
                             if (typeId === undefined)
                                 throw Error("The singleton activation requires a typeId");
                             return LifetimeManager.singletonLifetime(typeId);
                         default:
-                            return LifetimeManager.empty;
+                            return LifetimeManager.empty();
                     }
                 }
             }

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

             import { argumentNotEmptyString, each } from "../safe";
             import { ActivationContext } from "./ActivationContext";
             import { Descriptor, PartialServiceMap, TypeOfService, ContainerKeys } from "./interfaces";
             import { ActivationError } from "./ActivationError";
             export interface ReferenceDescriptorParams<S extends object, K extends ContainerKeys<S>> {
                 name: K;
                 optional?: boolean;
                 default?: TypeOfService<S, K>;
                 services?: PartialServiceMap<S>;
             }
             export class LazyReferenceDescriptor<S extends object = any, K extends ContainerKeys<S> = ContainerKeys<S>>
                 implements Descriptor<S, ((args?: PartialServiceMap<S>) => TypeOfService<S, K>)> {
                 _name: K;
                 _optional = false;
                 _default: TypeOfService<S, K> | undefined;
                 _services: PartialServiceMap<S>;
                 constructor(opts: ReferenceDescriptorParams<S, K>) {
                     argumentNotEmptyString(opts && opts.name, "opts.name");
                     this._name = opts.name;
                     this._optional = !!opts.optional;
                     this._default = opts.default;
                     this._services = (opts.services || {}) as PartialServiceMap<S>;
                 }
                 activate(context: ActivationContext<S>) {
                     // добавляем сервисы
                     if (this._services) {
                         each(this._services, (v, k) => context.register(k, v));
                     }
                     const saved = context.clone();
-                    return (cfg?: PartialServiceMap<S>) => {
+                    return (cfg?: PartialServiceMap<S>): any => {
                         // защищаем контекст на случай исключения в процессе
                         // активации
                         const ct = cfg ? saved.clone() : saved;
                         try {
                             if (cfg) {
                                 each(cfg, (v, k) => ct.register(k, v));
                             }
                             return this._optional ? ct.resolve(this._name, this._default) : ct
                                 .resolve(this._name);
                         } catch (error) {
                             throw new ActivationError(this._name.toString(), ct.getStack(), error);
                         }
                     };
                 }
                 toString() {
                     const opts = [];
                     if (this._optional)
                         opts.push("optional");
                     opts.push("lazy");
                     const parts = [
                         "@ref "
                     ];
                     if (opts.length) {
                         parts.push("{");
                         parts.push(opts.join());
                         parts.push("} ");
                     }
                     parts.push(this._name.toString());
                     if (this._default !== undefined && this._default !== null) {
                         parts.push(" = ");
                         parts.push(String(this._default));
                     }
                     return parts.join("");
                 }
             }

src/main/ts/di/LifetimeManager.ts +80 -36

             import { IDestroyable, MapOf } from "../interfaces";
             import { argumentNotNull, isDestroyable } from "../safe";
             import { ILifetimeManager, ILifetime } from "./interfaces";
             import { ActivationContext } from "./ActivationContext";
+            import { Container } from "./Container";
             function safeCall(item: () => void) {
                 try {
                     item();
                 } catch {
                     // silence!
                 }
             }
             const emptyLifetime: ILifetime = {
                 has() {
                     return false;
                 },
-                enter() {
+                initialize() {
                 },
                 get() {
                     throw new Error("The specified item isn't registered with this lifetime manager");
                 },
                 store() {
                     // does nothing
                 }
             };
+            const unknownLifetime: ILifetime = {
+                has() {
+                    throw new Error("The lifetime is unknown");
+                },
+                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 {
                 private _cleanup: (() => void)[] = [];
                 private _cache: MapOf<any> = {};
                 private _destroyed = false;
                 private _pending: MapOf<boolean> = {};
-                initialize(): ILifetime {
+                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;
                         },
-                        enter() {
+                        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 readonly empty: ILifetimeManager = {
+                static empty(): ILifetime {
-                    initialize(): ILifetime {
+                    return emptyLifetime;
-                        return emptyLifetime;
-                };
+                static hierarchyLifetime(): ILifetime {
+                    let _lifetime = unknownLifetime;
+                    return {
+                        initialize(context: ActivationContext<any>) {
+                            if (_lifetime !== unknownLifetime)
+                                throw new Error("Cyclic reference activation detected");
-                static readonly hierarchyLifetime: ILifetimeManager = {
+                            _lifetime = context.getContainer().getLifetimeManager().create(context);
-                    initialize(context: ActivationContext<any>): ILifetime {
+                        },
-                        return context.getContainer().getLifetimeManager().initialize(context);
+                        get() {
+                            return _lifetime.get();
-                };
+                        },
+                        has() {
+                            return _lifetime.has();
+                        },
+                        store(item: any, cleanup?: (item: any) => void) {
+                            return _lifetime.store(item, cleanup);
+                        }
+                    };
+                }
-                static readonly contextLifetime: ILifetimeManager = {
+                static contextLifetime(): ILifetime {
-                    initialize(context: ActivationContext<any>): ILifetime {
+                    let _lifetime = unknownLifetime;
-                        const id = String(++nextId);
+                    return {
-                        return {
+                        initialize(context: ActivationContext<any>) {
-                            enter() {
+                            if (_lifetime !== unknownLifetime)
-                                if (context.visit(id))
+                                throw new Error("Cyclic reference detected");
-                                    throw new Error("Cyclic reference detected");
+                            _lifetime = context.createLifetime();
-                            },
+                        },
-                            get() {
+                        get() {
-                                return context.get(id);
+                            return _lifetime.get();
-                            },
+                        },
-                            has() {
+                        has() {
-                                return context.has(id);
+                            return _lifetime.has();
-                            },
+                        },
-                            store(item: any) {
+                        store(item: any) {
-                                context.store(id, item);
+                            _lifetime.store(item);
+                        }
-                        };
+                    };
+                }
-                };
-                static singletonLifetime(typeId: string): ILifetimeManager {
+                static singletonLifetime(typeId: string): ILifetime {
+                    return emptyLifetime;
+                }
+                static containerLifetime(container: Container<any>) {
+                    let _lifetime = unknownLifetime;
                     return {
-                        initialize() {
+                        initialize(context: ActivationContext<any>) {
-                            return emptyLifetime;
+                            if (_lifetime !== unknownLifetime)
+                                throw new Error("Cyclic reference detected");
+                            _lifetime = container.getLifetimeManager().create(context);
+                        },
+                        get() {
+                            return _lifetime.get();
+                        },
+                        has() {
+                            return _lifetime.has();
+                        },
+                        store(item: any) {
+                            _lifetime.store(item);
                         }
                     };
                 }
             }

src/main/ts/di/ReferenceDescriptor.ts +21 -1

             import { argumentNotEmptyString, each } from "../safe";
             import { ActivationContext } from "./ActivationContext";
             import { Descriptor, PartialServiceMap, TypeOfService, ContainerKeys } from "./interfaces";
             export interface ReferenceDescriptorParams<S extends object, K extends ContainerKeys<S>> {
+                /**
+                 * The name of the descriptor
+                 */
                 name: K;
+                /**
+                 * The flag that indicates that the referenced service isn't required to exist.
+                 * If the reference is optional and the referenced service doesn't exist,
+                 * the undefined or a default value will be returned.
+                 */
                 optional?: boolean;
+                /**
+                 * a default value for the reference when the referenced service doesn't exist.
+                 */
                 default?: TypeOfService<S, K>;
+                /**
+                 * The service overrides
+                 */
                 services?: PartialServiceMap<S>;
             }
             export class ReferenceDescriptor<S extends object = any, K extends ContainerKeys<S> = ContainerKeys<S>>
                 implements Descriptor<S, TypeOfService<S, K>> {
                 _name: K;
                 _optional = false;
                 _default: TypeOfService<S, K> | undefined;
                 _services: PartialServiceMap<S>;
                 constructor(opts: ReferenceDescriptorParams<S, K>) {
                     argumentNotEmptyString(opts && opts.name, "opts.name");
                     this._name = opts.name;
                     this._optional = !!opts.optional;
                     this._default = opts.default;
                     this._services = (opts.services || {}) as PartialServiceMap<S>;
                 }
-                activate(context: ActivationContext<S>) {
+                /** This method activates the referenced service if one exists
+                 * @param context activation context which is used during current activation
+                 */
+                activate(context: ActivationContext<S>): any {
                     // добавляем сервисы
                     if (this._services) {
                         each(this._services, (v, k) => context.register(k, v));
                     }
                     const res = this._optional ?
                         context.resolve(this._name, this._default) :
                         context.resolve(this._name);
                     return res;
                 }
                 toString() {
                     const opts = [];
                     if (this._optional)
                         opts.push("optional");
                     const parts = [
                         "@ref "
                     ];
                     if (opts.length) {
                         parts.push("{");
                         parts.push(opts.join());
                         parts.push("} ");
                     }
                     parts.push(this._name.toString());
                     if (this._default !== undefined && this._default !== null) {
                         parts.push(" = ");
                         parts.push(String(this._default));
                     }
                     return parts.join("");
                 }
             }

src/main/ts/di/ServiceDescriptor.ts +5 -8

             import { ActivationContext } from "./ActivationContext";
             import { Descriptor, ServiceMap, PartialServiceMap, ILifetimeManager, 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?: ILifetimeManager;
+                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;
-                _lifetimeManager = LifetimeManager.empty;
+                _lifetime = LifetimeManager.empty();
                 _objectLifetime: ILifetime | undefined;
                 constructor(opts: ServiceDescriptorParams<S, T, P>) {
                     if (opts.lifetime)
-                        this._lifetimeManager = 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>) {
-                    if (!this._objectLifetime)
+                    const lifetime = this._lifetime;
-                        this._objectLifetime = this._lifetimeManager.initialize(context);
-                    const lifetime = this._objectLifetime;
                     if (lifetime.has()) {
                         return lifetime.get();
                     } else {
-                        lifetime.enter();
+                        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 +2 -6

-            import { Resolver, ServiceModule, LazyDependencyOptions, DependencyOptions } from "./interfaces";
+            import { Resolver, LazyDependencyOptions, DependencyOptions } from "./interfaces";
-            import { AnnotationBuilder } from "../Annotations";
             import { Container } from "../Container";
             import { Descriptor, ILifetime, ContainerKeys } from "../interfaces";
             import { ActivationContext } from "../ActivationContext";
             export class DescriptorBuilder<T, S extends object> {
                 readonly _container: Container<S>;
                 readonly _cb: (d: Descriptor<S, T>) => void;
                 constructor(container: Container<S>, cb: (d: Descriptor<S, T>) => void) {
                     this._container = container;
                     this._cb = cb;
                 }
-                service(service: AnnotationBuilder<T, S> | ServiceModule<T, S>) {
                 factory(f: (resolve: Resolver<S>, activate: (lifetime: ILifetime, factory: () => any, cleanup?: (item: any) => void) => any) => T): void {
                     this._cb({
                         activate(context: ActivationContext<S>) {
                             const resolve = (name: ContainerKeys<S>, opts?: DependencyOptions | LazyDependencyOptions) => {
                                 if (opts && "lazy" in opts && opts.lazy) {
                                     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 activate = (lifetime: ILifetime, factory: () => any, cleanup?: (item: any) => void) => {
                                 if (lifetime.has()) {
                                     return lifetime.get();
                                 } else {
-                                    lifetime.enter();
+                                    lifetime.initialize(context);
                                     const instance = factory();
                                     lifetime.store(instance, cleanup);
                                     return instance;
                                 }
                             };
                             return f(resolve, activate);
                         }
                     });
                 }
                 value(v: T): void {
                     this._cb({
                         activate() {
                             return v;
                         }
                     });
                 }
             }

src/main/ts/di/fluent/interfaces.ts +3 -3

             import { primitive } from "../../safe";
             import { AnnotationBuilder } from "../Annotations";
             import { ILifetime, TypeOfService, ContainerKeys } 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 keyof ContainerKeys<S>, O> = O extends { default: infer X } ? (TypeOfService<S, K> | X) :
+            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 keyof ContainerKeys<S>, O extends LazyDependencyOptions>(this: void, name: K, opts: O): () => InferReferenceType<S, K, O>;
+                <K extends ContainerKeys<S>, O extends LazyDependencyOptions>(this: void, name: K, opts: O): () => InferReferenceType<S, K, O>;
-                <K extends keyof ContainerKeys<S>, O extends DependencyOptions>(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> {
                 service(service: AnnotationBuilder<T, S> | ServiceModule<T, S>): void;
                 factory(f: (resolve: Resolver<S>, activate: <T2>(lifetime: ILifetime, factory: () => T2, cleanup?: (item: T2) => void) => T2) => T): void;
                 value(v: T): void;
             }
             export interface Configuration<S extends object, Y extends keyof S = keyof S> {
                 register<K extends Y>(name: K, builder: (d: DescriptorBuilder<S[K], S>) => void): Configuration<S, Exclude<Y, K>>;
             }

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

             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 {
-                initialize(context: ActivationContext<any>): ILifetime;
+                create(context: ActivationContext<any>): ILifetime;
             }
             /**
              * Интерфейс для управления жизнью экземпляра объекта. Каждая регистрация имеет
              * свой собственный объект `ILifetime`, который создается при первой активации
              */
             export interface ILifetime {
                 /** Проверяет, что уже создан экземпляр объекта */
                 has(): boolean;
                 get(): any;
-                enter(): void;
+                initialize(context: ActivationContext<any>): void;
                 store(item: any, cleanup?: (item: any) => void): void;
             }

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

             import { isPrimitive } from "../safe";
             import { Descriptor } from "./interfaces";
-            import { AnnotationBuilder } from "./Annotations";
             import { Configuration } from "./fluent/Configuration";
             export function isDescriptor(x: any): x is Descriptor {
                 return (!isPrimitive(x)) &&
                     (x.activate instanceof Function);
             }
-            export function declare<S extends object>() {
+            export function configure<S extends object>() {
-                return {
+                return new Configuration<S>();
-                    annotate<T>() {
-                        return new AnnotationBuilder<T, S>();
-                    },
-                    configure(): Configuration<S> {
-                        throw new Error();
-                    },
-                    dependency() {
-                        throw new Error();
-                };
             }

src/main/ts/safe.ts +7 -12

             import { ICancellable, Constructor, IDestroyable } from "./interfaces";
             import { Cancellation } from "./Cancellation";
             let _nextOid = 0;
             const _oid = typeof Symbol === "function" ?
                 Symbol("__implab__oid__") :
                 "__implab__oid__";
             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 Результат вызова функции <c>cb</c>, либо <c>undefined</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++) {
-                        const x = cb.call(thisArg, obj[i], i);
+                        v = obj[i];
-                        if (x !== undefined)
+                        if (v !== undefined)
-                            return x;
+                            cb.call(thisArg, v, i);
                     }
                 } else {
-                    const _keys = Object.keys(obj);
+                    Object.keys(obj).forEach(k => obj[k] !== undefined && cb.call(thisArg, obj[k], k));
-                    for (const k of _keys) {
-                        const x = cb.call(thisArg, obj[k], k);
-                        if (x !== undefined)
-                            return x;
                 }
             }
             /** 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")
+                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/main/ts/text/StringFormat.ts +1 -1

-            import { isPrimitive, isNull, each, isKeyof, get } from "../safe";
+            import { isPrimitive, isNull, isKeyof, get } from "../safe";
             import { MapOf } from "../interfaces";
             type SubstFn = (name: string, format?: string) => string;
             type TemplateFn = (subst: SubstFn) => string | undefined;
             type ConvertFn = (value: any, format?: string) => string;
             const map = {
                 "\\{": "&curlopen;",
                 "\\}": "&curlclose;",
                 "&": "&amp;",
                 "\\:": "&colon;"
             };
             const rev = {
                 curlopen: "{",
                 curlclose: "}",
                 amp: "&",
                 colon: ":"
             };
             function espaceString(s: string) {
                 if (!s)
                     return s;
                 return "'" + s.replace(/('|\\)/g, "\\$1").replace("\n", "\\n") + "'";
             }
             function encode(s: string) {
                 if (!s)
                     return s;
                 return s.replace(/\\{|\\}|&|\\:|\n/g, m => isKeyof(m, map) ? map[m] : m);
             }
             function decode(s: string) {
                 if (!s)
                     return s;
                 return s.replace(/&(\w+);/g, (m, $1) => isKeyof($1, rev) ? rev[$1] : m);
             }
             function subst(s: string) {
                 const i = s.indexOf(":");
                 let name: string;
                 let pattern: string | undefined;
                 if (i >= 0) {
                     name = s.substr(0, i);
                     pattern = s.substr(i + 1);
                 } else {
                     name = s;
                 }
                 if (pattern)
                     return [
                         espaceString(decode(name)),
                         espaceString(decode(pattern))
                     ];
                 else
                     return [espaceString(decode(name))];
             }
             function _compile(str: string) {
                 if (!str)
                     return () => void 0;
                 const chunks = encode(str).split("{");
                 let chunk: string;
                 const code = ["var result=[];"];
                 for (let i = 0; i < chunks.length; i++) {
                     chunk = chunks[i];
                     if (i === 0) {
                         if (chunk)
                             code.push("result.push(" + espaceString(decode(chunk)) +
                                 ");");
                     } else {
                         const len = chunk.indexOf("}");
                         if (len < 0)
                             throw new Error("Unbalanced substitution #" + i);
                         code.push("result.push(subst(" +
                             subst(chunk.substr(0, len)).join(",") + "));");
                         if (chunk.length > len + 1)
                             code.push("result.push(" +
                                 espaceString(decode(chunk.substr(len + 1))) + ");");
                     }
                 }
                 code.push("return result.join('');");
                 // the code for this function is generated from the template
                 // tslint:disable-next-line:function-constructor
                 return new Function("subst", code.join("\n")) as TemplateFn;
             }
             const cache: MapOf<TemplateFn> = {};
             export function compile(template: string) {
                 let compiled = cache[template];
                 if (!compiled) {
                     compiled = _compile(template);
                     cache[template] = compiled;
                 }
                 return compiled;
             }
             function defaultConverter(value: any, pattern?: string) {
                 if (pattern && pattern.toLocaleLowerCase() === "json") {
                     const seen: any = [];
                     return JSON.stringify(value, (k, v) => {
                         if (!isPrimitive(v)) {
                             const id = seen.indexOf(v);
                             if (id >= 0)
                                 return "@ref-" + id;
                             else {
                                 seen.push(v);
                                 return v.toString() as string;
                             }
                         } else {
                             return isNull(v) ? "" : v.toString();
                         }
                     }, 2);
                 } else if (isNull(value)) {
                     return "";
                 } else if (value instanceof Date) {
                     return value.toISOString();
                 } else {
                     return value.toString() as string;
                 }
             }
             export class Formatter {
                 _converters: ConvertFn[];
                 constructor(converters?: ConvertFn[]) {
                     this._converters = converters || [];
                     this._converters.push(defaultConverter);
                 }
                 convert(value: any, pattern?: string) {
                     for (const c of this._converters) {
                         const res = c(value, pattern);
                         if (!isNull(res))
                             return res;
                     }
                     return "";
                 }
                 format(msg: string, ...args: any[]) {
                     const template = compile(msg);
                     return template((name, pattern) => {
                         const value = get(name, args);
                         return !isNull(value) ? this.convert(value, pattern) : "";
                     });
                 }
                 compile(msg: string) {
                     const template = compile(msg);
                     return (...args: any[]) => {
                         return template((name, pattern) => {
                             const value = get(name, args);
                             return !isNull(value) ? this.convert(value, pattern) : "";
                         });
                     };
                 }
             }
             const _default = new Formatter();
             export function format(msg: string, ...args: any[]) {
                 return _default.format(msg, ...args);
             }
             export function convert(value: any, pattern: string) {
                 return _default.format(value, pattern);
             }

src/test/ts/mock/Bar.ts +13 -9

             import { Foo } from "./Foo";
-            import { annotate, dependency } from "./services";
-            export const service = annotate<Bar>();
+            /* export const service = annotate<Bar>();
             @service.wire({
                 foo: dependency("foo"),
                 nested: {
                     lazy: dependency("foo", { lazy: true })
                 },
                 host: dependency("host")
-            }, "")
+            }, "") */
             export class Bar {
                 barName = "Twister";
                 _v: Foo | undefined;
-                constructor(_opts: {
+                constructor(
-                    foo?: Foo;
+                    _opts: {
-                    nested?: {
+                        foo?: Foo;
-                        lazy: () => Foo
+                        nested?: {
+                            lazy: () => Foo
+                        },
+                        host: string
                     },
-                    host: string
+                    s: string
-                }, s: string) {
+                ) {
                     if (_opts && _opts.foo)
                         this._v = _opts.foo;
+                    if (s)
+                        this.barName = s;
                 }
                 setName(name: string) {
                 }
                 getFoo() {
                     if (this._v === undefined)
                         throw new Error("The foo isn't set");
                     return this._v;
                 }
             }

src/test/ts/mock/Box.ts +3 -4

             import { Bar } from "./Bar";
-            import { annotate, dependency } from "./services";
             // export service descriptor
             // через service передается информация о типе зависимости
             // даже если это шаблон.
-            export const service = annotate<Box<Bar>>();
+            // export const service = annotate<Box<Bar>>();
-            @service.wire()
+            // @service.wire()
             export class Box<T> {
                 private _value: T | undefined;
                 constructor(value?: T) {
                     this._value = value;
                 }
-                @service.inject(dependency("bar"))
+                // @service.inject(dependency("bar"))
                 setValue(value: T) {
                     this._value = value;
                     return value;
                 }
                 getValue() {
                     if (this._value === undefined)
                         throw new Error("Trying to get a value from the empty box");
                     return this._value;
                 }
             }

src/test/ts/mock/config.ts +6 -3

-            import { configure } from "./services";
+            import { Services } from "./services";
+            import { configure } from "../di/traits";
+            import { LifetimeManager } from "../di/LifetimeManager";
-            export const config = configure()
+            export const config = configure<Services>()
                 .register("host", s => s.value("example.com"))
                 .register("bar2", bar2 => Promise.all([import("./Foo"), import("./Bar")])
                     .then(([{ Foo }, { Bar }]) => {
-                        const lifetime: any = undefined; // new HierarchyLifetime()
+                        const lifetime = LifetimeManager.hierarchyLifetime();
                         bar2.factory((resolve, activate) => {
                             const bar = new Bar({
                                 foo: activate(lifetime, () => new Foo()),
                                 nested: {
                                     lazy: resolve("foo", { lazy: true })
                                 },
                                 host: resolve("host")
                             }, "some text");
                             bar.setName(resolve("host"));
                             return bar;
                         });
                     })
                 );

src/test/ts/mock/services.ts 0 -6

             import { Foo } from "./Foo";
             import { Bar } from "./Bar";
             import { Box } from "./Box";
-            import { declare } from "../di/traits";
             /**
              * Сервисы доступные внутри контейнера
              */
             export interface Services {
                 foo: Foo;
                 bar: Bar;
                 bar2: Bar;
                 box: Box<Bar>;
                 host: string;
             }
-            /**
-             * Экспортируем вспомогательные функции для описания сервисов и кинфогурации
-             */
-            export const { dependency, annotate, configure } = declare<Services>();

src/test/ts/tests/ConfigurationBuilderTests.ts removed 0 -36

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