implab/implabjs-core Commit - r76:a193ba786ffc

Added safe.delay...

cin -

r76:a193ba786ffc default

parent child

Context file:

r76:a193ba786ffc

Collapse all files

src/test/ts/SafeTests.ts created 644 +86 0

@@ -0,0 +1,86
	1	import tape = require("tape");
	2	import { delay } from "./TestTraits";
	3	import { Cancellation } from "@implab/core/Cancellation";
	4	import { first, isPromise } from "@implab/core/safe";
	5
	6	tape("await delay test", async t => {
	7	// schedule delay
	8	let resolved = false;
	9	let res = delay(0).then(() => resolved = true);
	10
	11	t.false(resolved, "the delay should be async");
	12
	13	await res;
	14	t.pass("await delay");
	15
	16	// create cancellation token
	17	let cancel: (e?: any) => void;
	18	const ct = new Cancellation(c => cancel = c);
	19
	20	// schedule delay
	21	resolved = false;
	22	res = delay(0, ct).then(() => resolved = true);
	23
	24	t.false(resolved, "created delay with ct");
	25
	26	// cancel
	27	cancel();
	28
	29	try {
	30	await res;
	31	t.fail("the delay should fail when it is cancelled");
	32	} catch {
	33	t.pass("the delay is cancelled");
	34	}
	35
	36	let died = false;
	37
	38	// try schedule delay after the cancellation is requested
	39	res = delay(0, ct).then(x => true, () => died = true);
	40
	41	t.false(died, "The delay should be scheduled even if the cancellation is requested");
	42
	43	await res;
	44	t.true(died, "the delay should fail when cancelled");
	45
	46	t.end();
	47	});
	48
	49	tape("sequemce test", async t => {
	50	const sequence = ["a", "b", "c"];
	51	const empty = [];
	52
	53	// synchronous tests
	54	t.equals(first(sequence), "a", "Should return the first element");
	55
	56	let v: string;
	57	let e: Error;
	58	first(sequence, x => v = x);
	59	t.equal(v, "a", "The callback should be called for the first element");
	60
	61	t.throws(() => {
	62	first(empty);
	63	}, "Should throw when the sequence is empty");
	64
	65	t.throws(() => {
	66	first(empty, x => v = x);
	67	}, "Should throw when the sequence is empty");
	68
	69	first(empty, null, x => e = x);
	70	t.true(e, "The errorback should be called for the empty sequence");
	71
	72	// async tests
	73	const asyncSequence = Promise.resolve(sequence);
	74	const asyncEmptySequence = Promise.resolve(empty);
	75
	76	const promise = first(asyncSequence);
	77	t.true(isPromise(promise), "Should return promise");
	78
	79	v = await promise;
	80	t.equal(v, "a", "Should return the first element");
	81
	82	v = await new Promise(resolve => first(asyncSequence, resolve));
	83	t.equal(v, "a", "The callback should be called for the first element");
	84
	85	t.end();
	86	});

build.md +1 -1

             # BUILD
             Для сборки необходимо иметь
             * nodejs >= 8
             * npm
             * eslint
             * mercurial (для автоматического определения версии)
             В пцессе сборки будут установлены зависимости из package.json
             ## Properties
             Свойства, испольуземые для управления сборкой, через них можно указать имя,
             версию пакета, тип модулей, версию стандарта js для которого осуществляется
             сборка. Значения по-умолчанию заданы в `gradle.properties`
             ### npmName
             `default: core`
             Имя пакета в терминологии npm.
             ### npmScope
             `default: @implab`
             Пространство в терминологии npm для пакета.
             ### target
             `default: es5`
             Версии стандарта js в среде выполнения, возможные значения:
             * es3 - требует полифилы для es5, promise
             * es5 - требует полифил для promise
             * es6
             * es2015
             * es2016
             * es2017
             ### jsmodule
             `default: amd`
             * amd - requirejs модули, хорошо подходит для использования в браузерах.
             * commonjs - формат модулей для nodejs
             ## Tasks
             ### build
             ### test
             ### pack
             ### publish
             ## Examples
             ```shell
             ./gradlew test pack -PnpmName=core-amd
             ```
             ```shell
             ./gradlew test pack -Pjsmodule=commonjs -Ptarget=es2017
-            ```
  No newline at end of file
+            ```

src/main/ts/Cancellation.ts +3 -8

             import { ICancellation, IDestroyable } from "./interfaces";
-            import { argumentNotNull } from "./safe";
+            import { argumentNotNull, destroyed } from "./safe";
-            const destroyed = {
-                destroy() {
-            };
             export class Cancellation implements ICancellation {
                 private _reason: any;
-                private _cbs: Array<(e) => void>;
+                private _cbs: Array<(e: any) => void>;
-                constructor(action: (cancel: (e) => void) => void) {
+                constructor(action: (cancel: (e?: any) => void) => void) {
                     argumentNotNull(action, "action");
                     action(this._cancel.bind(this));
                 }
                 isSupported(): boolean {
                     return true;
                 }
                 throwIfRequested(): void {
                     if (this._reason)
                         throw this._reason;
                 }
                 isRequested(): boolean {
                     return !!this._reason;
                 }
                 register(cb: (e: any) => void): IDestroyable {
                     argumentNotNull(cb, "cb");
                     if (this._reason) {
                         cb(this._reason);
                         return destroyed;
                     } else {
                         if (!this._cbs)
                             this._cbs = [cb];
                         else
                             this._cbs.push(cb);
                         const me = this;
                         return {
                             destroy() {
                                 me._unregister(cb);
                             }
                         };
                     }
                 }
                 private _unregister(cb) {
                     if (this._cbs) {
                         const i = this._cbs.indexOf(cb);
                         if (i >= 0)
                             this._cbs.splice(i, 1);
                     }
                 }
                 private _cancel(reason) {
                     if (this._reason)
                         return;
                     this._reason = (reason = reason || new Error("Operation cancelled"));
                     if (this._cbs) {
                         this._cbs.forEach(cb => cb(reason));
                         this._cbs = null;
                     }
                 }
                 static readonly none: ICancellation = {
                     isSupported(): boolean {
                         return false;
                     },
                     throwIfRequested(): void {
                     },
                     isRequested(): boolean {
                         return false;
                     },
                     register(_cb: (e: any) => void): IDestroyable {
                         return destroyed;
                     }
                 };
             }

src/main/ts/Observable.ts +35 -11

-            import { IObservable, IDestroyable, ICancellation } from "./interfaces";
+            import { IObservable, IDestroyable, ICancellation, IObserver } from "./interfaces";
             import { Cancellation } from "./Cancellation";
-            import { argumentNotNull } from "./safe";
+            import { argumentNotNull, destroyed } from "./safe";
             type Handler<T> = (x: T) => void;
             type Initializer<T> = (notify: Handler<T>, error?: (e: any) => void, complete?: () => void) => void;
-            // TODO: think about to move this interfaces.ts and make it public
+            const noop = () => { };
-            interface IObserver<T> {
-                next(event: T): void;
-                error(e: any): void;
+            function isObserver(val: any): val is IObserver<any> {
+                return val && (typeof val.next === "function");
-                complete(): void;
             }
-            const noop = () => { };
             export class Observable<T> implements IObservable<T> {
                 private _once = new Array<IObserver<T>>();
                 private _observers = new Array<IObserver<T>>();
                 private _complete: boolean;
                 private _error: any;
                 constructor(func?: Initializer<T>) {
                     if (func)
                         func(
                             this._notifyNext.bind(this),
                             this._notifyError.bind(this),
                             this._notifyCompleted.bind(this)
                         );
                 }
                 /**
                  * Registers handlers for the current observable object.
                  *
                  * @param next the handler for events
                  * @param error the handler for a error
                  * @param complete the handler for a completion
                  * @returns {IDestroyable} the handler for the current subscription, this
                  *  handler can be used to unsubscribe from events.
                  *
                  */
                 on(next: Handler<T>, error?: Handler<any>, complete?: () => void): IDestroyable {
                     argumentNotNull(next, "next");
                     const me = this;
                     const observer: IObserver<T> & IDestroyable = {
                         next,
                         error: error ? error.bind(null) : noop,
                         complete: complete ? complete.bind(null) : noop,
                         destroy() {
                             me._removeObserver(this);
                         }
                     };
                     this._addObserver(observer);
                     return observer;
                 }
+                subscribe(next: IObserver<T> | Handler<T>, error?: Handler<any>, complete?: () => void): IDestroyable {
+                    if (isObserver(next)) {
+                        const me = this;
+                        const subscription = {
+                            destroy() {
+                                me._removeObserver(next);
+                            }
+                        };
+                        this._addObserver(next);
+                        return subscription;
+                    } else if (next) {
+                        const observer = {
+                            next,
+                            error,
+                            complete
+                        };
+                        const me = this;
+                        const subscription = {
+                            destroy() {
+                                me._removeObserver(observer);
+                            }
+                        };
+                        this._addObserver(observer);
+                        return subscription;
+                    } else {
+                        return destroyed;
+                    }
+                }
                 private _addObserver(observer: IObserver<T>) {
                     if (this._complete) {
                         try {
                             if (this._error)
                                 observer.error(this._error);
                             else
                                 observer.complete();
                         } catch (e) {
                             this.onObserverException(e);
                         }
                     } else {
                         this._observers.push(observer);
                     }
                 }
                 /**
                  * Waits for the next event. This method can't be used to read messages
                  * as a sequence since it can skip some messages between calls.
                  *
                  * @param ct a cancellation token
                  */
-                next(ct: ICancellation = Cancellation.none): Promise<T> {
+                next(ct: ICancellation = Cancellation.none) {
                     return new Promise<T>((resolve, reject) => {
                         const observer: IObserver<T> = {
                             next: resolve,
                             error: reject,
                             complete: () => reject("No more events are available")
                         };
                         if (this._addOnce(observer) && ct.isSupported()) {
                             ct.register(e => {
                                 this._removeOnce(observer);
                                 reject(e);
                             });
                         }
                     });
                 }
                 private _addOnce(observer: IObserver<T>) {
                     if (this._complete) {
                         try {
                             if (this._error)
                                 observer.error(this._error);
                             else
                                 observer.complete();
                         } catch (e) {
                             this.onObserverException(e);
                         }
                         return false;
                     }
                     this._once.push(observer);
                     return true;
                 }
                 protected onObserverException(e: any) {
                 }
                 private _removeOnce(d: IObserver<T>) {
                     const i = this._once.indexOf(d);
                     if (i >= 0)
                         this._once.splice(i, 1);
                 }
                 private _removeObserver(d: IObserver<T>) {
                     const i = this._observers.indexOf(d);
                     if (i >= 0)
                         this._observers.splice(i, 1);
                 }
                 private _notify(guard: (observer: IObserver<T>) => void) {
                     this._once.forEach(guard);
                     this._once = [];
                     this._observers.forEach(guard);
                 }
                 protected _notifyNext(evt: T) {
                     const guard = (observer: IObserver<T>) => {
                         try {
                             observer.next(evt);
                         } catch (e) {
                             this.onObserverException(e);
                         }
                     };
                     this._notify(guard);
                 }
                 protected _notifyError(e: any) {
                     const guard = (observer: IObserver<T>) => {
                         try {
                             observer.error(e);
                         } catch (e) {
                             this.onObserverException(e);
                         }
                     };
                     this._notify(guard);
                     this._observers = [];
                     this._complete = true;
                 }
                 protected _notifyCompleted() {
                     const guard = (observer: IObserver<T>) => {
                         try {
                             observer.complete();
                         } catch (e) {
                             this.onObserverException(e);
                         }
                     };
                     this._notify(guard);
                     this._observers = [];
                     this._complete = true;
                 }
             }

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

             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: object | any[], map?: (v, k) => 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 {
                 _hasInnerDescriptors = false;
                 _container: Container;
                 _path: Array<_key>;
                 _configName: string;
                 _require: ModuleResolver;
                 constructor(container: Container) {
-                    argumentNotNull(container, container);
+                    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(null, 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) {
                     const e = new ConfigError("Failed to load configuration", inner);
                     e.configName = this._configName;
                     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);
                     return this._require(moduleName);
                 }
                 async _visitRegistrations(data, name: _key) {
                     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);
                         return isDescriptor(d) ? d : new AggregateDescriptor(d);
                     }) as ServiceMap;
                     this._leave();
                     return services;
                 }
                 _enter(name: _key) {
                     this._path.push(name);
                     trace.debug(">{0}", name);
                 }
                 _leave() {
                     const name = this._path.pop();
                     trace.debug("<{0}", name);
                 }
                 async _visit(data, name: string) {
                     if (isPrimitive(data) || isDescriptor(data))
                         return data;
                     if (isDependencyRegistration(data)) {
                         return this._visitDependencyRegistration(data, name);
                     } else if (isValueRegistration(data)) {
                         return this._visitValueRegistration(data, name);
                     } else if (isTypeRegistration(data)) {
                         return this._visitTypeRegistration(data, name);
                     } else if (isFactoryRegistration(data)) {
                         return this._visitFactoryRegistration(data, name);
                     } else if (data instanceof Array) {
                         return this._visitArray(data, name);
                     }
                     return this._visitObject(data, name);
                 }
                 async _visitObject(data: object, name: _key) {
                     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) {
                     if (data.constructor &&
                         data.constructor.prototype !== Array.prototype)
                         return new ValueDescriptor(data);
                     this._enter(name);
                     const v = await mapAll(data, delegate(this, "_visit"));
                     this._leave();
                     return v;
                 }
                 _makeServiceParams(data: ServiceRegistration) {
                     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(data: ValueRegistration, name: _key) {
                     this._enter(name);
                     const d = data.parse ? new AggregateDescriptor(data.$value) : new ValueDescriptor(data.$value);
                     this._leave();
                     return d;
                 }
                 async _visitDependencyRegistration(data: DependencyRegistration, name: _key) {
                     argumentNotEmptyString(data && data.$dependency, "data.$dependency");
                     this._enter(name);
                     const d = new ReferenceDescriptor({
                         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(data: TypeRegistration, name: _key) {
                     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(data: FactoryRegistration, name: _key) {
                     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/interfaces.ts +8 0

             export interface Constructor<T = {}> {
                 new (...args: any[]): T;
                 prototype: T;
             }
             export type Factory<T = {}> = (...args: any[]) => T;
             export type Predicate<T = any> = (x: T) => boolean;
             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);
                 /**
                  * 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>;
                 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;
+            }

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

             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 {
                 if (isNull(instance))
                     return null;
                 if (_oid in instance)
                     return instance[_oid];
                 else
                     return (instance[_oid] = "oid_" + (++_nextOid));
             }
             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 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 {
                 if (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() {
                 return !this;
             }
             function _getNonStrictGlobal() {
                 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?) {
                 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, S>(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);
                     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> {
                 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) {
+                return new Promise((resolve, reject) => {
+                    if (ct.isRequested()) {
+                        ct.register(reject);
+                    } else {
+                        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);
+                    }
+                });
+            }
             /**
              * Для каждого элемента массива вызывает указанную функцию и сохраняет
              * возвращенное значение в массиве результатов.
              *
              * @remarks cb может выполняться асинхронно, при этом одновременно будет
              *          только одна операция.
              *
              * @async
              */
             export function pmap(items, cb) {
                 argumentNotNull(cb, "cb");
                 if (isPromise(items))
                     return items.then(data => pmap(data, cb));
                 if (isNull(items) || !items.length)
                     return items;
                 let i = 0;
                 const result = [];
                 function next() {
                     let r;
                     let ri;
                     function chain(x) {
                         result[ri] = x;
                         return next();
                     }
                     while (i < items.length) {
                         r = cb(items[i], i);
                         ri = i;
                         i++;
                         if (isPromise(r)) {
                             return r.then(chain);
                         } else {
                             result[ri] = r;
                         }
                     }
                     return result;
                 }
                 return next();
             }
             export function pfor(items, cb) {
                 argumentNotNull(cb, "cb");
                 if (isPromise(items))
                     return items.then(data => {
                         return pmap(data, cb);
                     });
                 if (isNull(items) || !items.length)
                     return items;
                 let i = 0;
                 function next() {
                     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) {
                         cb(sequence[0]);
                     } else {
                         return sequence[0];
                     }
                 } else {
                     if (err)
                         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) => void,
+                cb?: (x: T) => any,
-                err?: (x: Error) => void
+                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]) : sequence[0];
+                            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/testAmd/js/plan.js +2 -1

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

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