UNPKG

6.92 kBJavaScriptView Raw
1/**
2 * Check if passed parameter is a Promise
3 * @param {Object} obj
4 */
5const isPromise = (obj) => {
6 return typeof obj === 'object' && typeof obj.then === 'function';
7};
8
9/**
10 * forEach implementation in parallel
11 * @param {*[]} array
12 * @param {Function} callback
13 * @param {Object} thisArg
14 */
15exports.forEach = async (array, callback, thisArg) => {
16 const promiseArray = [];
17 for (let i = 0; i < array.length; i++) {
18 promiseArray.push(callback.call(thisArg || this, array[i], i, array));
19 }
20 await Promise.all(promiseArray);
21};
22
23/**
24 * forEach implementation in series
25 * @param {*[]} array
26 * @param {Function} callback
27 * @param {Object} thisArg
28 */
29exports.forEachSeries = async (array, callback, thisArg) => {
30 for (let i = 0; i < array.length; i++) {
31 await callback.call(thisArg || this, array[i], i, array);
32 }
33};
34
35/**
36 * map implementation in parallel
37 * @param {*[]} array
38 * @param {Function} callback
39 * @param {Object} thisArg
40 */
41exports.map = async (array, callback, thisArg) => {
42 const promiseArray = [];
43 for (let i = 0; i < array.length; i++) {
44 if (i in array) {
45 promiseArray[i] = callback.call(thisArg || this, array[i], i, array);
46 }
47 }
48 return Promise.all(promiseArray);
49};
50
51/**
52 * map implementation in series
53 * @param {*[]} array
54 * @param {Function} callback
55 * @param {Object} thisArg
56 */
57exports.mapSeries = async (array, callback, thisArg) => {
58 const result = [];
59 for (let i = 0; i < array.length; i++) {
60 if (i in array) {
61 result[i] = await callback.call(thisArg || this, array[i], i, array);
62 }
63 }
64 return result;
65};
66
67/**
68 * find implementation in parallel
69 * @param {*[]} array
70 * @param {Function} callback
71 * @param {Object} thisArg
72 */
73exports.find = (array, callback, thisArg) => {
74 return new Promise((resolve, reject) => {
75 for (let i = 0; i < array.length; i++) {
76 const check = (found) => {
77 if (found) {
78 resolve(array[i]);
79 }
80 };
81 const result = callback.call(thisArg || this, array[i], i, array);
82 if (isPromise(result)) {
83 result.then(check).catch(reject);
84 } else {
85 check(result);
86 }
87 }
88 });
89};
90
91/**
92 * find implementation in series
93 * @param {*[]} array
94 * @param {Function} callback
95 * @param {Object} thisArg
96 */
97exports.findSeries = async (array, callback, thisArg) => {
98 for (let i = 0; i < array.length; i++) {
99 if (await callback.call(thisArg || this, array[i], i, array)) {
100 return array[i];
101 }
102 }
103};
104
105/**
106 * findIndex implementation in parallel
107 * @param {*[]} array
108 * @param {Function} callback
109 * @param {Object} thisArg
110 */
111exports.findIndex = (array, callback, thisArg) => {
112 return new Promise((resolve, reject) => {
113 for (let i = 0; i < array.length; i++) {
114 const check = (found) => {
115 if (found) {
116 resolve(i);
117 }
118 };
119 const result = callback.call(thisArg || this, array[i], i, array);
120 if (isPromise(result)) {
121 result.then(check).catch(reject);
122 } else {
123 check(result);
124 }
125 }
126 });
127};
128
129/**
130 * findIndex implementation in series
131 * @param {*[]} array
132 * @param {Function} callback
133 * @param {Object} thisArg
134 */
135exports.findIndexSeries = async (array, callback, thisArg) => {
136 for (let i = 0; i < array.length; i++) {
137 if (await callback.call(thisArg || this, array[i], i, array)) {
138 return i;
139 }
140 }
141};
142
143/**
144 * some implementation in parallel
145 * @param {*[]} array
146 * @param {Function} callback
147 * @param {Object} thisArg
148 */
149exports.some = (array, callback, thisArg) => {
150 return new Promise((resolve, reject) => {
151 for (let i = 0; i < array.length; i++) {
152 const check = (found) => {
153 if (found) {
154 resolve(true);
155 } else if (i === array.length - 1) {
156 resolve(false);
157 }
158 };
159 const result = callback.call(thisArg || this, array[i], i, array);
160 if (isPromise(result)) {
161 result.then(check).catch(reject);
162 } else {
163 check(result);
164 }
165 }
166 });
167};
168
169/**
170 * some implementation in series
171 * @param {*[]} array
172 * @param {Function} callback
173 * @param {Object} thisArg
174 */
175exports.someSeries = async (array, callback, thisArg) => {
176 for (let i = 0; i < array.length; i++) {
177 if (await callback.call(thisArg || this, array[i], i, array)) {
178 return true;
179 }
180 }
181 return false;
182};
183
184/**
185 * every implementation in parallel
186 * @param {*[]} array
187 * @param {Function} callback
188 * @param {Object} thisArg
189 */
190exports.every = (array, callback, thisArg) => {
191 return new Promise((resolve, reject) => {
192 for (let i = 0; i < array.length; i++) {
193 const check = (found) => {
194 if (!found) {
195 resolve(false);
196 } else if (i === array.length - 1) {
197 resolve(true);
198 }
199 };
200 const result = callback.call(thisArg || this, array[i], i, array);
201 if (isPromise(result)) {
202 result.then(check).catch(reject);
203 } else {
204 check(result);
205 }
206 }
207 });
208};
209
210/**
211 * every implementation in series
212 * @param {*[]} array
213 * @param {Function} callback
214 * @param {Object} thisArg
215 */
216exports.everySeries = async (array, callback, thisArg) => {
217 for (let i = 0; i < array.length; i++) {
218 if (!await callback.call(thisArg || this, array[i], i, array)) {
219 return false;
220 }
221 }
222 return true;
223};
224
225/**
226 * filter implementation in parallel
227 * @param {*[]} array
228 * @param {Function} callback
229 * @param {Object} thisArg
230 */
231exports.filter = async (array, callback, thisArg) => {
232 const promiseArray = [];
233 for (let i = 0; i < array.length; i++) {
234 if (i in array) {
235 promiseArray[i] = callback.call(thisArg || this, array[i], i, array);
236 } else {
237 continue;
238 }
239 }
240 return Promise.all(promiseArray).then(results => {
241 const filteredArray = [];
242 results.forEach((result, index) => {
243 if (result) {
244 filteredArray.push(array[index]);
245 }
246 });
247 return filteredArray;
248 });
249};
250
251/**
252 * filter implementation in series
253 * @param {*[]} array
254 * @param {Function} callback
255 * @param {Object} thisArg
256 */
257exports.filterSeries = async (array, callback, thisArg) => {
258 const result = [];
259 for (let i = 0; i < array.length; i++) {
260 if (i in array) {
261 if (await callback.call(thisArg || this, array[i], i, array)) {
262 result.push(array[i]);
263 }
264 }
265 }
266 return result;
267};
268
269/**
270 * reduce implementation
271 * @param {*[]} array
272 * @param {Function} callback
273 * @param {*} initialValue
274 */
275exports.reduce = async (array, callback, initialValue) => {
276 let previousValue;
277 for (let i = 0; i < array.length; i++) {
278 if (i === 0) {
279 if (initialValue) {
280 previousValue = initialValue;
281 } else {
282 previousValue = array[i];
283 continue;
284 }
285 }
286 if (i in array) {
287 previousValue = await callback(previousValue, array[i], i, array);
288 }
289 }
290 return previousValue;
291};