mirror of
https://github.com/gosticks/DefinitelyTyped.git
synced 2025-10-16 12:05:41 +00:00
3c7c5b79aa
* [bluebird] Rename import to Bluebird for tests * [bluebird] Restore assignability to native Promises * [bluebird] Upgrade TypeScript Versions of all dependents
1452 lines
40 KiB
TypeScript
1452 lines
40 KiB
TypeScript
// Tests by: Bart van der Schoor <https://github.com/Bartvds>
|
|
|
|
// Note: replicate changes to all overloads in both definition and test file
|
|
// Note: keep both static and instance members inline (so similar)
|
|
|
|
// Note: try to maintain the ordering and separators, and keep to the pattern
|
|
|
|
import * as Bluebird from "bluebird";
|
|
|
|
let obj: object = {};
|
|
let bool = false;
|
|
let num = 0;
|
|
let str = '';
|
|
let err: Error = new Error();
|
|
let x: any = 0;
|
|
let f: (...args: any[]) => any = () => {};
|
|
let asyncfunc: (...args: any[]) => Bluebird<any>;
|
|
let arr: any[];
|
|
let exp: RegExp;
|
|
let anyArr: any[];
|
|
let strArr: string[];
|
|
let numArr: number[];
|
|
|
|
// - - - - - - - - - - - - - - - - -
|
|
|
|
let value: any;
|
|
let reason: any;
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
interface Foo {
|
|
foo(): string;
|
|
}
|
|
interface Bar {
|
|
bar(): string;
|
|
}
|
|
interface Baz {
|
|
baz(): string;
|
|
}
|
|
interface Qux {
|
|
qux: string;
|
|
}
|
|
|
|
// - - - - - - - - - - - - - - - - -
|
|
|
|
interface StrFooMap {
|
|
[key: string]: Foo;
|
|
}
|
|
|
|
interface StrBarMap {
|
|
[key: string]: Bar;
|
|
}
|
|
|
|
// - - - - - - - - - - - - - - - - -
|
|
|
|
interface StrFooArrMap {
|
|
[key: string]: Foo[];
|
|
}
|
|
|
|
interface StrBarArrMap {
|
|
[key: string]: Bar[];
|
|
}
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
let foo: Foo = { foo() { return 'foo'; } };
|
|
let bar: Bar = { bar() { return 'bar'; } };
|
|
let baz: Baz = { baz() { return 'baz'; } };
|
|
let qux: Qux = { qux: 'quix' };
|
|
|
|
let fooArr: Foo[] = [foo];
|
|
let barArr: Bar[];
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
let numProm: Bluebird<number>;
|
|
let strProm: Bluebird<string>;
|
|
let anyProm: Bluebird<any>;
|
|
let boolProm: Bluebird<boolean>;
|
|
let objProm: Bluebird<object> = Bluebird.resolve(obj);
|
|
let voidProm: Bluebird<void>;
|
|
|
|
let fooProm: Bluebird<Foo> = Bluebird.resolve(foo);
|
|
let barProm: Bluebird<Bar> = Bluebird.resolve(bar);
|
|
let fooOrBarProm: Bluebird<Foo | Bar>;
|
|
let bazProm: Bluebird<Baz> = Bluebird.resolve(baz);
|
|
let quxProm: Bluebird<Qux> = Bluebird.resolve(qux);
|
|
|
|
// - - - - - - - - - - - - - - - - -
|
|
|
|
let numThen: PromiseLike<number>;
|
|
let strThen: PromiseLike<string>;
|
|
let anyThen: PromiseLike<any>;
|
|
let boolThen: PromiseLike<boolean>;
|
|
let objThen: PromiseLike<object>;
|
|
let voidThen: PromiseLike<void>;
|
|
|
|
let fooThen: PromiseLike<Foo> = fooProm;
|
|
let barThen: PromiseLike<Bar> = barProm;
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
let numArrProm: Bluebird<number[]>;
|
|
let strArrProm: Bluebird<string[]>;
|
|
let anyArrProm: Bluebird<any[]>;
|
|
|
|
let fooArrProm: Bluebird<Foo[]> = Bluebird.resolve(fooArr);
|
|
let barArrProm: Bluebird<Bar[]>;
|
|
|
|
// - - - - - - - - - - - - - - - - -
|
|
|
|
let numArrThen: PromiseLike<number[]>;
|
|
let strArrThen: PromiseLike<string[]>;
|
|
let anyArrThen: PromiseLike<any[]>;
|
|
|
|
let fooArrThen: PromiseLike<Foo[]> = fooArrProm;
|
|
let barArrThen: PromiseLike<Bar[]>;
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
let numPromArr: Array<Bluebird<number>>;
|
|
let strPromArr: Array<Bluebird<string>>;
|
|
let anyPromArr: Array<Bluebird<any>>;
|
|
|
|
let fooPromArr: Array<Bluebird<Foo>>;
|
|
let barPromArr: Array<Bluebird<Bar>>;
|
|
|
|
// - - - - - - - - - - - - - - - - -
|
|
|
|
let numThenArr: Array<PromiseLike<number>>;
|
|
let strThenArr: Array<PromiseLike<string>>;
|
|
let anyThenArr: Array<PromiseLike<any>>;
|
|
|
|
let fooThenArr: Array<PromiseLike<Foo>> = [fooThen];
|
|
let barThenArr: Array<PromiseLike<Bar>>;
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
// booya!
|
|
let fooThenArrThen: PromiseLike<Array<PromiseLike<Foo>>> = Bluebird.resolve(fooThenArr);
|
|
|
|
let fooResolver: Bluebird.Resolver<Foo>;
|
|
let fooInspection: Bluebird.Inspection<Foo>;
|
|
let fooInspectionPromise: Bluebird<Bluebird.Inspection<Foo>>;
|
|
|
|
let fooInspectionArrProm: Bluebird<Array<Bluebird.Inspection<Foo>>>;
|
|
|
|
let BlueBird: typeof Bluebird;
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
let nativeFooProm: Promise<Foo>;
|
|
let nativeBarProm: Promise<Bar>;
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
let version: string = Bluebird.version;
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
let nodeCallbackFunc = (callback: (err: any, result: string) => void) => {};
|
|
let nodeCallbackFuncErrorOnly = (callback: (err: any) => void) => {};
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
fooThen = fooProm;
|
|
barThen = barProm;
|
|
|
|
nativeFooProm = fooProm;
|
|
nativeBarProm = barProm;
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
fooProm = new Bluebird((resolve: (value: Foo) => void, reject: (reason: any) => void) => {
|
|
if (bool) {
|
|
resolve(foo);
|
|
} else {
|
|
reject(new Error(str));
|
|
}
|
|
});
|
|
fooProm = new Bluebird((resolve: (value: Foo) => void) => {
|
|
if (bool) {
|
|
resolve(foo);
|
|
}
|
|
});
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
// needs a hint when used untyped?
|
|
fooProm = new Bluebird<Foo>((resolve, reject) => {
|
|
if (bool) {
|
|
resolve(fooThen);
|
|
} else {
|
|
reject(new Error(str));
|
|
}
|
|
});
|
|
fooProm = new Bluebird<Foo>((resolve) => {
|
|
resolve(fooThen);
|
|
});
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
fooInspectionPromise = fooProm.reflect();
|
|
|
|
fooInspectionPromise.then(value => {
|
|
fooInspection = value;
|
|
bool = fooInspection.isFulfilled();
|
|
bool = fooInspection.isRejected();
|
|
bool = fooInspection.isPending();
|
|
foo = fooInspection.value();
|
|
x = fooInspection.reason();
|
|
});
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
barProm = fooProm.then((value: Foo) => {
|
|
return bar;
|
|
}, (reason: any) => {
|
|
return bar;
|
|
});
|
|
barProm = fooProm.then((value: Foo) => {
|
|
return bar;
|
|
}, (reason: any) => {
|
|
return barProm;
|
|
});
|
|
// $ExpectType Bluebird<void | Bar>
|
|
fooProm.then((value: Foo) => {
|
|
return bar;
|
|
}, (reason: any) => {
|
|
return;
|
|
});
|
|
// $ExpectType Bluebird<void | Bar>
|
|
fooProm.then((value: Foo) => {
|
|
return bar;
|
|
}, (reason: any) => {
|
|
return voidProm;
|
|
});
|
|
barProm = fooProm.then((value: Foo) => {
|
|
return bar;
|
|
});
|
|
barProm = barProm.then((value: Bar) => {
|
|
if (value) return value;
|
|
return Bluebird.resolve(bar);
|
|
});
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
// $ExpectType Bluebird<void | Foo>
|
|
fooProm.catch((reason: any) => {
|
|
return;
|
|
});
|
|
|
|
// $ExpectType Bluebird<void | Foo>
|
|
fooProm.caught((reason: any) => {
|
|
return;
|
|
});
|
|
// $ExpectType Bluebird<void | Foo>
|
|
fooProm.catch((error: any) => {
|
|
return true;
|
|
}, (reason: any) => {
|
|
return;
|
|
});
|
|
// $ExpectType Bluebird<void | Foo>
|
|
fooProm.caught((error: any) => {
|
|
return true;
|
|
}, (reason: any) => {
|
|
return;
|
|
});
|
|
|
|
// $ExpectType Bluebird<void | Foo>
|
|
fooProm.catch((reason: any) => {
|
|
return voidProm;
|
|
});
|
|
// $ExpectType Bluebird<void | Foo>
|
|
fooProm.caught((reason: any) => {
|
|
return voidProm;
|
|
});
|
|
// $ExpectType Bluebird<void | Foo>
|
|
fooProm.catch((error: any) => {
|
|
return true;
|
|
}, (reason: any) => {
|
|
return voidProm;
|
|
});
|
|
// $ExpectType Bluebird<void | Foo>
|
|
fooProm.caught((error: any) => {
|
|
return true;
|
|
}, (reason: any) => {
|
|
return voidProm;
|
|
});
|
|
|
|
// $ExpectType Bluebird<void | Foo>
|
|
fooProm.catch<void | Foo>((reason: any) => { // tslint:disable-line:void-return
|
|
// handle multiple valid return types simultaneously
|
|
if (foo === null) {
|
|
return;
|
|
} else if (!reason) {
|
|
return voidProm;
|
|
} else if (foo) {
|
|
return foo;
|
|
}
|
|
});
|
|
|
|
fooOrBarProm = fooProm.catch((reason: any) => {
|
|
return bar;
|
|
});
|
|
fooOrBarProm = fooProm.caught((reason: any) => {
|
|
return bar;
|
|
});
|
|
|
|
fooOrBarProm = fooProm.catch((error: any) => {
|
|
return true;
|
|
}, (reason: any) => {
|
|
return bar;
|
|
});
|
|
fooOrBarProm = fooProm.caught((error: any) => {
|
|
return true;
|
|
}, (reason: any) => {
|
|
return bar;
|
|
});
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
// $ExpectType Bluebird<void | Foo>
|
|
fooProm.catch(Error, (reason: any) => {
|
|
return;
|
|
});
|
|
// $ExpectType Bluebird<void | Foo>
|
|
fooProm.catch(Bluebird.CancellationError, (reason: any) => {
|
|
return;
|
|
});
|
|
// $ExpectType Bluebird<void | Foo>
|
|
fooProm.caught(Error, (reason: any) => {
|
|
return;
|
|
});
|
|
// $ExpectType Bluebird<void | Foo>
|
|
fooProm.caught(Bluebird.CancellationError, (reason: any) => {
|
|
return;
|
|
});
|
|
|
|
fooOrBarProm = fooProm.catch(Error, (reason: any) => {
|
|
return bar;
|
|
});
|
|
fooOrBarProm = fooProm.catch(Bluebird.CancellationError, (reason: any) => {
|
|
return bar;
|
|
});
|
|
fooOrBarProm = fooProm.caught(Error, (reason: any) => {
|
|
return bar;
|
|
});
|
|
fooOrBarProm = fooProm.caught(Bluebird.CancellationError, (reason: any) => {
|
|
return bar;
|
|
});
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
class CustomError extends Error {
|
|
customField: number;
|
|
}
|
|
// $ExpectType Bluebird<void | Foo>
|
|
fooProm.catch(CustomError, reason => {
|
|
let a: number = reason.customField;
|
|
});
|
|
|
|
class CustomErrorWithConstructor extends Error {
|
|
arg1: boolean;
|
|
arg2: number;
|
|
constructor(arg1: boolean, arg2: number) {
|
|
super();
|
|
this.arg1 = arg1;
|
|
this.arg2 = arg2;
|
|
}
|
|
}
|
|
// $ExpectType Bluebird<void | Foo>
|
|
fooProm.catch(CustomErrorWithConstructor, reason => {
|
|
let a: boolean = reason.arg1;
|
|
let b: number = reason.arg2;
|
|
});
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
class CustomError1 extends Error {}
|
|
class CustomError2 extends Error {}
|
|
class CustomError3 extends Error {}
|
|
class CustomError4 extends Error {}
|
|
class CustomError5 extends Error {}
|
|
|
|
// $ExpectType Bluebird<void | Foo>
|
|
fooProm.catch(CustomError1, error => {});
|
|
// $ExpectType Bluebird<void | Foo>
|
|
fooProm.catch(CustomError1, CustomError2, error => {});
|
|
// $ExpectType Bluebird<void | Foo>
|
|
fooProm.catch(CustomError1, CustomError2, CustomError3, error => {});
|
|
// $ExpectType Bluebird<void | Foo>
|
|
fooProm.catch(CustomError1, CustomError2, CustomError3, CustomError4, error => {});
|
|
// $ExpectType Bluebird<void | Foo>
|
|
fooProm.catch(CustomError1, CustomError2, CustomError3, CustomError4, CustomError5, error => {});
|
|
|
|
const booPredicate1 = (error: CustomError1) => true;
|
|
const booPredicate2 = (error: [number]) => true;
|
|
const booPredicate3 = (error: string) => true;
|
|
const booPredicate4 = (error: object) => true;
|
|
const booPredicate5 = (error: any) => true;
|
|
|
|
// $ExpectType Bluebird<void | Foo>
|
|
fooProm.catch(booPredicate1, error => {});
|
|
// $ExpectType Bluebird<void | Foo>
|
|
fooProm.catch(booPredicate1, booPredicate2, error => {});
|
|
// $ExpectType Bluebird<void | Foo>
|
|
fooProm.catch(booPredicate1, booPredicate2, booPredicate3, error => {});
|
|
// $ExpectType Bluebird<void | Foo>
|
|
fooProm.catch(booPredicate1, booPredicate2, booPredicate3, booPredicate4, error => {});
|
|
// $ExpectType Bluebird<void | Foo>
|
|
fooProm.catch(booPredicate1, booPredicate2, booPredicate3, booPredicate4, booPredicate5, error => {});
|
|
|
|
const booObject1 = new CustomError1();
|
|
const booObject2 = [400, 500];
|
|
const booObject3 = ["Error1", "Error2"];
|
|
const booObject4 = {code: 400};
|
|
const booObject5: any = null;
|
|
|
|
// $ExpectType Bluebird<void | Foo>
|
|
fooProm.catch(booObject1, error => {});
|
|
// $ExpectType Bluebird<void | Foo>
|
|
fooProm.catch(booObject1, booObject2, error => {});
|
|
// $ExpectType Bluebird<void | Foo>
|
|
fooProm.catch(booObject1, booObject2, booObject3, error => {});
|
|
// $ExpectType Bluebird<void | Foo>
|
|
fooProm.catch(booObject1, booObject2, booObject3, booObject4, error => {});
|
|
// $ExpectType Bluebird<void | Foo>
|
|
fooProm.catch(booObject1, booObject2, booObject3, booObject4, booObject5, error => {});
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
barProm = fooProm.error((reason: any) => {
|
|
return bar;
|
|
});
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
fooProm = fooProm.finally(() => {
|
|
// non-Thenable return is ignored
|
|
return "foo";
|
|
});
|
|
fooProm = fooProm.finally(() => {
|
|
return fooThen;
|
|
});
|
|
fooProm = fooProm.finally(() => {
|
|
// non-Thenable return is ignored
|
|
});
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
fooProm = fooProm.lastly(() => {
|
|
// non-Thenable return is ignored
|
|
return "foo";
|
|
});
|
|
fooProm = fooProm.lastly(() => {
|
|
return fooThen;
|
|
});
|
|
fooProm = fooProm.lastly(() => {
|
|
// non-Thenable return is ignored
|
|
});
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
fooProm = fooProm.bind(obj);
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
// $ExpectType void
|
|
fooProm.done((value: Foo) => {
|
|
return bar;
|
|
}, (reason: any) => {
|
|
return bar;
|
|
});
|
|
// $ExpectType void
|
|
fooProm.done((value: Foo) => {
|
|
return bar;
|
|
});
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
// $ExpectType void
|
|
fooProm.done((value: Foo) => {
|
|
return barThen;
|
|
}, (reason: any) => {
|
|
return barThen;
|
|
});
|
|
// $ExpectType void
|
|
fooProm.done((value: Foo) => {
|
|
return barThen;
|
|
});
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
fooProm = fooProm.tap((value: Foo) => {
|
|
// non-Thenable return is ignored
|
|
return "foo";
|
|
});
|
|
fooProm = fooProm.tap((value: Foo) => {
|
|
return fooThen;
|
|
});
|
|
fooProm = fooProm.tap((value: Foo) => {
|
|
return voidThen;
|
|
});
|
|
fooProm = fooProm.tap(() => {
|
|
// non-Thenable return is ignored
|
|
});
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
fooProm = fooProm.tapCatch((err) => {
|
|
return "foo";
|
|
});
|
|
|
|
fooProm = fooProm.tapCatch(err => {
|
|
return Bluebird.resolve("foo");
|
|
});
|
|
|
|
fooProm.tapCatch(CustomError, (err: CustomError) => {
|
|
return err.customField;
|
|
});
|
|
|
|
fooProm.tapCatch((e: any) => e instanceof CustomError, (err: CustomError) => {
|
|
return err.customField;
|
|
});
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
fooProm = fooProm.delay(num);
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
fooProm = fooProm.timeout(num);
|
|
fooProm = fooProm.timeout(num, str);
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
fooProm.nodeify();
|
|
fooProm = fooProm.nodeify((err: any) => { });
|
|
fooProm = fooProm.nodeify((err: any, foo?: Foo) => { });
|
|
|
|
fooProm.nodeify({ spread: true });
|
|
fooProm = fooProm.nodeify((err: any) => { }, { spread: true });
|
|
fooProm = fooProm.nodeify((err: any, foo?: Foo) => { }, { spread: true });
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
// $ExpectType void
|
|
fooProm.cancel();
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
bool = fooProm.isCancelled();
|
|
bool = fooProm.isFulfilled();
|
|
bool = fooProm.isRejected();
|
|
bool = fooProm.isPending();
|
|
bool = fooProm.isResolved();
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
strProm = fooProm.call("foo");
|
|
strProm = fooProm.call("foo", 1, 2, 3);
|
|
|
|
// $ExpectType Bluebird<never>
|
|
quxProm.call("qux");
|
|
|
|
strProm = fooProm.get("foo").then(method => method());
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
barProm = fooProm.return(bar);
|
|
barProm = fooProm.thenReturn(bar);
|
|
|
|
voidProm = fooProm.return();
|
|
voidProm = fooProm.thenReturn();
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
// fooProm
|
|
fooProm = fooProm.throw(err);
|
|
fooProm = fooProm.thenThrow(err);
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
fooOrBarProm = fooProm.return(foo).catchReturn(bar);
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
// fooProm
|
|
fooProm = fooProm.catchThrow(err);
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
str = fooProm.toString();
|
|
|
|
obj = fooProm.toJSON();
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
barProm = fooArrProm.spread((one: Foo, two: Foo, twotwo: Foo) => {
|
|
return bar;
|
|
});
|
|
|
|
// - - - - - - - - - - - - - - - - -
|
|
|
|
barProm = fooArrProm.spread((one: Foo, two: Foo, twotwo: Foo) => {
|
|
return barThen;
|
|
});
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
fooArrProm = fooArrProm.all();
|
|
|
|
// $ExpectType Bluebird<never>
|
|
fooProm.all();
|
|
|
|
fooProm = fooArrProm.any();
|
|
|
|
// $ExpectType Bluebird<never>
|
|
fooProm.any();
|
|
|
|
fooArrProm = fooArrProm.some(num);
|
|
|
|
// $ExpectType Bluebird<never>
|
|
fooProm.some(num);
|
|
|
|
fooProm = fooArrProm.race();
|
|
|
|
// $ExpectType Bluebird<never>
|
|
fooProm.race();
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
let propsValue: { num: number, str: string };
|
|
Bluebird.resolve({ num: 1, str: Bluebird.resolve('a') }).props().then(val => { propsValue = val; });
|
|
Bluebird.props({ num: 1, str: Bluebird.resolve('a') }).then(val => { propsValue = val; });
|
|
Bluebird.props(Bluebird.props({ num: 1, str: Bluebird.resolve('a') })).then(val => { propsValue = val; });
|
|
|
|
let propsMapValue: Map<number, string>;
|
|
Bluebird.resolve(new Map<number, string>()).props().then(val => { propsMapValue = val; });
|
|
Bluebird.resolve(new Map<number, PromiseLike<string>>()).props().then(val => { propsMapValue = val; });
|
|
Bluebird.props(new Map<number, string>()).then(val => { propsMapValue = val; });
|
|
Bluebird.props(new Map<number, PromiseLike<string>>()).then(val => { propsMapValue = val; });
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
Bluebird.all([fooProm, barProm]).then(result => {
|
|
foo = result[0];
|
|
bar = result[1];
|
|
});
|
|
|
|
Bluebird.all([fooProm, fooProm]).then(result => {
|
|
foo = result[0];
|
|
foo = result[1];
|
|
});
|
|
|
|
Bluebird.all([fooProm, barProm, bazProm]).then(result => {
|
|
foo = result[0];
|
|
bar = result[1];
|
|
baz = result[2];
|
|
});
|
|
|
|
Bluebird.all([fooProm, barProm, fooProm]).then(result => {
|
|
foo = result[0];
|
|
bar = result[1];
|
|
foo = result[2];
|
|
});
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
barArrProm = fooArrProm.map((item: Foo, index: number, arrayLength: number) => {
|
|
return bar;
|
|
});
|
|
barArrProm = fooArrProm.map((item: Foo) => {
|
|
return bar;
|
|
});
|
|
|
|
barArrProm = fooArrProm.map((item: Foo, index: number, arrayLength: number) => {
|
|
return bar;
|
|
}, {
|
|
concurrency: 1
|
|
});
|
|
barArrProm = fooArrProm.map((item: Foo) => {
|
|
return bar;
|
|
}, {
|
|
concurrency: 1
|
|
});
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
barArrProm = fooArrProm.mapSeries((item: Foo, index: number, arrayLength: number) => {
|
|
return bar;
|
|
});
|
|
barArrProm = fooArrProm.mapSeries((item: Foo) => {
|
|
return bar;
|
|
});
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
barProm = fooArrProm.reduce((memo: Bar, item: Foo, index: number, arrayLength: number) => {
|
|
return memo;
|
|
});
|
|
barProm = fooArrProm.reduce((memo: Bar, item: Foo) => {
|
|
return memo;
|
|
}, bar);
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
fooArrProm = fooArrProm.filter((item: Foo, index: number, arrayLength: number) => {
|
|
return bool;
|
|
});
|
|
fooArrProm = fooArrProm.filter((item: Foo) => {
|
|
return bool;
|
|
});
|
|
|
|
fooArrProm = fooArrProm.filter((item: Foo, index: number, arrayLength: number) => {
|
|
return bool;
|
|
}, {
|
|
concurrency: 1
|
|
});
|
|
fooArrProm = fooArrProm.filter((item: Foo) => {
|
|
return bool;
|
|
}, {
|
|
concurrency: 1
|
|
});
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
fooArrProm = fooArrProm.each((item: Foo): Bar => bar);
|
|
fooArrProm = fooArrProm.each((item: Foo, index: number) => index ? bar : null);
|
|
fooArrProm = fooArrProm.each((item: Foo, index: number, arrayLength: number): Bar => bar);
|
|
fooArrProm = fooArrProm.each((item: Foo, index: number, arrayLength: number): Bluebird<Bar> => barProm);
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
fooProm = new Bluebird.Promise<Foo>((resolve, reject) => {
|
|
resolve(foo);
|
|
});
|
|
fooProm = Bluebird.Promise.try<Foo>(() => {
|
|
return foo;
|
|
});
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
function getMaybePromise(): Foo|Bluebird<Foo> {
|
|
return foo;
|
|
}
|
|
|
|
fooProm = Bluebird.try(() => {
|
|
return getMaybePromise();
|
|
});
|
|
fooProm = Bluebird.try<Foo>(() => {
|
|
return getMaybePromise();
|
|
});
|
|
fooProm = Bluebird.try(() => {
|
|
return foo;
|
|
});
|
|
|
|
// - - - - - - - - - - - - - - - - -
|
|
|
|
fooProm = Bluebird.try(() => {
|
|
return fooThen;
|
|
});
|
|
|
|
// - - - - - - - - - - - - - - - - -
|
|
|
|
fooProm = Bluebird.try(() => {
|
|
if (fooProm) {
|
|
return fooProm;
|
|
}
|
|
return foo;
|
|
});
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
fooProm = Bluebird.attempt(() => {
|
|
return getMaybePromise();
|
|
});
|
|
fooProm = Bluebird.attempt<Foo>(() => {
|
|
return getMaybePromise();
|
|
});
|
|
fooProm = Bluebird.attempt(() => {
|
|
return foo;
|
|
});
|
|
|
|
// - - - - - - - - - - - - - - - - -
|
|
|
|
fooProm = Bluebird.attempt(() => {
|
|
if (fooProm) {
|
|
return fooProm;
|
|
}
|
|
return foo;
|
|
});
|
|
|
|
// - - - - - - - - - - - - - - - - -
|
|
|
|
fooProm = Bluebird.attempt(() => {
|
|
return fooThen;
|
|
});
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
asyncfunc = Bluebird.method(() => {});
|
|
{
|
|
const noArg: () => Bluebird<void> = Bluebird.method(() => {});
|
|
const oneArg: (x1: number) => Bluebird<void> = Bluebird.method((x1: number) => {});
|
|
const twoArg: (x1: number, x2: string) => Bluebird<void> = Bluebird.method((x1: number, x2: string) => {});
|
|
}
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
fooProm = Bluebird.resolve(foo);
|
|
fooProm = Bluebird.resolve(fooThen);
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
voidProm = Bluebird.reject(reason);
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
fooResolver = Bluebird.defer<Foo>();
|
|
|
|
fooResolver.resolve(foo);
|
|
|
|
fooResolver.reject(err);
|
|
|
|
fooResolver.callback = (err: any, value: Foo) => {};
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
fooProm = Bluebird.cast(foo);
|
|
fooProm = Bluebird.cast(fooThen);
|
|
|
|
voidProm = Bluebird.bind(x);
|
|
|
|
bool = Bluebird.is(value);
|
|
|
|
Bluebird.longStackTraces();
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
// TODO enable delay
|
|
|
|
fooProm = Bluebird.delay(num, fooThen);
|
|
fooProm = Bluebird.delay(num, foo);
|
|
voidProm = Bluebird.delay(num);
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
asyncfunc = Bluebird.promisify(f);
|
|
asyncfunc = Bluebird.promisify(f, obj);
|
|
|
|
obj = Bluebird.promisifyAll(obj);
|
|
anyProm = Bluebird.fromNode(nodeCallbackFunc);
|
|
anyProm = Bluebird.fromNode(nodeCallbackFuncErrorOnly);
|
|
anyProm = Bluebird.fromNode(nodeCallbackFunc, {multiArgs : true});
|
|
anyProm = Bluebird.fromNode(nodeCallbackFuncErrorOnly, {multiArgs : true});
|
|
|
|
anyProm = Bluebird.fromCallback(nodeCallbackFunc);
|
|
anyProm = Bluebird.fromCallback(nodeCallbackFuncErrorOnly);
|
|
anyProm = Bluebird.fromCallback(nodeCallbackFunc, {multiArgs : true});
|
|
anyProm = Bluebird.fromCallback(nodeCallbackFuncErrorOnly, {multiArgs : true});
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
declare let util: any;
|
|
|
|
function defaultFilter(name: string, func: (...args: any[]) => any) {
|
|
return util.isIdentifier(name) &&
|
|
name.charAt(0) !== "_" &&
|
|
!util.isClass(func);
|
|
}
|
|
|
|
function DOMPromisifier(originalMethod: (...args: any[]) => any) {
|
|
// return a function
|
|
return function promisified(this: object, ...args: any[]) {
|
|
// which returns a promise
|
|
return new Bluebird((resolve, reject) => {
|
|
args.push(resolve, reject);
|
|
originalMethod.apply(this, args);
|
|
});
|
|
};
|
|
}
|
|
|
|
obj = Bluebird.promisifyAll(obj, {
|
|
suffix: "",
|
|
filter: defaultFilter,
|
|
promisifier: DOMPromisifier
|
|
});
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
const generator1 = function*(a: number, b: string) { return "string"; };
|
|
const coroutine1 = Bluebird.coroutine<string, number, string>(generator1);
|
|
strProm = coroutine1(5, "foo");
|
|
|
|
const generator2 = function*(a: number, b: string) {
|
|
yield foo;
|
|
return bar;
|
|
};
|
|
const coroutine2 = Bluebird.coroutine<Bar, number, string>(generator2);
|
|
barProm = coroutine2(5, "foo");
|
|
|
|
const coroutineCustomYield = Bluebird.coroutine(generator1, { yieldHandler: (value) => "whatever" });
|
|
/*
|
|
barProm = Bluebird.spawn<number>(f);
|
|
*/
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
BlueBird = Bluebird.getNewLibraryCopy();
|
|
BlueBird = Bluebird.noConflict();
|
|
|
|
Bluebird.onPossiblyUnhandledRejection((reason: any) => {});
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
// TODO expand tests to overloads
|
|
fooArrProm = Bluebird.all(fooThenArrThen);
|
|
fooArrProm = Bluebird.all(fooArrProm);
|
|
fooArrProm = Bluebird.all(fooThenArr);
|
|
fooArrProm = Bluebird.all(fooArr);
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
objProm = Bluebird.props(objProm);
|
|
objProm = Bluebird.props(obj);
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
// TODO expand tests to overloads
|
|
fooProm = Bluebird.any(fooThenArrThen);
|
|
fooProm = Bluebird.any(fooArrProm);
|
|
fooProm = Bluebird.any(fooThenArr);
|
|
fooProm = Bluebird.any(fooArr);
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
// TODO expand tests to overloads
|
|
fooProm = Bluebird.race(fooThenArrThen);
|
|
fooProm = Bluebird.race(fooArrProm);
|
|
fooProm = Bluebird.race(fooThenArr);
|
|
fooProm = Bluebird.race(fooArr);
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
// TODO expand tests to overloads
|
|
fooArrProm = Bluebird.some(fooThenArrThen, num);
|
|
fooArrProm = Bluebird.some(fooThenArr, num);
|
|
fooArrProm = Bluebird.some(fooArr, num);
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
fooArrProm = Bluebird.join(foo, foo, foo);
|
|
fooArrProm = Bluebird.join(fooThen, fooThen, fooThen);
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
// map()
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
// fooThenArrThen
|
|
|
|
barArrProm = Bluebird.map(fooThenArrThen, (item: Foo) => {
|
|
return bar;
|
|
});
|
|
barArrProm = Bluebird.map(fooThenArrThen, (item: Foo) => {
|
|
return barThen;
|
|
});
|
|
barArrProm = Bluebird.map(fooThenArrThen, (item: Foo, index: number, arrayLength: number) => {
|
|
return bar;
|
|
});
|
|
barArrProm = Bluebird.map(fooThenArrThen, (item: Foo, index: number, arrayLength: number) => {
|
|
return barThen;
|
|
});
|
|
|
|
barArrProm = Bluebird.map(fooThenArrThen, (item: Foo) => {
|
|
return bar;
|
|
}, {
|
|
concurrency: 1
|
|
});
|
|
barArrProm = Bluebird.map(fooThenArrThen, (item: Foo) => {
|
|
return barThen;
|
|
}, {
|
|
concurrency: 1
|
|
});
|
|
barArrProm = Bluebird.map(fooThenArrThen, (item: Foo, index: number, arrayLength: number) => {
|
|
return bar;
|
|
}, {
|
|
concurrency: 1
|
|
});
|
|
barArrProm = Bluebird.map(fooThenArrThen, (item: Foo, index: number, arrayLength: number) => {
|
|
return barThen;
|
|
}, {
|
|
concurrency: 1
|
|
});
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
// fooArrThen
|
|
|
|
barArrProm = Bluebird.map(fooArrThen, (item: Foo) => {
|
|
return bar;
|
|
});
|
|
barArrProm = Bluebird.map(fooArrThen, (item: Foo) => {
|
|
return barThen;
|
|
});
|
|
barArrProm = Bluebird.map(fooArrThen, (item: Foo, index: number, arrayLength: number) => {
|
|
return bar;
|
|
});
|
|
barArrProm = Bluebird.map(fooArrThen, (item: Foo, index: number, arrayLength: number) => {
|
|
return barThen;
|
|
});
|
|
|
|
barArrProm = Bluebird.map(fooArrThen, (item: Foo) => {
|
|
return bar;
|
|
}, {
|
|
concurrency: 1
|
|
});
|
|
barArrProm = Bluebird.map(fooArrThen, (item: Foo) => {
|
|
return barThen;
|
|
}, {
|
|
concurrency: 1
|
|
});
|
|
barArrProm = Bluebird.map(fooArrThen, (item: Foo, index: number, arrayLength: number) => {
|
|
return bar;
|
|
}, {
|
|
concurrency: 1
|
|
});
|
|
barArrProm = Bluebird.map(fooArrThen, (item: Foo, index: number, arrayLength: number) => {
|
|
return barThen;
|
|
}, {
|
|
concurrency: 1
|
|
});
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
// fooThenArr
|
|
|
|
barArrProm = Bluebird.map(fooThenArr, (item: Foo) => {
|
|
return bar;
|
|
});
|
|
barArrProm = Bluebird.map(fooThenArr, (item: Foo) => {
|
|
return barThen;
|
|
});
|
|
barArrProm = Bluebird.map(fooThenArr, (item: Foo, index: number, arrayLength: number) => {
|
|
return bar;
|
|
});
|
|
barArrProm = Bluebird.map(fooThenArr, (item: Foo, index: number, arrayLength: number) => {
|
|
return barThen;
|
|
});
|
|
|
|
barArrProm = Bluebird.map(fooThenArr, (item: Foo) => {
|
|
return bar;
|
|
}, {
|
|
concurrency: 1
|
|
});
|
|
barArrProm = Bluebird.map(fooThenArr, (item: Foo) => {
|
|
return barThen;
|
|
}, {
|
|
concurrency: 1
|
|
});
|
|
barArrProm = Bluebird.map(fooThenArr, (item: Foo, index: number, arrayLength: number) => {
|
|
return bar;
|
|
}, {
|
|
concurrency: 1
|
|
});
|
|
barArrProm = Bluebird.map(fooThenArr, (item: Foo, index: number, arrayLength: number) => {
|
|
return barThen;
|
|
}, {
|
|
concurrency: 1
|
|
});
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
// fooArr
|
|
|
|
barArrProm = Bluebird.map(fooArr, (item: Foo) => {
|
|
return bar;
|
|
});
|
|
barArrProm = Bluebird.map(fooArr, (item: Foo) => {
|
|
return barThen;
|
|
});
|
|
barArrProm = Bluebird.map(fooArr, (item: Foo, index: number, arrayLength: number) => {
|
|
return bar;
|
|
});
|
|
barArrProm = Bluebird.map(fooArr, (item: Foo, index: number, arrayLength: number) => {
|
|
return barThen;
|
|
});
|
|
|
|
barArrProm = Bluebird.map(fooArr, (item: Foo) => {
|
|
return bar;
|
|
}, {
|
|
concurrency: 1
|
|
});
|
|
barArrProm = Bluebird.map(fooArr, (item: Foo) => {
|
|
return barThen;
|
|
}, {
|
|
concurrency: 1
|
|
});
|
|
barArrProm = Bluebird.map(fooArr, (item: Foo, index: number, arrayLength: number) => {
|
|
return bar;
|
|
}, {
|
|
concurrency: 1
|
|
});
|
|
barArrProm = Bluebird.map(fooArr, (item: Foo, index: number, arrayLength: number) => {
|
|
return barThen;
|
|
}, {
|
|
concurrency: 1
|
|
});
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
// mapSeries()
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
// fooThenArrThen
|
|
|
|
barArrProm = Bluebird.mapSeries(fooThenArrThen, (item: Foo) => {
|
|
return bar;
|
|
});
|
|
barArrProm = Bluebird.mapSeries(fooThenArrThen, (item: Foo) => {
|
|
return barThen;
|
|
});
|
|
barArrProm = Bluebird.mapSeries(fooThenArrThen, (item: Foo, index: number, arrayLength: number) => {
|
|
return bar;
|
|
});
|
|
barArrProm = Bluebird.mapSeries(fooThenArrThen, (item: Foo, index: number, arrayLength: number) => {
|
|
return barThen;
|
|
});
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
// fooArrThen
|
|
|
|
barArrProm = Bluebird.mapSeries(fooArrThen, (item: Foo) => {
|
|
return bar;
|
|
});
|
|
barArrProm = Bluebird.mapSeries(fooArrThen, (item: Foo) => {
|
|
return barThen;
|
|
});
|
|
barArrProm = Bluebird.mapSeries(fooArrThen, (item: Foo, index: number, arrayLength: number) => {
|
|
return bar;
|
|
});
|
|
barArrProm = Bluebird.mapSeries(fooArrThen, (item: Foo, index: number, arrayLength: number) => {
|
|
return barThen;
|
|
});
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
// fooThenArr
|
|
|
|
barArrProm = Bluebird.mapSeries(fooThenArr, (item: Foo) => {
|
|
return bar;
|
|
});
|
|
barArrProm = Bluebird.mapSeries(fooThenArr, (item: Foo) => {
|
|
return barThen;
|
|
});
|
|
barArrProm = Bluebird.mapSeries(fooThenArr, (item: Foo, index: number, arrayLength: number) => {
|
|
return bar;
|
|
});
|
|
barArrProm = Bluebird.mapSeries(fooThenArr, (item: Foo, index: number, arrayLength: number) => {
|
|
return barThen;
|
|
});
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
// fooArr
|
|
|
|
barArrProm = Bluebird.mapSeries(fooArr, (item: Foo) => {
|
|
return bar;
|
|
});
|
|
barArrProm = Bluebird.mapSeries(fooArr, (item: Foo) => {
|
|
return barThen;
|
|
});
|
|
barArrProm = Bluebird.mapSeries(fooArr, (item: Foo, index: number, arrayLength: number) => {
|
|
return bar;
|
|
});
|
|
barArrProm = Bluebird.mapSeries(fooArr, (item: Foo, index: number, arrayLength: number) => {
|
|
return barThen;
|
|
});
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
// reduce()
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
// fooThenArrThen
|
|
|
|
barProm = Bluebird.reduce(fooThenArrThen, (memo: Bar, item: Foo) => {
|
|
return memo;
|
|
}, bar);
|
|
barProm = Bluebird.reduce(fooThenArrThen, (memo: Bar, item: Foo) => {
|
|
return barThen;
|
|
}, bar);
|
|
barProm = Bluebird.reduce(fooThenArrThen, (memo: Bar, item: Foo, index: number, arrayLength: number) => {
|
|
return memo;
|
|
}, bar);
|
|
barProm = Bluebird.reduce(fooThenArrThen, (memo: Bar, item: Foo, index: number, arrayLength: number) => {
|
|
return barThen;
|
|
}, bar);
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
// fooArrThen
|
|
|
|
barProm = Bluebird.reduce(fooArrThen, (memo: Bar, item: Foo) => {
|
|
return memo;
|
|
}, bar);
|
|
barProm = Bluebird.reduce(fooArrThen, (memo: Bar, item: Foo) => {
|
|
return barThen;
|
|
}, bar);
|
|
barProm = Bluebird.reduce(fooArrThen, (memo: Bar, item: Foo, index: number, arrayLength: number) => {
|
|
return memo;
|
|
}, bar);
|
|
barProm = Bluebird.reduce(fooArrThen, (memo: Bar, item: Foo, index: number, arrayLength: number) => {
|
|
return barThen;
|
|
}, bar);
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
// fooThenArr
|
|
|
|
barProm = Bluebird.reduce(fooThenArr, (memo: Bar, item: Foo) => {
|
|
return memo;
|
|
}, bar);
|
|
barProm = Bluebird.reduce(fooThenArr, (memo: Bar, item: Foo) => {
|
|
return barThen;
|
|
}, bar);
|
|
barProm = Bluebird.reduce(fooThenArr, (memo: Bar, item: Foo, index: number, arrayLength: number) => {
|
|
return memo;
|
|
}, bar);
|
|
barProm = Bluebird.reduce(fooThenArr, (memo: Bar, item: Foo, index: number, arrayLength: number) => {
|
|
return barThen;
|
|
}, bar);
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
// fooArr
|
|
|
|
barProm = Bluebird.reduce(fooArr, (memo: Bar, item: Foo) => {
|
|
return memo;
|
|
}, bar);
|
|
barProm = Bluebird.reduce(fooArr, (memo: Bar, item: Foo) => {
|
|
return barThen;
|
|
}, bar);
|
|
barProm = Bluebird.reduce(fooArr, (memo: Bar, item: Foo, index: number, arrayLength: number) => {
|
|
return memo;
|
|
}, bar);
|
|
barProm = Bluebird.reduce(fooArr, (memo: Bar, item: Foo, index: number, arrayLength: number) => {
|
|
return barThen;
|
|
}, bar);
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
// filter()
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
// fooThenArrThen
|
|
|
|
fooArrProm = Bluebird.filter(fooThenArrThen, (item: Foo) => {
|
|
return bool;
|
|
});
|
|
fooArrProm = Bluebird.filter(fooThenArrThen, (item: Foo) => {
|
|
return boolThen;
|
|
});
|
|
fooArrProm = Bluebird.filter(fooThenArrThen, (item: Foo, index: number, arrayLength: number) => {
|
|
return bool;
|
|
});
|
|
fooArrProm = Bluebird.filter(fooThenArrThen, (item: Foo, index: number, arrayLength: number) => {
|
|
return boolThen;
|
|
});
|
|
|
|
fooArrProm = Bluebird.filter(fooThenArrThen, (item: Foo) => {
|
|
return bool;
|
|
}, {
|
|
concurrency: 1
|
|
});
|
|
fooArrProm = Bluebird.filter(fooThenArrThen, (item: Foo) => {
|
|
return boolThen;
|
|
}, {
|
|
concurrency: 1
|
|
});
|
|
fooArrProm = Bluebird.filter(fooThenArrThen, (item: Foo, index: number, arrayLength: number) => {
|
|
return bool;
|
|
}, {
|
|
concurrency: 1
|
|
});
|
|
fooArrProm = Bluebird.filter(fooThenArrThen, (item: Foo, index: number, arrayLength: number) => {
|
|
return boolThen;
|
|
}, {
|
|
concurrency: 1
|
|
});
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
// fooArrThen
|
|
|
|
fooArrProm = Bluebird.filter(fooArrThen, (item: Foo) => {
|
|
return bool;
|
|
});
|
|
fooArrProm = Bluebird.filter(fooArrThen, (item: Foo) => {
|
|
return boolThen;
|
|
});
|
|
fooArrProm = Bluebird.filter(fooArrThen, (item: Foo, index: number, arrayLength: number) => {
|
|
return bool;
|
|
});
|
|
fooArrProm = Bluebird.filter(fooArrThen, (item: Foo, index: number, arrayLength: number) => {
|
|
return boolThen;
|
|
});
|
|
|
|
fooArrProm = Bluebird.filter(fooArrThen, (item: Foo) => {
|
|
return bool;
|
|
}, {
|
|
concurrency: 1
|
|
});
|
|
fooArrProm = Bluebird.filter(fooArrThen, (item: Foo) => {
|
|
return boolThen;
|
|
}, {
|
|
concurrency: 1
|
|
});
|
|
fooArrProm = Bluebird.filter(fooArrThen, (item: Foo, index: number, arrayLength: number) => {
|
|
return bool;
|
|
}, {
|
|
concurrency: 1
|
|
});
|
|
fooArrProm = Bluebird.filter(fooArrThen, (item: Foo, index: number, arrayLength: number) => {
|
|
return boolThen;
|
|
}, {
|
|
concurrency: 1
|
|
});
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
// fooThenArr
|
|
|
|
fooArrProm = Bluebird.filter(fooThenArr, (item: Foo) => {
|
|
return bool;
|
|
});
|
|
fooArrProm = Bluebird.filter(fooThenArr, (item: Foo) => {
|
|
return boolThen;
|
|
});
|
|
fooArrProm = Bluebird.filter(fooThenArr, (item: Foo, index: number, arrayLength: number) => {
|
|
return bool;
|
|
});
|
|
fooArrProm = Bluebird.filter(fooThenArr, (item: Foo, index: number, arrayLength: number) => {
|
|
return boolThen;
|
|
});
|
|
|
|
fooArrProm = Bluebird.filter(fooThenArr, (item: Foo) => {
|
|
return bool;
|
|
}, {
|
|
concurrency: 1
|
|
});
|
|
fooArrProm = Bluebird.filter(fooThenArr, (item: Foo) => {
|
|
return boolThen;
|
|
}, {
|
|
concurrency: 1
|
|
});
|
|
fooArrProm = Bluebird.filter(fooThenArr, (item: Foo, index: number, arrayLength: number) => {
|
|
return bool;
|
|
}, {
|
|
concurrency: 1
|
|
});
|
|
fooArrProm = Bluebird.filter(fooThenArr, (item: Foo, index: number, arrayLength: number) => {
|
|
return boolThen;
|
|
}, {
|
|
concurrency: 1
|
|
});
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
// fooArr
|
|
|
|
fooArrProm = Bluebird.filter(fooArr, (item: Foo) => {
|
|
return bool;
|
|
});
|
|
fooArrProm = Bluebird.filter(fooArr, (item: Foo) => {
|
|
return boolThen;
|
|
});
|
|
fooArrProm = Bluebird.filter(fooArr, (item: Foo, index: number, arrayLength: number) => {
|
|
return bool;
|
|
});
|
|
fooArrProm = Bluebird.filter(fooArr, (item: Foo, index: number, arrayLength: number) => {
|
|
return boolThen;
|
|
});
|
|
|
|
fooArrProm = Bluebird.filter(fooArr, (item: Foo) => {
|
|
return bool;
|
|
}, {
|
|
concurrency: 1
|
|
});
|
|
fooArrProm = Bluebird.filter(fooArr, (item: Foo) => {
|
|
return boolThen;
|
|
}, {
|
|
concurrency: 1
|
|
});
|
|
fooArrProm = Bluebird.filter(fooArr, (item: Foo, index: number, arrayLength: number) => {
|
|
return bool;
|
|
}, {
|
|
concurrency: 1
|
|
});
|
|
fooArrProm = Bluebird.filter(fooArr, (item: Foo, index: number, arrayLength: number) => {
|
|
return boolThen;
|
|
}, {
|
|
concurrency: 1
|
|
});
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
// each()
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
// fooThenArrThen
|
|
|
|
fooArrThen = Bluebird.each(fooThenArrThen, (item: Foo) => bar);
|
|
fooArrThen = Bluebird.each(fooThenArrThen, (item: Foo) => barThen);
|
|
fooArrThen = Bluebird.each(fooThenArrThen, (item: Foo, index: number, arrayLength: number) => bar);
|
|
fooArrThen = Bluebird.each(fooThenArrThen, (item: Foo, index: number, arrayLength: number) => barThen);
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
// fooArrThen
|
|
|
|
fooArrThen = Bluebird.each(fooArrThen, (item: Foo) => bar);
|
|
fooArrThen = Bluebird.each(fooArrThen, (item: Foo) => barThen);
|
|
fooArrThen = Bluebird.each(fooArrThen, (item: Foo, index: number, arrayLength: number) => bar);
|
|
fooArrThen = Bluebird.each(fooArrThen, (item: Foo, index: number, arrayLength: number) => barThen);
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
// fooThenArr
|
|
|
|
fooArrThen = Bluebird.each(fooThenArr, (item: Foo) => bar);
|
|
fooArrThen = Bluebird.each(fooThenArr, (item: Foo) => barThen);
|
|
fooArrThen = Bluebird.each(fooThenArr, (item: Foo, index: number, arrayLength: number) => bar);
|
|
fooArrThen = Bluebird.each(fooThenArr, (item: Foo, index: number, arrayLength: number) => barThen);
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
// fooArr
|
|
|
|
fooArrThen = Bluebird.each(fooArr, (item: Foo) => bar);
|
|
fooArrThen = Bluebird.each(fooArr, (item: Foo) => barThen);
|
|
fooArrThen = Bluebird.each(fooArr, (item: Foo, index: number, arrayLength: number) => bar);
|
|
fooArrThen = Bluebird.each(fooArr, (item: Foo, index: number, arrayLength: number) => barThen);
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|