implab/implabjs-core Commit - r129:c13384c6c1ac

working on lifetime management

cin -

r129:c13384c6c1ac ioc ts support

parent child

Context file:

r129:c13384c6c1ac

Collapse all files

src/main/ts/di/LifetimeManager.ts created 644 +70 0

@@ -0,0 +1,70
	1	import { IDestroyable, MapOf } from "../interfaces";
	2	import { argumentNotNull, isDestroyable } from "../safe";
	3	import { ILifetimeManager } from "./interfaces";
	4
	5	function safeCall(item: () => void) {
	6	try {
	7	item();
	8	} catch {
	9	// silence
	10	}
	11	}
	12
	13	export class LifetimeManager implements IDestroyable, ILifetimeManager {
	14	private _cleanup: (() => void)[] = [];
	15	private _cache: MapOf<any> = {};
	16	private _destroyed = false;
	17
	18	has(id: string) {
	19	return id in this._cache;
	20	}
	21
	22	get(id: string) {
	23	const t = this._cache[id];
	24	if (t === undefined)
	25	throw new Error(`The item with with the key ${id} isn't found`);
	26	return t;
	27	}
	28
	29	register(id: string, item: any, cleanup?: (item: any) => void) {
	30	argumentNotNull(id, "id");
	31	argumentNotNull(item, "item");
	32	if (this.has(id))
	33	throw new Error(`The item with with the key ${id} already registered with this lifetime manager`);
	34	this._cache[id] = item;
	35
	36	if (this._destroyed)
	37	throw new Error("Lifetime manager is destroyed");
	38	if (cleanup) {
	39	this._cleanup.push(() => cleanup(item));
	40	} else if (isDestroyable(item)) {
	41	this._cleanup.push(() => item.destroy());
	42	}
	43	}
	44
	45	destroy() {
	46	if (!this._destroyed) {
	47	this._destroyed = true;
	48	this._cleanup.forEach(safeCall);
	49	this._cleanup.length = 0;
	50	}
	51	}
	52
	53	static readonly empty: ILifetimeManager = {
	54	has() {
	55	return false;
	56	},
	57
	58	get() {
	59	throw new Error("The specified item isn't registered with this lifetime manager");
	60	},
	61
	62	register() {
	63	// does nothing
	64	},
	65
	66	destroy() {
	67	throw new Error("Trying to destroy empty lifetime manager, this is a bug.");
	68	}
	69	};
	70	}

src/main/ts/di/AggregateDescriptor.ts +4 0

             import { Descriptor } from "./interfaces";
             import { ActivationContext } from "./ActivationContext";
             import { isPrimitive } from "../safe";
             import { isDescriptor } from "./traits";
             export class AggregateDescriptor<S extends object, T> implements Descriptor<S, T> {
                 _value: any;
                 constructor(value: any) {
                     this._value = value;
                 }
                 activate(context: ActivationContext<S>): T {
                     return this._parse(this._value, context, "$value");
                 }
                 _parse(value: any, context: ActivationContext<S>, path: string): any {
                     if (isPrimitive(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}]`)) as any;
                     const t: any = {};
                     for (const p in value)
                         t[p] = this._parse(value[p], context, `${path}.${p}`);
                     return t;
                 }
                 toString() {
                     return "@walk";
                 }
+                clone() {
+                    return this;
                 }
+            }

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

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

             import { ServiceDescriptor, ServiceDescriptorParams } from "./ServiceDescriptor";
             import { argumentNotNull, oid } from "../safe";
             export interface FactoryServiceDescriptorParams<S extends object, T, P extends any[]> extends ServiceDescriptorParams<S, T, P> {
                 factory: (...args: P) => T;
             }
             export class FactoryServiceDescriptor<S extends object, T, P extends any[]> extends ServiceDescriptor<S, T, P> {
                 constructor(opts: FactoryServiceDescriptorParams<S, T, P>) {
                     super(opts);
                     argumentNotNull(opts && opts.factory, "opts.factory");
                     // bind to null
                     this._factory = (...args) => opts.factory.apply(null, args as any);
-                    if (opts.activation === "singleton") {
-                        this._cacheId = oid(opts.factory);
                 }
             }

src/main/ts/di/ServiceDescriptor.ts +29 -113

             import { ActivationContext } from "./ActivationContext";
-            import { Descriptor, ServiceMap, PartialServiceMap, ActivationType } from "./interfaces";
+            import { Descriptor, ServiceMap, PartialServiceMap, ActivationType, ILifetimeManager } from "./interfaces";
-            import { Container } from "./Container";
             import { argumentNotNull, isPrimitive, keys, isNull } from "../safe";
             import { TraceSource } from "../log/TraceSource";
             import { isDescriptor } from "./traits";
+            import { LifetimeManager } from "./LifetimeManager";
+            import { MatchingMemberKeys } from "../interfaces";
             let cacheId = 0;
             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 makeClenupCallback<T>(target: T, method: Cleaner<T>): () => void;
+            function makeClenupCallback<T>(method: Cleaner<T>) {
-            function makeClenupCallback(target: any, method: any) {
+                if (typeof (method) === "function") {
-                if (typeof (method) === "string") {
+                    return (target: T) => {
-                    return () => {
+                        method(target);
-                        target[method]();
                     };
                 } else {
-                    return () => {
+                    return (target: T) => {
-                        method(target);
+                        (target[method] as any)();
                     };
                 }
             }
             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) | keyof Extract<T, { [M in keyof T]: () => void }>;
+            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[]> {
-                activation?: ActivationType;
+                lifetime: ILifetimeManager;
-                owner: Container<S>;
                 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> {
-                _instance: T | undefined;
-                _hasInstance = false;
-                _activationType: ActivationType = "call";
                 _services: ServiceMap<S>;
                 _params: P | undefined;
                 _inject: InjectionSpec<T>[];
-                _cleanup: Cleaner<T> | undefined;
+                _cleanup: ((item: T) => void) | undefined;
-                _cacheId: any;
+                _cacheId = String(++cacheId);
-                _owner: Container<S>;
+                _lifetime = LifetimeManager.empty;
                 constructor(opts: ServiceDescriptorParams<S, T, P>) {
                     argumentNotNull(opts, "opts");
-                    argumentNotNull(opts.owner, "owner");
-                    this._owner = opts.owner;
+                    if (opts.lifetime)
+                        this._lifetime = opts.lifetime;
-                    if (!isNull(opts.activation))
-                        this._activationType = opts.activation;
                     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 = opts.cleanup;
+                        this._cleanup = makeClenupCallback(opts.cleanup);
                     }
                 }
                 activate(context: ActivationContext<S>) {
-                    // if we have a local service records, register them first
+                    const lifetime = this._lifetime.initialize(this._cacheId, context);
-                    let instance: T;
-                    // ensure we have a cache id
-                    if (!this._cacheId)
-                        this._cacheId = ++cacheId;
-                    switch (this._activationType) {
-                        case "singleton": // SINGLETON
-                            // if the value is cached return it
-                            if (this._hasInstance)
-                                return this._instance;
-                            // singletons are bound to the root container
-                            const container = context.container.getRootContainer();
-                            if (container.has(this._cacheId)) {
-                                instance = container.get(this._cacheId);
-                            } else {
-                                instance = this._create(context);
-                                container.store(this._cacheId, instance);
-                                if (this._cleanup)
-                                    container.onDispose(
-                                        makeClenupCallback(instance, this._cleanup));
-                            this._hasInstance = true;
-                            return (this._instance = instance);
-                        case "container": // CONTAINER
-                            // return a cached value
-                            if (this._hasInstance)
-                                return this._instance;
-                            // create an instance
-                            instance = this._create(context);
-                            // the instance is bound to the container
+                    if (lifetime.has()) {
-                            if (this._cleanup)
+                        return lifetime.get();
-                                this._owner.onDispose(
+                    } else {
-                                    makeClenupCallback(instance, this._cleanup));
+                        const instance = this._create(context);
+                        lifetime.store(this._cacheId, this._cleanup);
-                            // cache and return the instance
+                        return instance;
-                            this._hasInstance = true;
-                            return (this._instance = instance);
-                        case "context": // CONTEXT
-                            // return a cached value if one exists
-                            if (context.has(this._cacheId))
-                                return context.get(this._cacheId);
-                            // context context activated instances are controlled by callers
-                            return context.store(this._cacheId, this._create(context));
-                        case "call": // CALL
-                            // per-call created instances are controlled by callers
-                            return this._create(context);
-                        case "hierarchy": // HIERARCHY
-                            // hierarchy activated instances are behave much like container activated
-                            // except they are created and bound to the child container
-                            // return a cached value
-                            if (context.container.has(this._cacheId))
-                                return context.container.get(this._cacheId);
-                            instance = this._create(context);
-                            if (this._cleanup)
-                                context.container.onDispose(makeClenupCallback(
-                                    instance,
-                                    this._cleanup));
-                            return context.container.store(this._cacheId, instance);
-                        default:
-                            throw new Error("Invalid activation type: " + this._activationType);
                     }
                 }
-                isInstanceCreated() {
-                    return this._hasInstance;
-                getInstance() {
-                    return this._instance;
                 _factory(...params: any[]): T {
                     throw Error("Not implemented");
                 }
                 _create(context: ActivationContext<S>) {
                     trace.debug(`constructing ${context._name}`);
-                    if (this._activationType !== "call" &&
-                        context.visit(this._cacheId) > 0)
-                        throw new Error("Recursion detected");
                     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/interfaces.ts 0 -2

             import { primitive } from "../../safe";
             import { ActivationType } from "../interfaces";
             import { AnnotaionBuilder } from "../Annotations";
             import { LazyDependencyRegistration, DependencyRegistration } from "../Configuration";
             import { Container } from "../Container";
             export interface DependencyOptions<T> {
                 optional?: boolean;
                 default?: T;
             }
             export interface LazyDependencyOptions<T> extends DependencyOptions<T> {
                 lazy: true;
             }
             export type ExtractService<K, S> = K extends keyof S ? S[K] : K;
             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]: AnnotaionBuilder<T, S>;
             };
             export interface ServiceRecordBuilder<T, S extends object> {
                 type<P extends any[], C extends new (...args: ExtractDependency<P, S>) => T>(
                     target: C, ...params: P): ConstructorBuilder<C, S>;
                 factory<P extends any[], F extends (...args: ExtractDependency<P, S>) => T>(
                     target: F, ...params: P): FactoryBuilder<F, S>;
                 wired<M extends keyof any>(module: ServiceModule<T, S, M>, m: M): RegistrationBuilder<T, S>;
                 wired(module: ServiceModule<T, S>): RegistrationBuilder<T, S>;
             }
             export interface RegistrationVisitor<S extends object> {
                 visitDependency(): void;
                 visitObject(): void;
                 visitTypeRegistration(): void;
                 visitFactoryRegistration(): void;
-                visitBuilder<T>(builder: (t: ServiceRecordBuilder<T, S>) => void): void;
             }
             export interface RegistrationBuilder<T, S extends object> {
                 override<K extends keyof S>(name: K, builder: S[K], raw: true): this;
                 override<K extends keyof S>(name: K, builder: (t: ServiceRecordBuilder<S[K], S>) => void): this;
                 override<K extends keyof S, V>(name: S[K] extends ExtractDependency<V, S> ? K : never, value: V): this;
                 activate(activation: ActivationType): this;
                 inject<M extends keyof T, P extends any[]>(member: T[M] extends (...params: ExtractDependency<P, S>) => any ? M : never, ...params: P): this;
                 visit(visitor: RegistrationVisitor<S>): void;
             }
             export interface ConstructorBuilder<C extends new (...args: any[]) => any, S extends object> extends RegistrationBuilder<InstanceType<C>, S> {
                 $type: C;
             }
             export interface FactoryBuilder<F extends (...args: any[]) => any, S extends object> extends RegistrationBuilder<ReturnType<F>, S> {
                 $factory: F;
             }
             export interface ConfigBuilder<S extends object, Y extends keyof S = keyof S> {
                 register<K extends Y>(name: K, builder: (t: ServiceRecordBuilder<S[K], S>) => void | Promise<void>): ConfigBuilder<S, Exclude<Y, K>>;
                 register<K extends Y, V>(name: S[K] extends ExtractDependency<V, S> ? K : never, value: V): ConfigBuilder<S, Exclude<Y, K>>;
                 register<K extends Y>(name: K, value: S[K], raw: true): ConfigBuilder<S, Exclude<Y, K>>;
                 apply(container: Container<S>): Promise<void>;
             }
             interface ServicesDeclaration<S extends object> {
                 build<T>(this: void): ServiceRecordBuilder<T, S>;
                 annotate<T>(this: void): AnnotaionBuilder<T, S>;
                 dependency<K extends keyof S>(this: void, name: K, opts: LazyDependencyOptions<S[K]>): LazyDependencyRegistration<S, K>;
                 dependency<K extends keyof S>(this: void, name: K, opts?: DependencyOptions<S[K]>): DependencyRegistration<S, K>;
                 configure(): ConfigBuilder<S>;
             }
             export declare function declare<S extends object>(): ServicesDeclaration<S>;

src/main/ts/di/interfaces.ts +13 0

             import { ActivationContext } from "./ActivationContext";
+            import { IDestroyable } from "../interfaces";
             export interface Descriptor<S extends object = any, T = any> {
                 activate(context: ActivationContext<S>): T;
+                clone(): this;
             }
             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 ContainerResolve<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, ContainerResolve<S, K>>;
             };
             export type PartialServiceMap<S extends object> = {
                 [k in keyof S]?: Descriptor<S, S[k]>;
             };
             export interface Resolver<S extends object> {
                 resolve<K extends ContainerKeys<S>>(name: K, def?: ContainerResolve<S, K>): ContainerResolve<S, K>;
             }
             export interface ContainerProvided<S extends object> {
                 container: Resolver<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 extends IDestroyable {
+                initialize(id: string, context: ActivationContext<any>): ILifetime;
+            }
+            export interface ILifetime {
+                has(): boolean;
+                get(): any;
+                store(item: any, cleanup?: (item: any) => void): void;
+            }
  No newline at end of file

src/main/ts/interfaces.ts +8 0

             export interface Constructor<T = {}> {
                 new(...args: any[]): T;
                 prototype: T;
             }
             export type PromiseOrValue<T> = T | PromiseLike<T>;
             export type Factory<T = {}> = (...args: any[]) => T;
             export type Predicate<T = any> = (x: T) => boolean;
+            export type MatchingMemberKeys<T, From> = { [K in keyof From]: From[K] extends T ? K : never}[keyof From];
+            export type NotMatchingMemberKeys<T, From> = { [K in keyof From]: From[K] extends T ? never : K}[keyof From];
+            export type ExtractMembers<T, From> = Pick<From, MatchingMemberKeys<T, From>>;
+            export type ExcludeMembers<T, From> = Pick<From, NotMatchingMemberKeys<T, From>>;
             export interface MapOf<T> {
                 [key: string]: T;
             }
             export interface IDestroyable {
                 destroy(): void;
             }
             export interface IRemovable {
                 remove(): void;
             }
             export interface ICancellation {
                 throwIfRequested(): void;
                 isRequested(): boolean;
                 isSupported(): boolean;
                 register(cb: (e: any) => void): IDestroyable;
             }
             /**
              * Интерфейс поддерживающий асинхронную активацию
              */
             export interface IActivatable {
                 /**
                  * @returns Boolean indicates the current state
                  */
                 isActive(): boolean;
                 /**
                  * Starts the component activation
                  * @param ct cancellation token for this operation
                  */
                 activate(ct?: ICancellation): Promise<void>;
                 /**
                  * Starts the component deactivation
                  * @param ct cancellation token for this operation
                  */
                 deactivate(ct?: ICancellation): Promise<void>;
                 /**
                  * Sets the activation controller for this component
                  * @param controller The activation controller
                  *
                  * Activation controller checks whether this component
                  * can be activated and manages the active state of the
                  * component
                  */
                 setActivationController(controller: IActivationController): void;
                 /** Indicates whether this component has an activation controller */
                 hasActivationController(): boolean;
                 /**
                  * Gets the current activation controller for this component
                  */
                 getActivationController(): IActivationController;
             }
             export interface IActivationController {
                 activating(component: IActivatable, ct?: ICancellation): Promise<void>;
                 activated(component: IActivatable, ct?: ICancellation): Promise<void>;
                 deactivating(component: IActivatable, ct?: ICancellation): Promise<void>;
                 deactivated(component: IActivatable, ct?: ICancellation): Promise<void>;
                 deactivate(ct?: ICancellation): Promise<void>;
                 activate(component: IActivatable, ct?: ICancellation): Promise<void>;
                 hasActive(): boolean;
                 getActive(): IActivatable;
             }
             export interface IAsyncComponent {
                 getCompletion(): Promise<void>;
             }
             export interface ICancellable {
                 cancel(reason?: any): void;
             }
             export interface IObservable<T> {
                 on(next: (x: T) => void, error?: (e: any) => void, complete?: () => void): IDestroyable;
                 next(ct?: ICancellation): Promise<T>;
             }
             export interface IObserver<T> {
                 next(event: T): void;
                 error(e: any): void;
                 complete(): void;
             }
             export interface TextWriter {
                 write(obj: any): void;
                 write(format: string, ...args: any[]): void;
                 writeLine(obj?: any): void;
                 writeLine(format: string, ...args: any[]): void;
                 writeValue(value: any, spec?: string): void;
             }

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

-            import { ICancellable, Constructor } from "./interfaces";
+            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>
              *          если достигнут конец массива.
              */
             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) {
                     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);
                     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")
+                    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() {
                 }
             };

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