@modern-js/plugin 2.12.0 → 2.13.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (43) hide show
  1. package/CHANGELOG.md +8 -0
  2. package/dist/cjs/farrow-pipeline/context.js +7 -16
  3. package/dist/cjs/farrow-pipeline/counter.js +1 -2
  4. package/dist/cjs/farrow-pipeline/index.js +71 -2
  5. package/dist/cjs/manager/async.js +9 -8
  6. package/dist/cjs/manager/shared.js +16 -15
  7. package/dist/cjs/manager/sync.js +4 -9
  8. package/dist/cjs/waterfall/async.js +3 -2
  9. package/dist/cjs/workflow/async.js +6 -5
  10. package/dist/cjs/workflow/parallel.js +1 -1
  11. package/dist/esm/index.js +743 -4
  12. package/dist/esm-node/farrow-pipeline/context.js +7 -16
  13. package/dist/esm-node/farrow-pipeline/counter.js +1 -2
  14. package/dist/esm-node/farrow-pipeline/index.js +60 -1
  15. package/dist/esm-node/manager/async.js +9 -8
  16. package/dist/esm-node/manager/shared.js +16 -15
  17. package/dist/esm-node/manager/sync.js +4 -9
  18. package/dist/esm-node/waterfall/async.js +3 -2
  19. package/dist/esm-node/workflow/async.js +6 -5
  20. package/dist/esm-node/workflow/parallel.js +1 -1
  21. package/dist/types/farrow-pipeline/context.d.ts +0 -1
  22. package/dist/types/farrow-pipeline/index.d.ts +25 -1
  23. package/package.json +3 -3
  24. package/dist/cjs/farrow-pipeline/pipeline.js +0 -86
  25. package/dist/esm/farrow-pipeline/context.js +0 -31
  26. package/dist/esm/farrow-pipeline/counter.js +0 -17
  27. package/dist/esm/farrow-pipeline/index.js +0 -1
  28. package/dist/esm/farrow-pipeline/pipeline.js +0 -112
  29. package/dist/esm/manager/async.js +0 -306
  30. package/dist/esm/manager/index.js +0 -3
  31. package/dist/esm/manager/shared.js +0 -35
  32. package/dist/esm/manager/sync.js +0 -226
  33. package/dist/esm/manager/types.js +0 -1
  34. package/dist/esm/utils/pluginDagSort.js +0 -70
  35. package/dist/esm/waterfall/async.js +0 -271
  36. package/dist/esm/waterfall/index.js +0 -2
  37. package/dist/esm/waterfall/sync.js +0 -127
  38. package/dist/esm/workflow/async.js +0 -293
  39. package/dist/esm/workflow/index.js +0 -3
  40. package/dist/esm/workflow/parallel.js +0 -249
  41. package/dist/esm/workflow/sync.js +0 -114
  42. package/dist/esm-node/farrow-pipeline/pipeline.js +0 -60
  43. package/dist/types/farrow-pipeline/pipeline.d.ts +0 -29
package/dist/esm/index.js CHANGED
@@ -1,4 +1,743 @@
1
- export * from "./farrow-pipeline";
2
- export * from "./waterfall";
3
- export * from "./workflow";
4
- export * from "./manager";
1
+ // src/farrow-pipeline/context.ts
2
+ function _arrayLikeToArray(arr, len) {
3
+ if (len == null || len > arr.length) len = arr.length;
4
+ for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
5
+ return arr2;
6
+ }
7
+ function _arrayWithoutHoles(arr) {
8
+ if (Array.isArray(arr)) return _arrayLikeToArray(arr);
9
+ }
10
+ function _defineProperty(obj, key, value) {
11
+ if (key in obj) {
12
+ Object.defineProperty(obj, key, {
13
+ value: value,
14
+ enumerable: true,
15
+ configurable: true,
16
+ writable: true
17
+ });
18
+ } else {
19
+ obj[key] = value;
20
+ }
21
+ return obj;
22
+ }
23
+ function _iterableToArray(iter) {
24
+ if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
25
+ }
26
+ function _nonIterableSpread() {
27
+ throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
28
+ }
29
+ function _objectSpread(target) {
30
+ for(var i = 1; i < arguments.length; i++){
31
+ var source = arguments[i] != null ? arguments[i] : {};
32
+ var ownKeys = Object.keys(source);
33
+ if (typeof Object.getOwnPropertySymbols === "function") {
34
+ ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
35
+ return Object.getOwnPropertyDescriptor(source, sym).enumerable;
36
+ }));
37
+ }
38
+ ownKeys.forEach(function(key) {
39
+ _defineProperty(target, key, source[key]);
40
+ });
41
+ }
42
+ return target;
43
+ }
44
+ function ownKeys(object, enumerableOnly) {
45
+ var keys = Object.keys(object);
46
+ if (Object.getOwnPropertySymbols) {
47
+ var symbols = Object.getOwnPropertySymbols(object);
48
+ if (enumerableOnly) {
49
+ symbols = symbols.filter(function(sym) {
50
+ return Object.getOwnPropertyDescriptor(object, sym).enumerable;
51
+ });
52
+ }
53
+ keys.push.apply(keys, symbols);
54
+ }
55
+ return keys;
56
+ }
57
+ function _objectSpreadProps(target, source) {
58
+ source = source != null ? source : {};
59
+ if (Object.getOwnPropertyDescriptors) {
60
+ Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
61
+ } else {
62
+ ownKeys(Object(source)).forEach(function(key) {
63
+ Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
64
+ });
65
+ }
66
+ return target;
67
+ }
68
+ function _toConsumableArray(arr) {
69
+ return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
70
+ }
71
+ function _unsupportedIterableToArray(o, minLen) {
72
+ if (!o) return;
73
+ if (typeof o === "string") return _arrayLikeToArray(o, minLen);
74
+ var n = Object.prototype.toString.call(o).slice(8, -1);
75
+ if (n === "Object" && o.constructor) n = o.constructor.name;
76
+ if (n === "Map" || n === "Set") return Array.from(n);
77
+ if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
78
+ }
79
+ var createContext = function(value) {
80
+ var currentValue = value;
81
+ return {
82
+ use: function() {
83
+ return {
84
+ get value () {
85
+ return currentValue;
86
+ },
87
+ set value (v){
88
+ currentValue = v;
89
+ }
90
+ };
91
+ },
92
+ get: function() {
93
+ return currentValue;
94
+ },
95
+ set: function(v1) {
96
+ currentValue = v1;
97
+ }
98
+ };
99
+ };
100
+ // src/farrow-pipeline/counter.ts
101
+ var createCounter = function(callback) {
102
+ var dispatch = function(index, input) {
103
+ var next = function() {
104
+ var nextInput = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : input;
105
+ return dispatch(index + 1, nextInput);
106
+ };
107
+ return callback(index, input, next);
108
+ };
109
+ return {
110
+ start: function(input) {
111
+ return dispatch(0, input);
112
+ },
113
+ dispatch: dispatch
114
+ };
115
+ };
116
+ // src/farrow-pipeline/index.ts
117
+ var isPipeline = function(input) {
118
+ return Boolean(input === null || input === void 0 ? void 0 : input[PipelineSymbol]);
119
+ };
120
+ var PipelineSymbol = Symbol.for("MODERN_PIPELINE");
121
+ var getMiddleware = function(input) {
122
+ if (typeof input === "function") {
123
+ return input;
124
+ } else if (input && typeof input.middleware === "function") {
125
+ return input.middleware;
126
+ }
127
+ throw new Error("".concat(input, " is not a Middleware"));
128
+ };
129
+ var createPipeline = function() {
130
+ var middlewares = [];
131
+ var use = function() {
132
+ for(var _len = arguments.length, inputs = new Array(_len), _key = 0; _key < _len; _key++){
133
+ inputs[_key] = arguments[_key];
134
+ }
135
+ var _middlewares;
136
+ (_middlewares = middlewares).push.apply(_middlewares, _toConsumableArray(inputs.map(getMiddleware)));
137
+ return pipeline;
138
+ };
139
+ var createCurrentCounter = function(onLast) {
140
+ return createCounter(function(index, input, next) {
141
+ if (index >= middlewares.length) {
142
+ if (onLast) {
143
+ return onLast(input);
144
+ }
145
+ throw new Error("Expect returning a value, but all middlewares just calling next()");
146
+ }
147
+ return middlewares[index](input, next);
148
+ });
149
+ };
150
+ var currentCounter = createCurrentCounter();
151
+ var getCounter = function(options) {
152
+ if (!options) {
153
+ return currentCounter;
154
+ }
155
+ return createCurrentCounter(options === null || options === void 0 ? void 0 : options.onLast);
156
+ };
157
+ var run = function(input, options) {
158
+ return getCounter(options).start(input);
159
+ };
160
+ var middleware = function(input, next) {
161
+ return run(input, {
162
+ onLast: next
163
+ });
164
+ };
165
+ var _obj;
166
+ var pipeline = (_obj = {}, _defineProperty(_obj, PipelineSymbol, true), _defineProperty(_obj, "use", use), _defineProperty(_obj, "run", run), _defineProperty(_obj, "middleware", middleware), _obj);
167
+ return pipeline;
168
+ };
169
+ var createAsyncPipeline = function() {
170
+ var pipeline = createPipeline();
171
+ return _objectSpread({}, pipeline);
172
+ };
173
+ // src/waterfall/sync.ts
174
+ var WATERFALL_SYMBOL = Symbol.for("MODERN_WATERFALL");
175
+ var getBrook = function(input) {
176
+ if (typeof input === "function") {
177
+ return input;
178
+ } else if (input && typeof input.middleware === "function") {
179
+ return input.middleware;
180
+ }
181
+ throw new Error("".concat(input, " is not a Brook or { brook: Brook }"));
182
+ };
183
+ var createWaterfall = function() {
184
+ var pipeline = createPipeline();
185
+ var use = function() {
186
+ for(var _len = arguments.length, brooks = new Array(_len), _key = 0; _key < _len; _key++){
187
+ brooks[_key] = arguments[_key];
188
+ }
189
+ var _pipeline;
190
+ (_pipeline = pipeline).use.apply(_pipeline, _toConsumableArray(brooks.map(getBrook).map(mapBrookToMiddleware)));
191
+ return waterfall;
192
+ };
193
+ var run = function(input, options) {
194
+ return pipeline.run(input, _objectSpreadProps(_objectSpread({}, options), {
195
+ onLast: function(input2) {
196
+ return input2;
197
+ }
198
+ }));
199
+ };
200
+ var middleware = function(input) {
201
+ return pipeline.run(input, {
202
+ onLast: function(input2) {
203
+ return input2;
204
+ }
205
+ });
206
+ };
207
+ var waterfall = _objectSpreadProps(_objectSpread({}, pipeline), _defineProperty({
208
+ use: use,
209
+ run: run,
210
+ middleware: middleware
211
+ }, WATERFALL_SYMBOL, true));
212
+ return waterfall;
213
+ };
214
+ var isWaterfall = function(input) {
215
+ return Boolean(input === null || input === void 0 ? void 0 : input[WATERFALL_SYMBOL]);
216
+ };
217
+ var mapBrookToMiddleware = function(brook) {
218
+ return function(input, next) {
219
+ return next(brook(input));
220
+ };
221
+ };
222
+ // src/waterfall/async.ts
223
+ var ASYNC_WATERFALL_SYMBOL = Symbol.for("MODERN_ASYNC_WATERFALL");
224
+ var getAsyncBrook = function(input) {
225
+ if (typeof input === "function") {
226
+ return input;
227
+ }
228
+ if (input && typeof input.middleware === "function") {
229
+ return input.middleware;
230
+ }
231
+ throw new Error("".concat(input, " is not a AsyncBrook or { brook: AsyncBrook }"));
232
+ };
233
+ var createAsyncWaterfall = function() {
234
+ var pipeline = createAsyncPipeline();
235
+ var use = function() {
236
+ for(var _len = arguments.length, input = new Array(_len), _key = 0; _key < _len; _key++){
237
+ input[_key] = arguments[_key];
238
+ }
239
+ var _pipeline;
240
+ (_pipeline = pipeline).use.apply(_pipeline, _toConsumableArray(input.map(getAsyncBrook).map(mapAsyncBrookToAsyncMiddleware)));
241
+ return waterfall;
242
+ };
243
+ var run = function(input, options) {
244
+ return pipeline.run(input, _objectSpreadProps(_objectSpread({}, options), {
245
+ onLast: function(input2) {
246
+ return input2;
247
+ }
248
+ }));
249
+ };
250
+ var middleware = function(input) {
251
+ return pipeline.run(input, {
252
+ onLast: function(input2) {
253
+ return input2;
254
+ }
255
+ });
256
+ };
257
+ var waterfall = _objectSpreadProps(_objectSpread({}, pipeline), _defineProperty({
258
+ use: use,
259
+ run: run,
260
+ middleware: middleware
261
+ }, ASYNC_WATERFALL_SYMBOL, true));
262
+ return waterfall;
263
+ };
264
+ var isAsyncWaterfall = function(input) {
265
+ return Boolean(input === null || input === void 0 ? void 0 : input[ASYNC_WATERFALL_SYMBOL]);
266
+ };
267
+ var mapAsyncBrookToAsyncMiddleware = function(brook) {
268
+ return function(input, next) {
269
+ return Promise.resolve(brook(input)).then(function(result) {
270
+ return next(result);
271
+ });
272
+ };
273
+ };
274
+ // src/workflow/sync.ts
275
+ var WORKFLOW_SYMBOL = Symbol.for("MODERN_WORKFLOW");
276
+ var createWorkflow = function() {
277
+ var pipeline = createPipeline();
278
+ var use = function() {
279
+ for(var _len = arguments.length, input = new Array(_len), _key = 0; _key < _len; _key++){
280
+ input[_key] = arguments[_key];
281
+ }
282
+ var _pipeline;
283
+ (_pipeline = pipeline).use.apply(_pipeline, _toConsumableArray(input.map(mapWorkerToMiddleware)));
284
+ return workflow;
285
+ };
286
+ var run = function(input) {
287
+ var result = pipeline.run(input, {
288
+ onLast: function() {
289
+ return [];
290
+ }
291
+ });
292
+ return result.filter(Boolean);
293
+ };
294
+ var workflow = _objectSpreadProps(_objectSpread({}, pipeline), _defineProperty({
295
+ use: use,
296
+ run: run
297
+ }, WORKFLOW_SYMBOL, true));
298
+ return workflow;
299
+ };
300
+ var isWorkflow = function(input) {
301
+ return Boolean(input === null || input === void 0 ? void 0 : input[WORKFLOW_SYMBOL]);
302
+ };
303
+ var mapWorkerToMiddleware = function(worker) {
304
+ return function(input, next) {
305
+ return [
306
+ worker(input)
307
+ ].concat(_toConsumableArray(next(input)));
308
+ };
309
+ };
310
+ // src/workflow/parallel.ts
311
+ var PARALLEL_WORKFLOW_SYMBOL = Symbol.for("MODERN_PARALLEL_WORKFLOW");
312
+ var isParallelWorkflow = function(input) {
313
+ return Boolean(input === null || input === void 0 ? void 0 : input[PARALLEL_WORKFLOW_SYMBOL]);
314
+ };
315
+ var createParallelWorkflow = function() {
316
+ var pipeline = createPipeline();
317
+ var use = function() {
318
+ for(var _len = arguments.length, input = new Array(_len), _key = 0; _key < _len; _key++){
319
+ input[_key] = arguments[_key];
320
+ }
321
+ var _pipeline;
322
+ (_pipeline = pipeline).use.apply(_pipeline, _toConsumableArray(input.map(mapParallelWorkerToAsyncMiddleware)));
323
+ return workflow;
324
+ };
325
+ var run = function(input) {
326
+ return Promise.all(pipeline.run(input, {
327
+ onLast: function() {
328
+ return [];
329
+ }
330
+ })).then(function(result) {
331
+ return result.filter(Boolean);
332
+ });
333
+ };
334
+ var workflow = _objectSpreadProps(_objectSpread({}, pipeline), _defineProperty({
335
+ run: run,
336
+ use: use
337
+ }, PARALLEL_WORKFLOW_SYMBOL, true));
338
+ return workflow;
339
+ };
340
+ var mapParallelWorkerToAsyncMiddleware = function(worker) {
341
+ return function(input, next) {
342
+ return [
343
+ worker(input)
344
+ ].concat(_toConsumableArray(next(input)));
345
+ };
346
+ };
347
+ // src/workflow/async.ts
348
+ var ASYNC_WORKFLOW_SYMBOL = Symbol.for("MODERN_ASYNC_WORKFLOW");
349
+ var isAsyncWorkflow = function(input) {
350
+ return Boolean(input === null || input === void 0 ? void 0 : input[ASYNC_WORKFLOW_SYMBOL]);
351
+ };
352
+ var createAsyncWorkflow = function() {
353
+ var pipeline = createAsyncPipeline();
354
+ var use = function() {
355
+ for(var _len = arguments.length, input = new Array(_len), _key = 0; _key < _len; _key++){
356
+ input[_key] = arguments[_key];
357
+ }
358
+ var _pipeline;
359
+ (_pipeline = pipeline).use.apply(_pipeline, _toConsumableArray(input.map(mapAsyncWorkerToAsyncMiddleware)));
360
+ return workflow;
361
+ };
362
+ var run = function(input) {
363
+ var result = pipeline.run(input, {
364
+ onLast: function() {
365
+ return [];
366
+ }
367
+ });
368
+ if (isPromise(result)) {
369
+ return result.then(function(result2) {
370
+ return result2.filter(Boolean);
371
+ });
372
+ }
373
+ return result.filter(Boolean);
374
+ };
375
+ var workflow = _objectSpreadProps(_objectSpread({}, pipeline), _defineProperty({
376
+ use: use,
377
+ run: run
378
+ }, ASYNC_WORKFLOW_SYMBOL, true));
379
+ return workflow;
380
+ };
381
+ var mapAsyncWorkerToAsyncMiddleware = function(worker) {
382
+ return function(input, next) {
383
+ return Promise.resolve(worker(input)).then(function(result) {
384
+ return Promise.resolve(next(input)).then(function(nextResult) {
385
+ return [
386
+ result
387
+ ].concat(_toConsumableArray(nextResult));
388
+ });
389
+ });
390
+ };
391
+ };
392
+ function isPromise(obj) {
393
+ return obj && typeof obj.then === "function";
394
+ }
395
+ // src/utils/pluginDagSort.ts
396
+ var dagSort = function(plugins) {
397
+ var _loop = function() {
398
+ var zep = zeroEndPoints.shift();
399
+ sortedPoint.push(getPluginByAny(zep));
400
+ allLines = allLines.filter(function(l) {
401
+ return l[0] !== getPluginByAny(zep)[key];
402
+ });
403
+ var restPoints = plugins.filter(function(item) {
404
+ return !sortedPoint.find(function(sp) {
405
+ return sp[key] === item[key];
406
+ });
407
+ });
408
+ zeroEndPoints = restPoints.filter(// eslint-disable-next-line @typescript-eslint/no-loop-func
409
+ function(item) {
410
+ return !allLines.find(function(l) {
411
+ return l[1] === item[key];
412
+ });
413
+ });
414
+ };
415
+ var key = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "name", preKey = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : "pre", postKey = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : "post";
416
+ var getPluginByAny = function getPluginByAny(q) {
417
+ var target = plugins.find(function(item) {
418
+ return typeof q === "string" ? item[key] === q : item[key] === q[key];
419
+ });
420
+ if (!target) {
421
+ throw new Error("plugin ".concat(q, " not existed"));
422
+ }
423
+ return target;
424
+ };
425
+ var allLines = [];
426
+ plugins.forEach(function(item) {
427
+ item[preKey].forEach(function(p) {
428
+ if (plugins.find(function(ap) {
429
+ return ap.name === p;
430
+ })) {
431
+ allLines.push([
432
+ getPluginByAny(p)[key],
433
+ getPluginByAny(item)[key]
434
+ ]);
435
+ }
436
+ });
437
+ item[postKey].forEach(function(pt) {
438
+ if (plugins.find(function(ap) {
439
+ return ap.name === pt;
440
+ })) {
441
+ allLines.push([
442
+ getPluginByAny(item)[key],
443
+ getPluginByAny(pt)[key]
444
+ ]);
445
+ }
446
+ });
447
+ });
448
+ var zeroEndPoints = plugins.filter(function(item) {
449
+ return !allLines.find(function(l) {
450
+ return l[1] === item[key];
451
+ });
452
+ });
453
+ var sortedPoint = [];
454
+ while(zeroEndPoints.length)_loop();
455
+ if (allLines.length) {
456
+ var restInRingPoints = {};
457
+ allLines.forEach(function(l) {
458
+ restInRingPoints[l[0]] = true;
459
+ restInRingPoints[l[1]] = true;
460
+ });
461
+ throw new Error("plugins dependences has loop: ".concat(Object.keys(restInRingPoints).join(",")));
462
+ }
463
+ return sortedPoint;
464
+ };
465
+ // src/manager/shared.ts
466
+ var checkPlugins = function(plugins) {
467
+ if (process.env.NODE_ENV !== "production") {
468
+ plugins.forEach(function(origin) {
469
+ origin.rivals.forEach(function(rival) {
470
+ plugins.forEach(function(plugin) {
471
+ if (rival === plugin.name) {
472
+ throw new Error("".concat(origin.name, " has rival ").concat(plugin.name));
473
+ }
474
+ });
475
+ });
476
+ origin.required.forEach(function(required) {
477
+ if (!plugins.some(function(plugin) {
478
+ return plugin.name === required;
479
+ })) {
480
+ throw new Error("The plugin: ".concat(required, " is required when plugin: ").concat(origin.name, " is exist."));
481
+ }
482
+ });
483
+ });
484
+ }
485
+ };
486
+ function sortPlugins(input) {
487
+ return dagSort(input.slice());
488
+ }
489
+ var includePlugin = function(plugins, input) {
490
+ return plugins.some(function(plugin) {
491
+ return plugin.name === input.name;
492
+ });
493
+ };
494
+ var isObject = function(obj) {
495
+ return obj !== null && typeof obj === "object";
496
+ };
497
+ var hasOwnProperty = function(obj, prop) {
498
+ return obj.hasOwnProperty(prop);
499
+ };
500
+ // src/manager/sync.ts
501
+ var SYNC_PLUGIN_SYMBOL = "SYNC_PLUGIN_SYMBOL";
502
+ var DEFAULT_OPTIONS = {
503
+ name: "untitled",
504
+ pre: [],
505
+ post: [],
506
+ rivals: [],
507
+ required: [],
508
+ usePlugins: [],
509
+ registerHook: {}
510
+ };
511
+ var createManager = function(hooks, api) {
512
+ var index = 0;
513
+ var runners;
514
+ var currentHooks = _objectSpread({}, hooks);
515
+ var useRunner = function() {
516
+ return runners;
517
+ };
518
+ var registerHook = function(extraHooks) {
519
+ currentHooks = _objectSpread({}, extraHooks, currentHooks);
520
+ };
521
+ var isPlugin = function(input) {
522
+ return isObject(input) && hasOwnProperty(input, SYNC_PLUGIN_SYMBOL) && input[SYNC_PLUGIN_SYMBOL] === SYNC_PLUGIN_SYMBOL;
523
+ };
524
+ var pluginAPI = _objectSpreadProps(_objectSpread({}, api), {
525
+ useHookRunners: useRunner
526
+ });
527
+ var clone = function(overrideAPI) {
528
+ var plugins = [];
529
+ var addPlugin = function(plugin) {
530
+ if (!includePlugin(plugins, plugin)) {
531
+ plugins.push(_objectSpread({}, plugin));
532
+ }
533
+ };
534
+ var usePlugin = function() {
535
+ for(var _len = arguments.length, input = new Array(_len), _key = 0; _key < _len; _key++){
536
+ input[_key] = arguments[_key];
537
+ }
538
+ input.forEach(function(plugin) {
539
+ if (isPlugin(plugin)) {
540
+ addPlugin(plugin);
541
+ } else if (typeof plugin === "function") {
542
+ var options = plugin();
543
+ addPlugin(createPlugin(options.setup, options));
544
+ } else if (isObject(plugin)) {
545
+ addPlugin(createPlugin(plugin.setup, plugin));
546
+ } else if (process.env.NODE_ENV !== "production") {
547
+ console.warn("Unknown plugin: ".concat(JSON.stringify(plugin)));
548
+ }
549
+ });
550
+ return manager;
551
+ };
552
+ var createPlugin = function() {
553
+ var setup = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : function() {}, options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
554
+ var _options_usePlugins;
555
+ if ((_options_usePlugins = options.usePlugins) === null || _options_usePlugins === void 0 ? void 0 : _options_usePlugins.length) {
556
+ options.usePlugins.forEach(function(plugin) {
557
+ usePlugin(createPlugin(plugin.setup, plugin));
558
+ });
559
+ }
560
+ if (options.registerHook) {
561
+ registerHook(options.registerHook);
562
+ }
563
+ return _objectSpreadProps(_objectSpread(_objectSpreadProps(_objectSpread({}, DEFAULT_OPTIONS), {
564
+ name: "No.".concat(index++, " plugin")
565
+ }), options), {
566
+ SYNC_PLUGIN_SYMBOL: SYNC_PLUGIN_SYMBOL,
567
+ setup: setup
568
+ });
569
+ };
570
+ var clear = function() {
571
+ plugins = [];
572
+ };
573
+ var init = function() {
574
+ var sortedPlugins = sortPlugins(plugins);
575
+ var mergedPluginAPI = _objectSpread({}, pluginAPI, overrideAPI);
576
+ checkPlugins(sortedPlugins);
577
+ var hooksList = sortedPlugins.map(function(plugin) {
578
+ return plugin.setup(mergedPluginAPI);
579
+ });
580
+ runners = generateRunner(hooksList, currentHooks);
581
+ return runners;
582
+ };
583
+ var run = function(cb) {
584
+ return cb();
585
+ };
586
+ var manager = {
587
+ createPlugin: createPlugin,
588
+ isPlugin: isPlugin,
589
+ usePlugin: usePlugin,
590
+ init: init,
591
+ clear: clear,
592
+ run: run,
593
+ registerHook: registerHook,
594
+ useRunner: useRunner,
595
+ clone: clone
596
+ };
597
+ return manager;
598
+ };
599
+ return clone();
600
+ };
601
+ var generateRunner = function(hooksList, hooksMap) {
602
+ var runner = {};
603
+ var cloneShape = cloneHooksMap(hooksMap);
604
+ if (hooksMap) {
605
+ var _loop = function(key) {
606
+ hooksList.forEach(function(hooks) {
607
+ if (hooks === null || hooks === void 0 ? void 0 : hooks[key]) {
608
+ cloneShape[key].use(hooks[key]);
609
+ }
610
+ });
611
+ runner[key] = function(input, options) {
612
+ return cloneShape[key].run(input, _objectSpread({}, options));
613
+ };
614
+ };
615
+ for(var key in cloneShape)_loop(key);
616
+ }
617
+ return runner;
618
+ };
619
+ var cloneHook = function(hook) {
620
+ if (isWaterfall(hook)) {
621
+ return createWaterfall();
622
+ }
623
+ if (isAsyncWaterfall(hook)) {
624
+ return createAsyncWaterfall();
625
+ }
626
+ if (isWorkflow(hook)) {
627
+ return createWorkflow();
628
+ }
629
+ if (isAsyncWorkflow(hook)) {
630
+ return createAsyncWorkflow();
631
+ }
632
+ if (isParallelWorkflow(hook)) {
633
+ return createParallelWorkflow();
634
+ }
635
+ if (isPipeline(hook)) {
636
+ return createPipeline();
637
+ }
638
+ throw new Error("Unknown hook: ".concat(hook));
639
+ };
640
+ var cloneHooksMap = function(record) {
641
+ if (!record) {
642
+ return record;
643
+ }
644
+ var result = {};
645
+ for(var key in record){
646
+ result[key] = cloneHook(record[key]);
647
+ }
648
+ return result;
649
+ };
650
+ // src/manager/async.ts
651
+ var ASYNC_PLUGIN_SYMBOL = "ASYNC_PLUGIN_SYMBOL";
652
+ var createAsyncManager = function(hooks, api) {
653
+ var index = 0;
654
+ var runners;
655
+ var currentHooks = _objectSpread({}, hooks);
656
+ var useRunner = function() {
657
+ return runners;
658
+ };
659
+ var registerHook = function(extraHooks) {
660
+ currentHooks = _objectSpread({}, extraHooks, currentHooks);
661
+ };
662
+ var isPlugin = function(input) {
663
+ return isObject(input) && hasOwnProperty(input, ASYNC_PLUGIN_SYMBOL) && input[ASYNC_PLUGIN_SYMBOL] === ASYNC_PLUGIN_SYMBOL;
664
+ };
665
+ var pluginAPI = _objectSpreadProps(_objectSpread({}, api), {
666
+ useHookRunners: useRunner
667
+ });
668
+ var clone = function(overrideAPI) {
669
+ var plugins = [];
670
+ var addPlugin = function(plugin) {
671
+ if (!includePlugin(plugins, plugin)) {
672
+ plugins.push(_objectSpread({}, plugin));
673
+ }
674
+ };
675
+ var usePlugin = function() {
676
+ for(var _len = arguments.length, input = new Array(_len), _key = 0; _key < _len; _key++){
677
+ input[_key] = arguments[_key];
678
+ }
679
+ input.forEach(function(plugin) {
680
+ if (isPlugin(plugin)) {
681
+ addPlugin(plugin);
682
+ } else if (typeof plugin === "function") {
683
+ var options = plugin();
684
+ addPlugin(createPlugin(options.setup, options));
685
+ } else if (isObject(plugin)) {
686
+ addPlugin(createPlugin(plugin.setup, plugin));
687
+ } else if (process.env.NODE_ENV !== "production") {
688
+ console.warn("Unknown plugin: ".concat(JSON.stringify(plugin)));
689
+ }
690
+ });
691
+ return manager;
692
+ };
693
+ var createPlugin = function() {
694
+ var setup = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : function() {}, options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
695
+ var _options_usePlugins;
696
+ if ((_options_usePlugins = options.usePlugins) === null || _options_usePlugins === void 0 ? void 0 : _options_usePlugins.length) {
697
+ options.usePlugins.forEach(function(plugin) {
698
+ usePlugin(createPlugin(plugin.setup, plugin));
699
+ });
700
+ }
701
+ if (options.registerHook) {
702
+ registerHook(options.registerHook);
703
+ }
704
+ return _objectSpreadProps(_objectSpread(_objectSpreadProps(_objectSpread({}, DEFAULT_OPTIONS), {
705
+ name: "No.".concat(index++, " plugin")
706
+ }), options), {
707
+ ASYNC_PLUGIN_SYMBOL: ASYNC_PLUGIN_SYMBOL,
708
+ setup: setup
709
+ });
710
+ };
711
+ var clear = function() {
712
+ plugins = [];
713
+ };
714
+ var init = function() {
715
+ var sortedPlugins = sortPlugins(plugins);
716
+ var mergedPluginAPI = _objectSpread({}, pluginAPI, overrideAPI);
717
+ checkPlugins(sortedPlugins);
718
+ return Promise.all(sortedPlugins.map(function(plugin) {
719
+ return plugin.setup(mergedPluginAPI);
720
+ })).then(function(hooksList) {
721
+ runners = generateRunner(hooksList, currentHooks);
722
+ return runners;
723
+ });
724
+ };
725
+ var run = function(cb) {
726
+ return cb();
727
+ };
728
+ var manager = {
729
+ createPlugin: createPlugin,
730
+ isPlugin: isPlugin,
731
+ usePlugin: usePlugin,
732
+ init: init,
733
+ run: run,
734
+ clear: clear,
735
+ clone: clone,
736
+ registerHook: registerHook,
737
+ useRunner: useRunner
738
+ };
739
+ return manager;
740
+ };
741
+ return clone();
742
+ };
743
+ export { DEFAULT_OPTIONS, cloneHook, cloneHooksMap, createAsyncManager, createAsyncPipeline, createAsyncWaterfall, createAsyncWorkflow, createContext, createManager, createParallelWorkflow, createPipeline, createWaterfall, createWorkflow, generateRunner, getAsyncBrook, getBrook, isAsyncWaterfall, isAsyncWorkflow, isParallelWorkflow, isPipeline, isWaterfall, isWorkflow };