implab/implabjs-core Commit - r114:475b8ce3e850

working on IoC configuration

cin -

r114:475b8ce3e850 ioc ts support

parent child

Context file:

r114:475b8ce3e850

Collapse all files

src/main/ts/di/ActivationContext.ts +29 -23

             import { TraceSource } from "../log/TraceSource";
             import { argumentNotNull, argumentNotEmptyString, isPrimitive, each, isNull } from "../safe";
             import { Descriptor, ServiceMap } from "./interfaces";
             import { Container } from "./Container";
+            import { MapOf } from "../interfaces";
             const trace = TraceSource.get("@implab/core/di/ActivationContext");
-            export interface ActivationContextInfo {
+            export interface ActivationContextInfo<S> {
                 name: string;
                 service: string;
-                scope: ServiceMap;
+                scope: ServiceMap<S>;
             }
-            export class ActivationContext {
+            export class ActivationContext<S> {
-                _cache: object;
+                _cache: MapOf<any>;
-                _services: ServiceMap;
+                _services: ServiceMap<S>;
-                _stack: ActivationContextInfo[];
+                _stack: ActivationContextInfo<S>[];
-                _visited: object;
+                _visited: MapOf<any>;
                 _name: string;
-                _localized: boolean;
+                _localized: boolean = false;
-                container: Container;
+                container: Container<S>;
-                constructor(container: Container, services: ServiceMap, name?: string, cache?: object, visited?) {
+                constructor(container: Container<S>, services: ServiceMap<S>, name?: string, cache?: object, visited?: MapOf<any>) {
                     argumentNotNull(container, "container");
                     argumentNotNull(services, "services");
-                    this._name = name;
+                    this._name = name || "<unnamed>";
                     this._visited = visited || {};
                     this._stack = [];
                     this._cache = cache || {};
                     this._services = services;
                     this.container = container;
                 }
                 getName() {
                     return this._name;
                 }
-                resolve(name, def?): any {
+                resolve<K extends keyof S, T extends S[K]>(name: K, def?: T) {
                     const d = this._services[name];
-                    if (!d)
+                    if (d !== undefined) {
-                        if (arguments.length > 1)
+                        return this.activate(d as Descriptor<T>, name.toString());
+                    } else {
+                        if (def !== undefined && def !== null)
                             return def;
                         else
                             throw new Error(`Service ${name} not found`);
+                    }
-                    return this.activate(d, name);
                 }
                 /**
                  * registers services local to the the activation context
                  *
                  * @name{string} the name of the service
                  * @service{string} the service descriptor to register
                  */
-                register(name: string, service: Descriptor) {
+                register<K extends keyof S>(name: K, service: Descriptor<S[K]>) {
                     argumentNotEmptyString(name, "name");
                     this._services[name] = service;
                 }
                 clone() {
                     return new ActivationContext(
                         this.container,
                         this._services,
                         this._name,
                         this._cache,
                         this._visited
                     );
                 }
                 has(id: string) {
                     return id in this._cache;
                 }
-                get(id: string) {
+                get<T>(id: string) {
                     return this._cache[id];
                 }
-                store(id: string, value) {
+                store(id: string, value: any) {
                     return (this._cache[id] = value);
                 }
-                activate(d: Descriptor, name: string) {
+                activate<T>(d: Descriptor<T>, name: string) {
                     if (trace.isLogEnabled())
                         trace.log(`enter ${name} ${d}`);
                     this.enter(name, d.toString());
-                    const v = d.activate(this);
+                    const v = d.activate<S>(this);
                     this.leave();
                     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() {
                     return this._stack.slice().reverse();
                 }
                 private enter(name: string, service: string) {
                     this._stack.push({
                         name,
                         service,
                         scope: this._services
                     });
                     this._name = name;
                     this._services = Object.create(this._services);
                 }
                 private leave() {
                     const ctx = this._stack.pop();
-                    this._services = ctx.scope;
+                    if (ctx) {
-                    this._name = ctx.name;
+                        this._services = ctx.scope;
+                        this._name = ctx.name;
+                    } else {
+                        trace.error("Trying to leave the last activation scope");
+                    }
                 }
             }

src/main/ts/di/ActivationError.ts +6 -3

-            import { ActivationContextInfo } from "./ActivationContext";
+            export interface ActivationItem {
+                name: string;
+                service: string;
+            }
             export class ActivationError {
-                activationStack: ActivationContextInfo[];
+                activationStack: ActivationItem[];
                 service: string;
                 innerException: any;
                 message: string;
-                constructor(service: string, activationStack: ActivationContextInfo[], innerException: any) {
+                constructor(service: string, activationStack: ActivationItem[], innerException: any) {
                     this.message = "Failed to activate the service";
                     this.activationStack = activationStack;
                     this.service = service;
                     this.innerException = innerException;
                 }
                 toString() {
                     const parts = [this.message];
                     if (this.service)
                         parts.push("when activating: " + this.service.toString());
                     if (this.innerException)
                         parts.push("caused by: " + this.innerException.toString());
                     if (this.activationStack) {
                         parts.push("at");
                         this.activationStack
                             .forEach(x => parts.push(`    ${x.name} ${x.service}`));
                     }
                     return parts.join("\n");
                 }
             }

src/main/ts/di/AggregateDescriptor.ts +11 -9

             import { Descriptor, isDescriptor } from "./interfaces";
             import { ActivationContext } from "./ActivationContext";
             import { isPrimitive } from "../safe";
-            export class AggregateDescriptor<T> implements Descriptor<T> {
+            type Parse<T> = T extends Descriptor<infer V> ? V :
+                    T extends {} ? { [K in keyof T]: Parse<T[K]> } :
+                    T;
+            export class AggregateDescriptor<T> implements Descriptor<Parse<T>> {
                 _value: T;
                 constructor(value: T) {
                     this._value = value;
                 }
-                activate(context: ActivationContext) {
+                activate<S>(context: ActivationContext<S>) {
                     return this._parse(this._value, context, "$value");
                 }
-                // TODO: make async
+                _parse<S, V>(value: V, context: ActivationContext<S>, path: string): Parse<V> {
-                _parse(value: T, context: ActivationContext, path: string) {
                     if (isPrimitive(value))
-                        return value;
+                        return value as any;
                     if (isDescriptor(value))
                         return context.activate(value, path);
                     if (value instanceof Array)
-                        return value.map((x, i) => this._parse(x, context, `${path}[${i}]`));
+                        return value.map((x, i) => this._parse(x, context, `${path}[${i}]`)) as any;
-                    const t = {};
+                    const t: any = {};
-                    for (const p of Object.keys(value))
+                    for (const p in value)
                         t[p] = this._parse(value[p], context, `${path}.${p}`);
                     return t;
                 }
                 toString() {
                     return "@walk";
                 }
             }

src/main/ts/di/Annotations.ts +23 -3

             import { Constructor } from "../interfaces";
             export interface InjectOptions {
                 lazy?: boolean;
             }
+            interface Dependency<K extends keyof any> {
+                $dependency: K;
+                lazy?: boolean;
+            }
+            interface Lazy<K extends keyof any> extends Dependency<K> {
+                lazy: true;
+            }
             type Setter<T = any> = (v: T) => void;
             type Compatible<T1, T2> = T1 extends T2 ? any : never;
-            type SetterType<T> = T extends (v: infer V) => void ? V : never;
             type ExtractService<K, S> = K extends keyof S ? S[K] : K;
             type ExtractDependency<D, S> = D extends { $dependency: infer K } ? D extends { lazy: true } ? () => ExtractService<K, S> : ExtractService<K, S> : VisitDependency<D, S>;
             type VisitDependency<D, S> = D extends {} ? { [K in keyof D]: ExtractDependency<D[K], S> } : D;
+            interface Config<S> {
+                dependency<K extends keyof S>(name: K): Dependency<K>;
+                lazy<K extends keyof S>(name: K): Lazy<K>;
+                build<T>(): Builder<T, S>;
+            }
+            export declare function services<S extends object>(): Config<S>;
             export class Builder<T, S> {
                 consume<P extends any[]>(...args: P) {
                     return <C extends new (...args: ExtractDependency<P, S>) => T>(constructor: C) => {
-                        return constructor as typeof constructor & { service: () => T };
+                        return constructor;
                     };
                 }
                 inject<K extends keyof S>(dependency: K) {
                     // K = "bar"
                     // M = "setValue"
                     // S[K] = Bar
                     // T[M] = (value: string) => void
                     // P[m] = (value: V) => void
                     return <P, M extends keyof (T | P)>(target: P, memberName: M, descriptor: TypedPropertyDescriptor<Compatible<T[M], Setter<S[K]>>>) => {
                     };
                 }
                 cast<T2 extends T>(): Builder<T2, S> {
                     return this as Builder<T2, S>;
                 }
             }

src/main/ts/di/ConfigError.ts +4 -4

             export class ConfigError extends Error {
-                inner: any;
+                inner?: {};
-                path: string;
+                path?: string;
-                configName: string;
+                configName?: string;
-                constructor(message: string, inner?: any) {
+                constructor(message: string, inner?: {}) {
                     super(message);
                     this.inner = inner;
                 }
             }

src/main/ts/di/Configuration.ts +17 -19

             import {
                 ServiceRegistration,
                 TypeRegistration,
                 FactoryRegistration,
                 ServiceMap,
                 isDescriptor,
                 isDependencyRegistration,
                 DependencyRegistration,
                 ValueRegistration,
                 ActivationType,
                 isValueRegistration,
                 isTypeRegistration,
                 isFactoryRegistration
             } from "./interfaces";
             import { argumentNotEmptyString, isPrimitive, isPromise, delegate, argumentOfType, argumentNotNull, get } 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";
             const trace = TraceSource.get("@implab/core/di/Configuration");
-            async function mapAll(data: any | any[], map?: (v: any, k: keyof any) => any): Promise<any> {
+            async function mapAll(data: any | any[], map?: (v: any, k: number | string) => 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;
-            type _key = string | number;
+            export class Configuration<S> {
-            export class Configuration {
                 _hasInnerDescriptors = false;
-                _container: Container;
+                _container: Container<S>;
-                _path: Array<_key>;
+                _path: Array<string>;
                 _configName: string | undefined;
                 _require: ModuleResolver | undefined;
-                constructor(container: Container) {
+                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: object, contextRequire?: any, ct = Cancellation.none) {
                     argumentNotNull(data, "data");
                     await this._applyConfiguration(data, await makeResolver(void (0), contextRequire), ct);
                 }
                 async _applyConfiguration(data: object, resolver?: ModuleResolver, ct = Cancellation.none) {
                     trace.log("applyConfiguration");
                     this._configName = "$";
                     if (resolver)
                         this._require = resolver;
                     let services: ServiceMap;
                     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);
                         return localName ? get(localName, m) : 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: any, name: _key) {
+                async _visitRegistrations(data: any, name: string) {
                     this._enter(name);
                     if (data.constructor &&
                         data.constructor.prototype !== Object.prototype)
                         throw new Error("Configuration must be a simple object");
                     const o: ServiceMap = {};
                     const keys = Object.keys(data);
                     const services = await mapAll(data, async (v, k) => {
-                        const d = await this._visit(v, k);
+                        const d = await this._visit(v, k.toString());
                         return isDescriptor(d) ? d : new AggregateDescriptor(d);
                     }) as ServiceMap;
                     this._leave();
                     return services;
                 }
                 _enter(name: keyof any) {
                     this._path.push(name.toString());
                     trace.debug(">{0}", name);
                 }
                 _leave() {
                     const name = this._path.pop();
                     trace.debug("<{0}", name);
                 }
-                async _visit<T extends object>(data: T, name: keyof T) {
+                async _visit<T>(data: T, name: string) {
                     if (isPrimitive(data) || isDescriptor(data))
                         return data;
-                    if (isDependencyRegistration(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);
+                    return this._visitObject(data as T & object, name);
                 }
-                async _visitObject(data: object, name: _key) {
+                async _visitObject<T extends object>(data: T, 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: _key) {
+                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<T, P, S>(data: ServiceRegistration<T, P, S>) {
+                _makeServiceParams<T, P>(data: ServiceRegistration<T, P, S>) {
                     const opts: any = {
                         owner: this._container
                     };
                     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) {
                         if (typeof (data.activation) === "string") {
                             switch (data.activation.toLowerCase()) {
                                 case "singleton":
                                     opts.activation = ActivationType.Singleton;
                                     break;
                                 case "container":
                                     opts.activation = ActivationType.Container;
                                     break;
                                 case "hierarchy":
                                     opts.activation = ActivationType.Hierarchy;
                                     break;
                                 case "context":
                                     opts.activation = ActivationType.Context;
                                     break;
                                 case "call":
                                     opts.activation = ActivationType.Call;
                                     break;
                                 default:
                                     throw new Error("Unknown activation type: " +
                                         data.activation);
                             }
                         } else {
                             opts.activation = Number(data.activation);
                         }
                     }
                     if (data.cleanup)
                         opts.cleanup = data.cleanup;
                     return opts;
                 }
-                async _visitValueRegistration<T>(data: ValueRegistration<T>, name: _key) {
+                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<S, K extends keyof S>(data: DependencyRegistration<S, K>, name: keyof S) {
+                async _visitDependencyRegistration<K extends keyof S>(data: DependencyRegistration<S, K>, name: string) {
                     argumentNotEmptyString(data && data.$dependency, "data.$dependency");
                     this._enter(name);
                     const d = new ReferenceDescriptor<S, K>({
                         name: data.$dependency,
                         lazy: data.lazy,
                         optional: data.optional,
                         default: data.default,
                         services: data.services && await this._visitRegistrations(data.services, "services")
                     });
                     this._leave();
                     return d;
                 }
-                async _visitTypeRegistration<T, P, S>(data: TypeRegistration<T, P, S>, name: _key) {
+                async _visitTypeRegistration<T, P>(data: TypeRegistration<T, P, 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);
                         opts.type = this._resolveType(moduleName, typeName);
                     }
                     const d = new TypeServiceDescriptor(
                         await mapAll(opts)
                     );
                     this._leave();
                     return d;
                 }
-                async _visitFactoryRegistration<T, P, S>(data: FactoryRegistration<T, P, S>, name: _key) {
+                async _visitFactoryRegistration<T, P>(data: FactoryRegistration<T, P, 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(
                         await mapAll(opts)
                     );
                     this._leave();
                     return d;
                 }
             }

src/main/ts/di/Container.ts +41 -31

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

src/main/ts/di/ReferenceDescriptor.ts +12 -14

-            import { isNull, argumentNotEmptyString, each } from "../safe";
+            import { isNull, argumentNotEmptyString, each, keys } from "../safe";
             import { ActivationContext } from "./ActivationContext";
             import { ServiceMap, Descriptor } from "./interfaces";
             import { ActivationError } from "./ActivationError";
             export interface ReferenceDescriptorParams<S, K extends keyof S> {
                 name: K;
                 lazy?: boolean;
                 optional?: boolean;
                 default?: S[K];
                 services?: ServiceMap;
             }
+            function def<T>(v: T) {
+                if (v === undefined)
+                    throw Error();
+                return v;
+            }
             export class ReferenceDescriptor<S, K extends keyof S> implements Descriptor<S[K]> {
                 _name: K;
                 _lazy = false;
                 _optional = false;
                 _default: any;
-                _services: ServiceMap;
+                _services: ServiceMap<S>;
                 constructor(opts: ReferenceDescriptorParams<S, K>) {
                     argumentNotEmptyString(opts && opts.name, "opts.name");
                     this._name = opts.name;
                     this._lazy = !!opts.lazy;
                     this._optional = !!opts.optional;
                     this._default = opts.default;
                     this._services = opts.services || {};
                 }
-                activate(context: ActivationContext, name: string) {
+                activate(context: ActivationContext<S>) {
                     // добавляем сервисы
                     if (this._services) {
-                        for (const p of Object.keys(this._services))
+                        each(this._services, (v, k) => context.register(k, def(v)));
-                            context.register(p, this._services[p]);
                     }
                     if (this._lazy) {
                         const saved = context.clone();
-                        return (cfg: ServiceMap) => {
+                        return (cfg: Partial<ServiceMap<S>>) => {
                             // защищаем контекст на случай исключения в процессе
                             // активации
                             const ct = saved.clone();
                             try {
                                 if (cfg) {
-                                    for (const k in cfg)
+                                    each(cfg, (v, k) => ct.register(k, v || {}));
-                                        ct.register(k, cfg[k]);
                                 }
                                 return this._optional ? ct.resolve(this._name, this._default) : ct
                                     .resolve(this._name);
                             } catch (error) {
                                 throw new ActivationError(this._name.toString(), ct.getStack(), error);
                             }
                         };
                     } else {
-                        // добавляем сервисы
-                        if (this._services) {
-                            for (const p of Object.keys(this._services))
-                                context.register(p, this._services[p]);
                         const v = this._optional ?
                             context.resolve(this._name, this._default) :
                             context.resolve(this._name);
                         return v;
                     }
                 }
                 toString() {
                     const opts = [];
                     if (this._optional)
                         opts.push("optional");
                     if (this._lazy)
                         opts.push("lazy");
                     const parts = [
                         "@ref "
                     ];
                     if (opts.length) {
                         parts.push("{");
                         parts.push(opts.join());
                         parts.push("} ");
                     }
                     parts.push(this._name.toString());
                     if (!isNull(this._default)) {
                         parts.push(" = ");
                         parts.push(this._default);
                     }
                     return parts.join("");
                 }
             }

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

             import { isPrimitive } from "../safe";
             import { ActivationContext } from "./ActivationContext";
             import { Constructor, Factory } from "../interfaces";
             export interface Descriptor<T = any> {
-                activate(context: ActivationContext, name?: string): T;
+                activate<S>(context: ActivationContext<S>): T;
             }
             export function isDescriptor(x: any): x is Descriptor {
                 return (!isPrimitive(x)) &&
                     (x.activate instanceof Function);
             }
             export type ServiceMap<S = any> = {
                 [k in keyof S]: Descriptor<S[k]>;
             }
             export enum ActivationType {
                 Singleton = 1,
                 Container,
                 Hierarchy,
                 Context,
                 Call
             }
             export interface RegistrationWithServices<S> {
                 services?: ServiceMap<S>;
             }
             export interface ServiceRegistration<T, P, S> extends RegistrationWithServices<S> {
                 activation?: "singleton" | "container" | "hierarchy" | "context" | "call";
                 params?: P;
                 inject?: object | object[];
                 cleanup?: ((instance: T) => void) | string;
             }
             export interface TypeRegistration<T, P, S> extends ServiceRegistration<T, P, S> {
                 $type: string | Constructor<T>;
             }
             export interface FactoryRegistration<T, P, S> extends ServiceRegistration<T, P, S> {
                 $factory: string | Factory<T>;
             }
             export interface ValueRegistration<T> {
                 $value: T;
                 parse?: boolean;
             }
             export interface DependencyRegistration<S, K extends keyof S> extends RegistrationWithServices<S> {
                 $dependency: K;
                 lazy?: boolean;
                 optional?: boolean;
                 default?: S[K];
             }
             export function isTypeRegistration(x: any): x is TypeRegistration<any, any, any> {
                 return (!isPrimitive(x)) && ("$type" in x);
             }
             export function isFactoryRegistration(x: any): x is FactoryRegistration<any, 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(x: any): x is DependencyRegistration<any, string | number | symbol> {
+            export function isDependencyRegistration<S>(x: any): x is DependencyRegistration<S, keyof S> {
                 return (!isPrimitive(x)) && ("$dependency" in x);
             }

src/main/ts/safe.ts +24 -15

             import { ICancellable, Constructor } from "./interfaces";
             import { Cancellation } from "./Cancellation";
             let _nextOid = 0;
             const _oid = typeof Symbol === "function" ?
                 Symbol("__implab__oid__") :
                 "__implab__oid__";
-            export function oid(instance: object): string {
+            export function oid(instance: any): string | undefined {
                 if (isNull(instance))
-                    return null;
+                    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 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) {
                 return (val === null || val === undefined);
             }
             export function isPrimitive(val: any): val is string | number | boolean | undefined | null {
                 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(val: any): val is PromiseLike<any> {
                 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 string | null | undefined {
+            export function isNullOrEmptyString(val: any): val is (string | null | undefined) {
-                if (val === null || val === undefined ||
+                return (val === null || val === undefined ||
                     ((typeof (val) === "string" || val instanceof String) && val.length === 0))
-                    return true;
             }
             export function isNotEmptyArray(arg: any): arg is Array<any> {
                 return (arg instanceof Array && arg.length > 0);
             }
-            function _isStrictMode() {
+            function _isStrictMode(this: any) {
                 return !this;
             }
-            function _getNonStrictGlobal() {
+            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>
              *          если достигнут конец массива.
              */
-            export function each(obj, cb, thisArg?) {
+            export function each<T>(obj: T, cb: (v: T[keyof T], k: keyof T) => 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) {
                     for (let i = 0; i < obj.length; i++) {
                         const x = cb.call(thisArg, obj[i], i);
                         if (x !== undefined)
                             return x;
                     }
                 } else {
-                    const keys = Object.keys(obj);
+                    const _keys = Object.keys(obj);
-                    for (const k of keys) {
+                    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?: string[] | object): T & S {
                 argumentNotNull(dest, "to");
                 const _res = dest as T & S;
                 if (isPrimitive(source))
                     return _res;
                 if (template instanceof Array) {
                     for (const p of template) {
                         if (p in source)
                             _res[p] = source[p];
                     }
                 } else if (template) {
-                    const keys = Object.keys(source);
+                    const _keys = Object.keys(source);
-                    for (const p of keys) {
+                    for (const p of _keys) {
                         if (p in template)
                             _res[template[p]] = source[p];
                     }
                 } else {
                     const keys = Object.keys(source);
                     for (const p of keys)
                         _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(_fn: (...args: any[]) => any, thisArg): (...args: any[]) => PromiseLike<any> {
+            export function async(_fn: (...args: any[]) => 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, e?): 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);
                     }
                 };
             }
             type _AnyFn = (...args) => any;
             export function delegate<T, K extends keyof T>(target: T, _method: (K | _AnyFn)) {
                 let method;
                 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);
                 });
             }
             /**
              * 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 = () => {
+                    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 = () => {
+                    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, 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, 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 destroy(d: any) {
                 if (d && "destroy" in d)
                     d.destroy();
             }
             /**
              * Used to mark that the async operation isn't awaited intentionally.
              * @param p The promise which represents the async operation.
              */
             export function nowait(p: Promise<any>) {
             }
             /** represents already destroyed object.
              */
             export const destroyed = {
                 /** Calling to this method doesn't affect anything, noop.
                  */
                 destroy() {
                 }
             };

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

-            import { config } from "./config";
+            import { services } from "../di/Annotations";
+            import { Bar } from "./Bar";
-            const service = config.build("barBox");
+            // declare required dependencies
+            const config = services<{
+                bar: Bar;
+            }>();
+            // export service descriptor
+            export const service = config.build<Box<Bar>>();
             @service.consume(config.dependency("bar"))
             export class Box<T> {
                 private _value: T | undefined;
                 constructor(value: T) {
                     this._value = value;
                 }
                 @service.inject("bar")
                 setValue(value: T) {
                     this._value = value;
                 }
                 setObj(value: object) {
                 }
                 getValue() {
                     if (this._value === undefined)
                         throw new Error("Trying to get a value from the empty box");
                     return this._value;
                 }
-            }
  No newline at end of file

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