65 lines
1.4 KiB
TypeScript
65 lines
1.4 KiB
TypeScript
import * as util from 'util';
|
|
|
|
export interface IResolve<T> {
|
|
(value?: T | Promise<T>): void;
|
|
}
|
|
|
|
export interface IReject {
|
|
(reason?: any): void;
|
|
}
|
|
|
|
export type TDeferredStatus = 'pending' | 'fulfilled' | 'rejected';
|
|
|
|
export class Deferred<T> {
|
|
promise: Promise<T>;
|
|
resolve: IResolve<T>;
|
|
reject: IReject;
|
|
status: TDeferredStatus;
|
|
constructor() {
|
|
this.promise = new Promise<T>((resolve, reject) => {
|
|
this.resolve = resolve;
|
|
this.reject = reject;
|
|
this.status = 'pending';
|
|
});
|
|
}
|
|
}
|
|
|
|
export let defer = <T>() => {
|
|
return new Deferred<T>();
|
|
};
|
|
|
|
/**
|
|
* Creates a new resolved promise for the provided value.
|
|
*/
|
|
export let resolvedPromise = <T>(value?: T): Promise<T> => {
|
|
return Promise.resolve(value);
|
|
};
|
|
|
|
/**
|
|
* Creates a new rejected promise for the provided reason.
|
|
*/
|
|
export let rejectedPromise = err => {
|
|
return Promise.reject(err);
|
|
};
|
|
|
|
export let promisify = util.promisify;
|
|
|
|
// polyfill
|
|
if (!promisify) {
|
|
promisify = require('util.promisify');
|
|
}
|
|
export let map = async <T>(inputArg: T[], functionArg) => {
|
|
let promisifedFunction = promisify(functionArg);
|
|
let promiseArray: Promise<any>[] = [];
|
|
let resultArray = [];
|
|
for (let item of inputArg) {
|
|
let promise: Promise<any> = promisifedFunction(item);
|
|
promiseArray.push(promise);
|
|
promise.then(x => {
|
|
resultArray.push(x);
|
|
});
|
|
}
|
|
await Promise.all(promiseArray);
|
|
return resultArray;
|
|
};
|