-
-
Notifications
You must be signed in to change notification settings - Fork 57
/
index.js
110 lines (90 loc) · 2.33 KB
/
index.js
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
import AggregateError from 'aggregate-error';
const stopSymbol = Symbol('pMap.stop');
export default async function pMap(
iterable,
mapper,
{
concurrency = Number.POSITIVE_INFINITY,
stopOnError = true
} = {}
) {
return new Promise((resolve, reject) => {
if (typeof mapper !== 'function') {
throw new TypeError('Mapper function is required');
}
if (!((Number.isSafeInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency >= 1)) {
throw new TypeError(`Expected \`concurrency\` to be an integer from 1 and up or \`Infinity\`, got \`${concurrency}\` (${typeof concurrency})`);
}
const result = [];
const errors = [];
const iterator = iterable[Symbol.iterator]();
const pendingIndexes = new Set();
let finished = false;
let isIterableDone = false;
let currentIndex = 0;
const next = () => {
if (finished) {
return;
}
const nextItem = iterator.next();
const index = currentIndex;
currentIndex++;
if (nextItem.done) {
isIterableDone = true;
if (pendingIndexes.size === 0) {
if (!stopOnError && errors.length > 0) {
reject(new AggregateError(errors));
} else {
resolve(result);
}
}
return;
}
pendingIndexes.add(index);
(async () => {
try {
const element = await nextItem.value;
if (finished) {
return;
}
result[index] = await mapper(element, index);
if (finished) {
return;
}
pendingIndexes.delete(index);
if (result[index] && result[index][stopSymbol]) {
finished = true;
const stopConfig = result[index][stopSymbol];
result[index] = stopConfig.value;
if (stopConfig.ongoingMappings.collapse) {
resolve(result.flat(0));
} else {
for (const pendingIndex of pendingIndexes) {
result[pendingIndex] = stopConfig.ongoingMappings.fillWith;
}
resolve(result);
}
} else {
next();
}
} catch (error) {
if (stopOnError) {
finished = true;
reject(error);
} else {
errors.push(error);
pendingIndexes.delete(index);
next();
}
}
})();
};
for (let index = 0; index < concurrency; index++) {
next();
if (isIterableDone) {
break;
}
}
});
}
pMap.stop = ({value, ongoingMappings = {}} = {}) => ({[stopSymbol]: {value, ongoingMappings}});