-
Notifications
You must be signed in to change notification settings - Fork 3
/
chainable.ts
126 lines (113 loc) · 3.53 KB
/
chainable.ts
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
import {
EachHandler,
EveryHandler,
FilterHandler,
FindHandler,
MapTransformer,
ParallelHandler,
RaceTransformer,
ReduceTransformer,
Resolvable,
SomeHandler,
each,
every,
filter,
find,
findIndex,
map,
reduce,
reduceRight,
some,
} from '.';
export class Chainable<T> extends Promise<T[]> {
each(handler: EachHandler<T>): Promise<boolean> {
let chainable = this.then(values => each(values, handler));
return Promise.resolve(chainable);
}
every(handler: EveryHandler<T>): Promise<boolean> {
let chainable = this.then(values => every(values, handler));
return Promise.resolve(chainable);
}
filter(handler: FilterHandler<T>): Chainable<T> {
return this.then(values => filter(values, handler)) as Chainable<T>;
}
find(handler: FindHandler<T>): Promise<T | undefined> {
let chainable = this.then(values => find(values, handler));
return Promise.resolve(chainable);
}
findIndex(handler: FindHandler<T>): Promise<number> {
let chainable = this.then(values => findIndex(values, handler));
return Promise.resolve(chainable);
}
map<TResult>(
transformer: MapTransformer<T, TResult>,
concurrency?: number,
): Chainable<TResult> {
return this.then(values =>
map(values, transformer, concurrency),
) as Chainable<TResult>;
}
parallel(handler: ParallelHandler<T>, concurrency?: number): Promise<void> {
let chainable = this.then(values => map(values, handler, concurrency));
return Promise.resolve(chainable).then(() => undefined);
}
race<TResult>(transformer: RaceTransformer<T, TResult>): Promise<TResult> {
let chainable = this.then(values => Promise.race(values.map(transformer)));
return Promise.resolve(chainable);
}
reduce<TResult>(
transformer: ReduceTransformer<T, TResult[]>,
initial: TResult[],
): Chainable<TResult>;
reduce<TResult>(
transformer: ReduceTransformer<T, TResult>,
initial: TResult,
): Promise<TResult>;
reduce(transformer: ReduceTransformer<T, T>): Promise<T>;
reduce(
transformer: ReduceTransformer<any, any>,
...args: any[]
): Chainable<any> | Promise<any> {
let chainable = this.then(values =>
(reduce as Function)(values, transformer, ...args),
);
return Array.isArray(args[0])
? (chainable as Chainable<any>)
: Promise.resolve(chainable);
}
reduceRight<TResult>(
transformer: ReduceTransformer<T, TResult[]>,
initial: TResult[],
): Chainable<TResult>;
reduceRight<TResult>(
transformer: ReduceTransformer<T, TResult>,
initial: TResult,
): Promise<TResult>;
reduceRight(transformer: ReduceTransformer<T, T>): Promise<T>;
reduceRight(
transformer: ReduceTransformer<any, any>,
...args: any[]
): Chainable<any> | Promise<any> {
let chainable = this.then(values =>
(reduceRight as Function)(values, transformer, ...args),
);
return Array.isArray(args[0])
? (chainable as Chainable<any>)
: Promise.resolve(chainable);
}
some(handler: SomeHandler<T>): Promise<boolean> {
let chainable = this.then(values => some(values, handler));
return Promise.resolve(chainable);
}
static resolve(): Promise<any>;
static resolve<T>(resolvable: Resolvable<T[]>): Chainable<T>;
static resolve<T>(resolvable?: Resolvable<T[]>): Chainable<T> {
return new Chainable<T>(resolve => resolve(resolvable));
}
}
/**
* Wrap given resolvable with a chainable derived of built-in promise.
*/
export function chainable<T>(resolvable: Resolvable<T[]>): Chainable<T> {
return Chainable.resolve(resolvable);
}