Add initial version of dijkstra backend cloudron image

node_modules/tarn/lib/PendingOperation.d.ts

@@ -0,0 +1,11 @@
+import { Deferred } from './utils';
+export declare class PendingOperation<T> {
+    protected timeoutMillis: number;
+    possibleTimeoutCause: Error | null;
+    promise: Promise<T>;
+    protected deferred: Deferred<T>;
+    constructor(timeoutMillis: number);
+    abort(): void;
+    reject(err: Error): void;
+    resolve(value: T): void;
+}

node_modules/tarn/lib/PendingOperation.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const TimeoutError_1 = require("./TimeoutError");
+const utils_1 = require("./utils");
+class PendingOperation {
+    constructor(timeoutMillis) {
+        this.timeoutMillis = timeoutMillis;
+        this.deferred = utils_1.defer();
+        this.possibleTimeoutCause = null;
+        this.promise = timeout(this.deferred.promise, timeoutMillis).catch(err => {
+            if (err instanceof TimeoutError_1.TimeoutError) {
+                if (this.possibleTimeoutCause) {
+                    err = new TimeoutError_1.TimeoutError(this.possibleTimeoutCause.message);
+                }
+                else {
+                    err = new TimeoutError_1.TimeoutError('operation timed out for an unknown reason');
+                }
+            }
+            return Promise.reject(err);
+        });
+    }
+    abort() {
+        this.reject(new Error('aborted'));
+    }
+    reject(err) {
+        this.deferred.reject(err);
+    }
+    resolve(value) {
+        this.deferred.resolve(value);
+    }
+}
+exports.PendingOperation = PendingOperation;
+function timeout(promise, time) {
+    return new Promise((resolve, reject) => {
+        const timeoutHandle = setTimeout(() => reject(new TimeoutError_1.TimeoutError()), time);
+        promise
+            .then(result => {
+            clearTimeout(timeoutHandle);
+            resolve(result);
+        })
+            .catch(err => {
+            clearTimeout(timeoutHandle);
+            reject(err);
+        });
+    });
+}

node_modules/tarn/lib/Pool.d.ts

@@ -0,0 +1,83 @@
+import { PendingOperation } from './PendingOperation';
+import { Resource } from './Resource';
+import { EventEmitter } from 'events';
+export interface PoolOptions<T> {
+    create: CallbackOrPromise<T>;
+    destroy: (resource: T) => any;
+    min: number;
+    max: number;
+    acquireTimeoutMillis?: number;
+    createTimeoutMillis?: number;
+    destroyTimeoutMillis?: number;
+    idleTimeoutMillis?: number;
+    createRetryIntervalMillis?: number;
+    reapIntervalMillis?: number;
+    log?: (msg: string) => any;
+    validate?: (resource: T) => boolean;
+    propagateCreateError?: boolean;
+}
+export declare class Pool<T> {
+    protected min: number;
+    protected max: number;
+    protected used: Resource<T>[];
+    protected free: Resource<T>[];
+    protected pendingCreates: PendingOperation<T>[];
+    protected pendingAcquires: PendingOperation<T>[];
+    protected pendingDestroys: PendingOperation<T>[];
+    protected interval: NodeJS.Timer | null;
+    protected destroyed: boolean;
+    protected propagateCreateError: boolean;
+    protected idleTimeoutMillis: number;
+    protected createRetryIntervalMillis: number;
+    protected reapIntervalMillis: number;
+    protected createTimeoutMillis: number;
+    protected destroyTimeoutMillis: number;
+    protected acquireTimeoutMillis: number;
+    protected log: (msg: string, level: 'warn') => any;
+    protected creator: CallbackOrPromise<T>;
+    protected destroyer: (resource: T) => any;
+    protected validate: (resource: T) => boolean;
+    protected eventId: number;
+    protected emitter: EventEmitter;
+    constructor(opt: PoolOptions<T>);
+    numUsed(): number;
+    numFree(): number;
+    numPendingAcquires(): number;
+    numPendingCreates(): number;
+    acquire(): PendingOperation<T>;
+    release(resource: T): boolean;
+    isEmpty(): boolean;
+    check(): void;
+    destroy(): Promise<import("./PromiseInspection").PromiseInspection<{}> | import("./PromiseInspection").PromiseInspection<void>>;
+    on(eventName: 'acquireRequest', handler: (eventId: number) => void): void;
+    on(eventName: 'acquireSuccess', handler: (eventId: number, resource: T) => void): void;
+    on(eventName: 'acquireFail', handler: (eventId: number, err: Error) => void): void;
+    on(eventName: 'release', handler: (resource: T) => void): void;
+    on(eventName: 'createRequest', handler: (eventId: number) => void): void;
+    on(eventName: 'createSuccess', handler: (eventId: number, resource: T) => void): void;
+    on(eventName: 'createFail', handler: (eventId: number, err: Error) => void): void;
+    on(eventName: 'destroyRequest', handler: (eventId: number, resource: T) => void): void;
+    on(eventName: 'destroySuccess', handler: (eventId: number, resource: T) => void): void;
+    on(eventName: 'destroyFail', handler: (eventId: number, resource: T, err: Error) => void): void;
+    on(eventName: 'startReaping', handler: () => void): void;
+    on(eventName: 'stopReaping', handler: () => void): void;
+    on(eventName: 'poolDestroyRequest', handler: (eventId: number) => void): void;
+    on(eventName: 'poolDestroySuccess', handler: (eventId: number) => void): void;
+    removeListener(event: string | symbol, listener: (...args: any[]) => void): void;
+    removeAllListeners(event?: string | symbol | undefined): void;
+    _tryAcquireOrCreate(): void;
+    _hasFreeResources(): boolean;
+    _doAcquire(): void;
+    _canAcquire(): boolean;
+    _validateResource(resource: T): boolean;
+    _shouldCreateMoreResources(): boolean;
+    _doCreate(): void;
+    _create(): PendingOperation<T>;
+    _destroy(resource: T): Promise<void | T>;
+    _logDestroyerError(eventId: number, resource: T, err: Error): void;
+    _startReaping(): void;
+    _stopReaping(): void;
+    _executeEventHandlers(eventName: string, ...args: any): void;
+}
+export declare type Callback<T> = (err: Error | null, resource: T) => any;
+export declare type CallbackOrPromise<T> = (cb: Callback<T>) => any | (() => Promise<T>);

node_modules/tarn/lib/Pool.js

@@ -0,0 +1,402 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const PendingOperation_1 = require("./PendingOperation");
+const Resource_1 = require("./Resource");
+const utils_1 = require("./utils");
+const events_1 = require("events");
+class Pool {
+    constructor(opt) {
+        this.destroyed = false;
+        this.emitter = new events_1.EventEmitter();
+        opt = opt || {};
+        if (!opt.create) {
+            throw new Error('Tarn: opt.create function most be provided');
+        }
+        if (!opt.destroy) {
+            throw new Error('Tarn: opt.destroy function most be provided');
+        }
+        if (typeof opt.min !== 'number' || opt.min < 0 || opt.min !== Math.round(opt.min)) {
+            throw new Error('Tarn: opt.min must be an integer >= 0');
+        }
+        if (typeof opt.max !== 'number' || opt.max <= 0 || opt.max !== Math.round(opt.max)) {
+            throw new Error('Tarn: opt.max must be an integer > 0');
+        }
+        if (opt.min > opt.max) {
+            throw new Error('Tarn: opt.max is smaller than opt.min');
+        }
+        if (!utils_1.checkOptionalTime(opt.acquireTimeoutMillis)) {
+            throw new Error('Tarn: invalid opt.acquireTimeoutMillis ' + JSON.stringify(opt.acquireTimeoutMillis));
+        }
+        if (!utils_1.checkOptionalTime(opt.createTimeoutMillis)) {
+            throw new Error('Tarn: invalid opt.createTimeoutMillis ' + JSON.stringify(opt.createTimeoutMillis));
+        }
+        if (!utils_1.checkOptionalTime(opt.destroyTimeoutMillis)) {
+            throw new Error('Tarn: invalid opt.destroyTimeoutMillis ' + JSON.stringify(opt.destroyTimeoutMillis));
+        }
+        if (!utils_1.checkOptionalTime(opt.idleTimeoutMillis)) {
+            throw new Error('Tarn: invalid opt.idleTimeoutMillis ' + JSON.stringify(opt.idleTimeoutMillis));
+        }
+        if (!utils_1.checkOptionalTime(opt.reapIntervalMillis)) {
+            throw new Error('Tarn: invalid opt.reapIntervalMillis ' + JSON.stringify(opt.reapIntervalMillis));
+        }
+        if (!utils_1.checkOptionalTime(opt.createRetryIntervalMillis)) {
+            throw new Error('Tarn: invalid opt.createRetryIntervalMillis ' +
+                JSON.stringify(opt.createRetryIntervalMillis));
+        }
+        const allowedKeys = {
+            create: true,
+            validate: true,
+            destroy: true,
+            log: true,
+            min: true,
+            max: true,
+            acquireTimeoutMillis: true,
+            createTimeoutMillis: true,
+            destroyTimeoutMillis: true,
+            idleTimeoutMillis: true,
+            reapIntervalMillis: true,
+            createRetryIntervalMillis: true,
+            propagateCreateError: true
+        };
+        for (let key of Object.keys(opt)) {
+            if (!allowedKeys[key]) {
+                throw new Error(`Tarn: unsupported option opt.${key}`);
+            }
+        }
+        this.creator = opt.create;
+        this.destroyer = opt.destroy;
+        this.validate = typeof opt.validate === 'function' ? opt.validate : () => true;
+        this.log = opt.log || (() => { });
+        this.acquireTimeoutMillis = opt.acquireTimeoutMillis || 30000;
+        this.createTimeoutMillis = opt.createTimeoutMillis || 30000;
+        this.destroyTimeoutMillis = opt.destroyTimeoutMillis || 5000;
+        this.idleTimeoutMillis = opt.idleTimeoutMillis || 30000;
+        this.reapIntervalMillis = opt.reapIntervalMillis || 1000;
+        this.createRetryIntervalMillis = opt.createRetryIntervalMillis || 200;
+        this.propagateCreateError = !!opt.propagateCreateError;
+        this.min = opt.min;
+        this.max = opt.max;
+        this.used = [];
+        this.free = [];
+        this.pendingCreates = [];
+        this.pendingAcquires = [];
+        this.pendingDestroys = [];
+        this.destroyed = false;
+        this.interval = null;
+        this.eventId = 1;
+    }
+    numUsed() {
+        return this.used.length;
+    }
+    numFree() {
+        return this.free.length;
+    }
+    numPendingAcquires() {
+        return this.pendingAcquires.length;
+    }
+    numPendingCreates() {
+        return this.pendingCreates.length;
+    }
+    acquire() {
+        const eventId = this.eventId++;
+        this._executeEventHandlers('acquireRequest', eventId);
+        const pendingAcquire = new PendingOperation_1.PendingOperation(this.acquireTimeoutMillis);
+        this.pendingAcquires.push(pendingAcquire);
+        // If the acquire fails for whatever reason
+        // remove it from the pending queue.
+        pendingAcquire.promise = pendingAcquire.promise
+            .then(resource => {
+            this._executeEventHandlers('acquireSuccess', eventId, resource);
+            return resource;
+        })
+            .catch(err => {
+            this._executeEventHandlers('acquireFail', eventId, err);
+            remove(this.pendingAcquires, pendingAcquire);
+            return Promise.reject(err);
+        });
+        this._tryAcquireOrCreate();
+        return pendingAcquire;
+    }
+    release(resource) {
+        this._executeEventHandlers('release', resource);
+        for (let i = 0, l = this.used.length; i < l; ++i) {
+            const used = this.used[i];
+            if (used.resource === resource) {
+                this.used.splice(i, 1);
+                this.free.push(used.resolve());
+                this._tryAcquireOrCreate();
+                return true;
+            }
+        }
+        return false;
+    }
+    isEmpty() {
+        return ([this.numFree(), this.numUsed(), this.numPendingAcquires(), this.numPendingCreates()].reduce((total, value) => total + value) === 0);
+    }
+    check() {
+        const timestamp = utils_1.now();
+        const newFree = [];
+        const minKeep = this.min - this.used.length;
+        const maxDestroy = this.free.length - minKeep;
+        let numDestroyed = 0;
+        this.free.forEach(free => {
+            if (utils_1.duration(timestamp, free.timestamp) >= this.idleTimeoutMillis &&
+                numDestroyed < maxDestroy) {
+                numDestroyed++;
+                this._destroy(free.resource);
+            }
+            else {
+                newFree.push(free);
+            }
+        });
+        this.free = newFree;
+        // Pool is completely empty, stop reaping.
+        // Next .acquire will start reaping interval again.
+        if (this.isEmpty()) {
+            this._stopReaping();
+        }
+    }
+    destroy() {
+        const eventId = this.eventId++;
+        this._executeEventHandlers('poolDestroyRequest', eventId);
+        this._stopReaping();
+        this.destroyed = true;
+        // First wait for all the pending creates get ready.
+        return utils_1.reflect(Promise.all(this.pendingCreates.map(create => utils_1.reflect(create.promise)))
+            .then(() => {
+            // Wait for all the used resources to be freed.
+            return Promise.all(this.used.map(used => utils_1.reflect(used.promise)));
+        })
+            .then(() => {
+            // Abort all pending acquires.
+            return Promise.all(this.pendingAcquires.map(acquire => {
+                acquire.abort();
+                return utils_1.reflect(acquire.promise);
+            }));
+        })
+            .then(() => {
+            // Now we can destroy all the freed resources.
+            return Promise.all(this.free.map(free => utils_1.reflect(this._destroy(free.resource))));
+        })
+            .then(() => {
+            // Also wait rest of the pending destroys to finish
+            return Promise.all(this.pendingDestroys.map(pd => pd.promise));
+        })
+            .then(() => {
+            this.free = [];
+            this.pendingAcquires = [];
+        })).then(res => {
+            this._executeEventHandlers('poolDestroySuccess', eventId);
+            this.emitter.removeAllListeners();
+            return res;
+        });
+    }
+    on(event, listener) {
+        this.emitter.on(event, listener);
+    }
+    removeListener(event, listener) {
+        this.emitter.removeListener(event, listener);
+    }
+    removeAllListeners(event) {
+        this.emitter.removeAllListeners(event);
+    }
+    _tryAcquireOrCreate() {
+        if (this.destroyed) {
+            return;
+        }
+        if (this._hasFreeResources()) {
+            this._doAcquire();
+        }
+        else if (this._shouldCreateMoreResources()) {
+            this._doCreate();
+        }
+    }
+    _hasFreeResources() {
+        return this.free.length > 0;
+    }
+    _doAcquire() {
+        let didDestroyResources = false;
+        while (this._canAcquire()) {
+            const pendingAcquire = this.pendingAcquires[0];
+            const free = this.free[this.free.length - 1];
+            if (!this._validateResource(free.resource)) {
+                this.free.pop();
+                this._destroy(free.resource);
+                didDestroyResources = true;
+                continue;
+            }
+            this.pendingAcquires.shift();
+            this.free.pop();
+            this.used.push(free.resolve());
+            //At least one active resource, start reaping
+            this._startReaping();
+            pendingAcquire.resolve(free.resource);
+        }
+        // If we destroyed invalid resources, we may need to create new ones.
+        if (didDestroyResources) {
+            this._tryAcquireOrCreate();
+        }
+    }
+    _canAcquire() {
+        return this.free.length > 0 && this.pendingAcquires.length > 0;
+    }
+    _validateResource(resource) {
+        try {
+            return !!this.validate(resource);
+        }
+        catch (err) {
+            // There's nothing we can do here but log the error. This would otherwise
+            // leak out as an unhandled exception.
+            this.log('Tarn: resource validator threw an exception ' + err.stack, 'warn');
+            return false;
+        }
+    }
+    _shouldCreateMoreResources() {
+        return (this.used.length + this.pendingCreates.length < this.max &&
+            this.pendingCreates.length < this.pendingAcquires.length);
+    }
+    _doCreate() {
+        const pendingAcquiresBeforeCreate = this.pendingAcquires.slice();
+        const pendingCreate = this._create();
+        pendingCreate.promise
+            .then(() => {
+            // Not returned on purpose.
+            this._tryAcquireOrCreate();
+            return null;
+        })
+            .catch(err => {
+            if (this.propagateCreateError && this.pendingAcquires.length !== 0) {
+                // If propagateCreateError is true, we don't retry the create
+                // but reject the first pending acquire immediately. Intentionally
+                // use `this.pendingAcquires` instead of `pendingAcquiresBeforeCreate`
+                // in case some acquires in pendingAcquiresBeforeCreate have already
+                // been resolved.
+                this.pendingAcquires[0].reject(err);
+            }
+            // Save the create error to all pending acquires so that we can use it
+            // as the error to reject the acquire if it times out.
+            pendingAcquiresBeforeCreate.forEach(pendingAcquire => {
+                pendingAcquire.possibleTimeoutCause = err;
+            });
+            // Not returned on purpose.
+            utils_1.delay(this.createRetryIntervalMillis).then(() => this._tryAcquireOrCreate());
+        });
+    }
+    _create() {
+        const eventId = this.eventId++;
+        this._executeEventHandlers('createRequest', eventId);
+        const pendingCreate = new PendingOperation_1.PendingOperation(this.createTimeoutMillis);
+        this.pendingCreates.push(pendingCreate);
+        callbackOrPromise(this.creator)
+            .then(resource => {
+            remove(this.pendingCreates, pendingCreate);
+            this.free.push(new Resource_1.Resource(resource));
+            // Not returned on purpose.
+            pendingCreate.resolve(resource);
+            this._executeEventHandlers('createSuccess', eventId, resource);
+            return null;
+        })
+            .catch(err => {
+            remove(this.pendingCreates, pendingCreate);
+            // Not returned on purpose.
+            pendingCreate.reject(err);
+            this._executeEventHandlers('createFail', eventId, err);
+            return null;
+        });
+        return pendingCreate;
+    }
+    _destroy(resource) {
+        const eventId = this.eventId++;
+        this._executeEventHandlers('destroyRequest', eventId, resource);
+        // this.destroyer can be both synchronous and asynchronous.
+        // so we wrap it to promise to get all exceptions through same pipeline
+        const pendingDestroy = new PendingOperation_1.PendingOperation(this.destroyTimeoutMillis);
+        const retVal = Promise.resolve().then(() => this.destroyer(resource));
+        retVal
+            .then(() => {
+            pendingDestroy.resolve(resource);
+        })
+            .catch((err) => {
+            pendingDestroy.reject(err);
+        });
+        this.pendingDestroys.push(pendingDestroy);
+        // In case of an error there's nothing we can do here but log it.
+        return pendingDestroy.promise
+            .then(res => {
+            this._executeEventHandlers('destroySuccess', eventId, resource);
+            return res;
+        })
+            .catch(err => this._logDestroyerError(eventId, resource, err))
+            .then(res => {
+            const index = this.pendingDestroys.findIndex(pd => pd === pendingDestroy);
+            this.pendingDestroys.splice(index, 1);
+            return res;
+        });
+    }
+    _logDestroyerError(eventId, resource, err) {
+        this._executeEventHandlers('destroyFail', eventId, resource, err);
+        this.log('Tarn: resource destroyer threw an exception ' + err.stack, 'warn');
+    }
+    _startReaping() {
+        if (!this.interval) {
+            this._executeEventHandlers('startReaping');
+            this.interval = setInterval(() => this.check(), this.reapIntervalMillis);
+        }
+    }
+    _stopReaping() {
+        if (this.interval !== null) {
+            this._executeEventHandlers('stopReaping');
+            clearInterval(this.interval);
+        }
+        this.interval = null;
+    }
+    _executeEventHandlers(eventName, ...args) {
+        const listeners = this.emitter.listeners(eventName);
+        // just calling .emit() would stop running rest of the listeners if one them fails
+        listeners.forEach(listener => {
+            try {
+                listener(...args);
+            }
+            catch (err) {
+                // There's nothing we can do here but log the error. This would otherwise
+                // leak out as an unhandled exception.
+                this.log(`Tarn: event handler "${eventName}" threw an exception ${err.stack}`, 'warn');
+            }
+        });
+    }
+}
+exports.Pool = Pool;
+function remove(arr, item) {
+    var idx = arr.indexOf(item);
+    if (idx === -1) {
+        return false;
+    }
+    else {
+        arr.splice(idx, 1);
+        return true;
+    }
+}
+function callbackOrPromise(func) {
+    return new Promise((resolve, reject) => {
+        const callback = (err, resource) => {
+            if (err) {
+                reject(err);
+            }
+            else {
+                resolve(resource);
+            }
+        };
+        utils_1.tryPromise(() => func(callback))
+            .then(res => {
+            // If the result is falsy, we assume that the callback will
+            // be called instead of interpreting the falsy value as a
+            // result value.
+            if (res) {
+                resolve(res);
+            }
+        })
+            .catch(err => {
+            reject(err);
+        });
+    });
+}

node_modules/tarn/lib/PromiseInspection.d.ts

@@ -0,0 +1,16 @@
+export declare type PromiseInspectionArgs<T> = {
+    value: T;
+    error?: Error;
+} | {
+    value?: T;
+    error: Error;
+};
+export declare class PromiseInspection<T> {
+    _value: T | void;
+    _error: Error | void;
+    constructor(args: PromiseInspectionArgs<T>);
+    value(): void | T;
+    reason(): void | Error;
+    isRejected(): boolean;
+    isFulfilled(): boolean;
+}

node_modules/tarn/lib/PromiseInspection.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class PromiseInspection {
+    constructor(args) {
+        this._value = args.value;
+        this._error = args.error;
+    }
+    value() {
+        return this._value;
+    }
+    reason() {
+        return this._error;
+    }
+    isRejected() {
+        return !!this._error;
+    }
+    isFulfilled() {
+        return !!this._value;
+    }
+}
+exports.PromiseInspection = PromiseInspection;

node_modules/tarn/lib/Resource.d.ts

@@ -0,0 +1,9 @@
+import { Deferred } from './utils';
+export declare class Resource<T> {
+    resource: T;
+    readonly timestamp: number;
+    protected deferred: Deferred<void>;
+    constructor(resource: T);
+    readonly promise: Promise<void>;
+    resolve(): Resource<T>;
+}

node_modules/tarn/lib/Resource.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("./utils");
+class Resource {
+    constructor(resource) {
+        this.resource = resource;
+        this.resource = resource;
+        this.timestamp = utils_1.now();
+        this.deferred = utils_1.defer();
+    }
+    get promise() {
+        return this.deferred.promise;
+    }
+    resolve() {
+        this.deferred.resolve(undefined);
+        return new Resource(this.resource);
+    }
+}
+exports.Resource = Resource;

node_modules/tarn/lib/TimeoutError.d.ts

@@ -0,0 +1,2 @@
+export declare class TimeoutError extends Error {
+}

node_modules/tarn/lib/TimeoutError.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class TimeoutError extends Error {
+}
+exports.TimeoutError = TimeoutError;

node_modules/tarn/lib/tarn.d.ts

@@ -0,0 +1,3 @@
+import { Pool } from './Pool';
+import { TimeoutError } from './TimeoutError';
+export { Pool, TimeoutError };

node_modules/tarn/lib/tarn.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const Pool_1 = require("./Pool");
+exports.Pool = Pool_1.Pool;
+const TimeoutError_1 = require("./TimeoutError");
+exports.TimeoutError = TimeoutError_1.TimeoutError;
+module.exports = {
+    Pool: Pool_1.Pool,
+    TimeoutError: TimeoutError_1.TimeoutError
+};

node_modules/tarn/lib/utils.d.ts

@@ -0,0 +1,14 @@
+import { PromiseInspection } from './PromiseInspection';
+export interface Deferred<T> {
+    resolve: (val: T) => any;
+    reject: <T>(err: T) => any;
+    promise: Promise<T>;
+}
+export declare function defer<T>(): Deferred<T>;
+export declare function now(): number;
+export declare function duration(t1: number, t2: number): number;
+export declare function checkOptionalTime(time?: number): boolean;
+export declare function checkRequiredTime(time: number): boolean;
+export declare function delay(millis: number): Promise<{}>;
+export declare function reflect<T>(promise: Promise<T>): Promise<PromiseInspection<T> | PromiseInspection<{}>>;
+export declare function tryPromise<T>(cb: () => T | PromiseLike<T>): Promise<T>;

node_modules/tarn/lib/utils.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const PromiseInspection_1 = require("./PromiseInspection");
+function defer() {
+    let resolve = null;
+    let reject = null;
+    const promise = new Promise((resolver, rejecter) => {
+        resolve = resolver;
+        reject = rejecter;
+    });
+    return {
+        promise,
+        resolve,
+        reject
+    };
+}
+exports.defer = defer;
+function now() {
+    return Date.now();
+}
+exports.now = now;
+function duration(t1, t2) {
+    return Math.abs(t2 - t1);
+}
+exports.duration = duration;
+function checkOptionalTime(time) {
+    if (typeof time === 'undefined') {
+        return true;
+    }
+    return checkRequiredTime(time);
+}
+exports.checkOptionalTime = checkOptionalTime;
+function checkRequiredTime(time) {
+    return typeof time === 'number' && time === Math.round(time) && time > 0;
+}
+exports.checkRequiredTime = checkRequiredTime;
+function delay(millis) {
+    return new Promise(resolve => setTimeout(resolve, millis));
+}
+exports.delay = delay;
+function reflect(promise) {
+    return promise
+        .then(value => {
+        return new PromiseInspection_1.PromiseInspection({ value });
+    })
+        .catch(error => {
+        return new PromiseInspection_1.PromiseInspection({ error });
+    });
+}
+exports.reflect = reflect;
+function tryPromise(cb) {
+    try {
+        const result = cb();
+        return Promise.resolve(result);
+    }
+    catch (err) {
+        return Promise.reject(err);
+    }
+}
+exports.tryPromise = tryPromise;