-
Notifications
You must be signed in to change notification settings - Fork 3
/
concurrency.ts
58 lines (49 loc) · 1.29 KB
/
concurrency.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
import {Resolvable, map} from '.';
let lockObjectToPromiseMapping = new Map<any, Promise<any>>();
export type LockHandler<T> = () => Resolvable<T>;
async function _lock<T>(object: any, handler: LockHandler<T>): Promise<T> {
try {
await lockObjectToPromiseMapping.get(object);
} catch (error) {}
return handler();
}
/**
* A simple asynchronous lock that helps queueing operations.
*/
export async function lock<T>(
object: any,
handler: LockHandler<T>,
): Promise<T> {
let ret = _lock(object, handler);
lockObjectToPromiseMapping.set(object, ret);
return ret;
}
export type ParallelHandler<T> = (
value: T,
index: number,
values: T[],
) => Resolvable<void>;
/**
* Run tasks in parallel, similar to `v.map` but not mean to transform.
*/
export async function parallel<T>(
values: T[],
handler: ParallelHandler<T>,
concurrency?: number,
): Promise<void> {
await map(values, handler, concurrency);
}
export type RaceTransformer<T, TResult> = (
value: T,
index: number,
values: T[],
) => Resolvable<TResult>;
/**
* Race tasks and fulfill or reject as soon as one of them fulfills or rejects.
*/
export async function race<T, TResult>(
values: T[],
transformer: RaceTransformer<T, TResult>,
): Promise<TResult> {
return Promise.race(values.map(transformer));
}