@modern-js/plugin 1.21.5 → 2.0.0-beta.1

package/dist/js/treeshaking/manager/shared.js

@@ -1,6 +1,5 @@
 import _typeof from "@babel/runtime/helpers/esm/typeof";
-import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
-import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+import { dagSort } from "../utils/pluginDagSort";
 export var checkPlugins = function checkPlugins(plugins) {
   plugins.forEach(function (origin) {
     origin.rivals.forEach(function (rival) {
@@ -21,50 +20,7 @@ export var checkPlugins = function checkPlugins(plugins) {
 };
 export function sortPlugins(input) {
   var plugins = input.slice();
-
-  for (var i = 0; i < plugins.length; i++) {
-    var plugin = plugins[i];
-
-    var _iterator = _createForOfIteratorHelper(plugin.pre),
-        _step;
-
-    try {
-      for (_iterator.s(); !(_step = _iterator.n()).done;) {
-        var pre = _step.value;
-
-        for (var j = i + 1; j < plugins.length; j++) {
-          if (plugins[j].name === pre) {
-            plugins = [].concat(_toConsumableArray(plugins.slice(0, i)), [plugins[j]], _toConsumableArray(plugins.slice(i, j)), _toConsumableArray(plugins.slice(j + 1, plugins.length)));
-          }
-        }
-      }
-    } catch (err) {
-      _iterator.e(err);
-    } finally {
-      _iterator.f();
-    }
-
-    var _iterator2 = _createForOfIteratorHelper(plugin.post),
-        _step2;
-
-    try {
-      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-        var post = _step2.value;
-
-        for (var _j = 0; _j < i; _j++) {
-          if (plugins[_j].name === post) {
-            plugins = [].concat(_toConsumableArray(plugins.slice(0, _j)), _toConsumableArray(plugins.slice(_j + 1, i + 1)), [plugins[_j]], _toConsumableArray(plugins.slice(i + 1, plugins.length)));
-          }
-        }
-      }
-    } catch (err) {
-      _iterator2.e(err);
-    } finally {
-      _iterator2.f();
-    }
-  }
-
-  return plugins;
+  return dagSort(plugins);
 }
 export var includePlugin = function includePlugin(plugins, input) {
   return plugins.some(function (plugin) {

package/dist/js/treeshaking/manager/sync.js

@@ -17,75 +17,63 @@ export var DEFAULT_OPTIONS = {
 export var createManager = function createManager(hooks, api) {
   var index = 0;
   var runners;
-
   var currentHooks = _objectSpread({}, hooks);
-
   var useRunner = function useRunner() {
     return runners;
   };
-
   var registerHook = function registerHook(extraHooks) {
     currentHooks = _objectSpread(_objectSpread({}, extraHooks), currentHooks);
   };
-
   var isPlugin = function isPlugin(input) {
     return isObject(input) && hasOwnProperty(input, SYNC_PLUGIN_SYMBOL) && input[SYNC_PLUGIN_SYMBOL] === SYNC_PLUGIN_SYMBOL;
   };
-
   var pluginAPI = _objectSpread(_objectSpread({}, api), {}, {
     useHookRunners: useRunner
   });
-
   var clone = function clone(overrideAPI) {
     var plugins = [];
-
     var addPlugin = function addPlugin(plugin) {
       if (!includePlugin(plugins, plugin)) {
         plugins.push(_objectSpread({}, plugin));
       }
     };
-
     var usePlugin = function usePlugin() {
       for (var _len = arguments.length, input = new Array(_len), _key = 0; _key < _len; _key++) {
         input[_key] = arguments[_key];
       }
-
       input.forEach(function (plugin) {
         // already created by createPlugin
         if (isPlugin(plugin)) {
           addPlugin(plugin);
-        } // using function to return plugin options
+        }
+        // using function to return plugin options
         else if (typeof plugin === 'function') {
           var _options = plugin();
-
           addPlugin(createPlugin(_options.setup, _options));
-        } // plain plugin object
+        }
+        // plain plugin object
         else if (isObject(plugin)) {
           addPlugin(createPlugin(plugin.setup, plugin));
-        } // unknown plugin
+        }
+        // unknown plugin
         else {
           console.warn("Unknown plugin: ".concat(JSON.stringify(plugin)));
         }
       });
       return manager;
     };
-
     var createPlugin = function createPlugin() {
       var _options$usePlugins;
-
       var setup = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : function () {};
       var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-
       if ((_options$usePlugins = options.usePlugins) !== null && _options$usePlugins !== void 0 && _options$usePlugins.length) {
         options.usePlugins.forEach(function (plugin) {
           usePlugin(createPlugin(plugin.setup, plugin));
         });
       }
-
       if (options.registerHook) {
         registerHook(options.registerHook);
       }
-
       return _objectSpread(_objectSpread(_objectSpread({}, DEFAULT_OPTIONS), {}, {
         name: "No.".concat(index++, " plugin")
       }, options), {}, {
@@ -93,16 +81,12 @@ export var createManager = function createManager(hooks, api) {
         setup: setup
       });
     };
-
     var clear = function clear() {
       plugins = [];
     };
-
     var init = function init() {
       var sortedPlugins = sortPlugins(plugins);
-
       var mergedPluginAPI = _objectSpread(_objectSpread({}, pluginAPI), overrideAPI);
-
       checkPlugins(sortedPlugins);
       var hooksList = sortedPlugins.map(function (plugin) {
         return plugin.setup(mergedPluginAPI);
@@ -110,11 +94,9 @@ export var createManager = function createManager(hooks, api) {
       runners = generateRunner(hooksList, currentHooks);
       return runners;
     };
-
     var run = function run(cb) {
       return cb();
     };
-
     var manager = {
       createPlugin: createPlugin,
       isPlugin: isPlugin,
@@ -128,89 +110,72 @@ export var createManager = function createManager(hooks, api) {
     };
     return manager;
   };
-
   return clone();
 };
 export var generateRunner = function generateRunner(hooksList, hooksMap) {
   var runner = {};
   var cloneShape = cloneHooksMap(hooksMap);
-
   if (hooksMap) {
     var _loop = function _loop(key) {
       var _iterator = _createForOfIteratorHelper(hooksList),
-          _step;
-
+        _step;
       try {
         for (_iterator.s(); !(_step = _iterator.n()).done;) {
           var hooks = _step.value;
-
           if (!hooks) {
             continue;
           }
-
           if (hooks[key]) {
             cloneShape[key].use(hooks[key]);
           }
-        } // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        }
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
         // @ts-expect-error
-
       } catch (err) {
         _iterator.e(err);
       } finally {
         _iterator.f();
       }
-
       runner[key] = function (input, options) {
         return cloneShape[key].run(input, _objectSpread({}, options));
       };
     };
-
     for (var key in cloneShape) {
       _loop(key);
     }
   }
-
   return runner;
 };
 export var cloneHook = function cloneHook(hook) {
   if (isWaterfall(hook)) {
     return createWaterfall();
   }
-
   if (isAsyncWaterfall(hook)) {
     return createAsyncWaterfall();
   }
-
   if (isWorkflow(hook)) {
     return createWorkflow();
   }
-
   if (isAsyncWorkflow(hook)) {
     return createAsyncWorkflow();
   }
-
   if (isParallelWorkflow(hook)) {
     return createParallelWorkflow();
   }
-
   if (isPipeline(hook)) {
     return createPipeline();
   }
-
   throw new Error("Unknown hook: ".concat(hook));
 };
 export var cloneHooksMap = function cloneHooksMap(record) {
   if (!record) {
     return record;
   }
-
   var result = {};
-
   for (var key in record) {
     // eslint-disable-next-line @typescript-eslint/ban-ts-comment
     // @ts-expect-error
     result[key] = cloneHook(record[key]);
   }
-
   return result;
 };

package/dist/js/treeshaking/utils/pluginDagSort.js

@@ -0,0 +1,74 @@
+export var dagSort = function dagSort(plugins) {
+  var key = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'name';
+  var preKey = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'pre';
+  var postKey = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'post';
+  var allLines = [];
+  function getPluginByAny(q) {
+    var target = plugins.find(function (item) {
+      return typeof q === 'string' ? item[key] === q : item[key] === q[key];
+    });
+    // current plugin design can't guarantee the plugins in pre/post existed
+    if (!target) {
+      throw new Error("plugin ".concat(q, " not existed"));
+    }
+    return target;
+  }
+  plugins.forEach(function (item) {
+    item[preKey].forEach(function (p) {
+      // compatibility: do not add the plugin-name that plugins not have
+      if (plugins.find(function (ap) {
+        return ap.name === p;
+      })) {
+        allLines.push([getPluginByAny(p)[key], getPluginByAny(item)[key]]);
+      }
+    });
+    item[postKey].forEach(function (pt) {
+      // compatibility: do not add the plugin-name that plugins not have
+      if (plugins.find(function (ap) {
+        return ap.name === pt;
+      })) {
+        allLines.push([getPluginByAny(item)[key], getPluginByAny(pt)[key]]);
+      }
+    });
+  });
+
+  // search the zero input plugin
+  var zeroEndPoints = plugins.filter(function (item) {
+    return !allLines.find(function (l) {
+      return l[1] === item[key];
+    });
+  });
+  var sortedPoint = [];
+  var _loop = function _loop() {
+    var zep = zeroEndPoints.shift();
+    sortedPoint.push(getPluginByAny(zep));
+    allLines = allLines.filter(function (l) {
+      return l[0] !== getPluginByAny(zep)[key];
+    });
+    var restPoints = plugins.filter(function (item) {
+      return !sortedPoint.find(function (sp) {
+        return sp[key] === item[key];
+      });
+    });
+    zeroEndPoints = restPoints.filter(
+    // eslint-disable-next-line @typescript-eslint/no-loop-func
+    function (item) {
+      return !allLines.find(function (l) {
+        return l[1] === item[key];
+      });
+    });
+  };
+  while (zeroEndPoints.length) {
+    _loop();
+  }
+  // if has ring, throw error
+  if (allLines.length) {
+    var restInRingPoints = {};
+    allLines.forEach(function (l) {
+      restInRingPoints[l[0]] = true;
+      restInRingPoints[l[1]] = true;
+    });
+    throw new Error("plugins dependences has loop: ".concat(Object.keys(restInRingPoints).join(',')));
+  }
+  return sortedPoint;
+};

package/dist/js/treeshaking/waterfall/async.js

@@ -11,21 +11,17 @@ export var getAsyncBrook = function getAsyncBrook(input) {
   } else if (input && typeof input.middleware === 'function') {
     return input.middleware;
   }
-
   throw new Error("".concat(input, " is not a AsyncBrook or { brook: AsyncBrook }"));
 };
 export var createAsyncWaterfall = function createAsyncWaterfall() {
   var pipeline = createAsyncPipeline();
-
   var use = function use() {
     for (var _len = arguments.length, input = new Array(_len), _key = 0; _key < _len; _key++) {
       input[_key] = arguments[_key];
     }
-
     pipeline.use.apply(pipeline, _toConsumableArray(input.map(getAsyncBrook).map(mapAsyncBrookToAsyncMiddleware)));
     return waterfall;
   };
-
   var run = function run(input, options) {
     return pipeline.run(input, _objectSpread(_objectSpread({}, options), {}, {
       onLast: function onLast(input) {
@@ -33,7 +29,6 @@ export var createAsyncWaterfall = function createAsyncWaterfall() {
       }
     }));
   };
-
   var middleware = function middleware(input) {
     return pipeline.run(input, {
       onLast: function onLast(input) {
@@ -41,19 +36,16 @@ export var createAsyncWaterfall = function createAsyncWaterfall() {
       }
     });
   };
-
   var waterfall = _objectSpread(_objectSpread({}, pipeline), {}, _defineProperty({
     use: use,
     run: run,
     middleware: middleware
   }, ASYNC_WATERFALL_SYMBOL, true));
-
   return waterfall;
 };
 export var isAsyncWaterfall = function isAsyncWaterfall(input) {
   return Boolean(input === null || input === void 0 ? void 0 : input[ASYNC_WATERFALL_SYMBOL]);
 };
-
 var mapAsyncBrookToAsyncMiddleware = function mapAsyncBrookToAsyncMiddleware(brook) {
   return /*#__PURE__*/function () {
     var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(input, next) {
@@ -64,11 +56,9 @@ var mapAsyncBrookToAsyncMiddleware = function mapAsyncBrookToAsyncMiddleware(bro
               _context.t0 = next;
               _context.next = 3;
               return brook(input);
-
             case 3:
               _context.t1 = _context.sent;
               return _context.abrupt("return", (0, _context.t0)(_context.t1));
-
             case 5:
             case "end":
               return _context.stop();
@@ -76,7 +66,6 @@ var mapAsyncBrookToAsyncMiddleware = function mapAsyncBrookToAsyncMiddleware(bro
         }
       }, _callee);
     }));
-
     return function (_x, _x2) {
       return _ref.apply(this, arguments);
     };

package/dist/js/treeshaking/waterfall/sync.js

@@ -9,21 +9,17 @@ export var getBrook = function getBrook(input) {
   } else if (input && typeof input.middleware === 'function') {
     return input.middleware;
   }
-
   throw new Error("".concat(input, " is not a Brook or { brook: Brook }"));
 };
 export var createWaterfall = function createWaterfall() {
   var pipeline = createPipeline();
-
   var use = function use() {
     for (var _len = arguments.length, brooks = new Array(_len), _key = 0; _key < _len; _key++) {
       brooks[_key] = arguments[_key];
     }
-
     pipeline.use.apply(pipeline, _toConsumableArray(brooks.map(getBrook).map(mapBrookToMiddleware)));
     return waterfall;
   };
-
   var run = function run(input, options) {
     return pipeline.run(input, _objectSpread(_objectSpread({}, options), {}, {
       onLast: function onLast(input) {
@@ -31,7 +27,6 @@ export var createWaterfall = function createWaterfall() {
       }
     }));
   };
-
   var middleware = function middleware(input) {
     return pipeline.run(input, {
       onLast: function onLast(input) {
@@ -39,19 +34,16 @@ export var createWaterfall = function createWaterfall() {
       }
     });
   };
-
   var waterfall = _objectSpread(_objectSpread({}, pipeline), {}, _defineProperty({
     use: use,
     run: run,
     middleware: middleware
   }, WATERFALL_SYMBOL, true));
-
   return waterfall;
 };
 export var isWaterfall = function isWaterfall(input) {
   return Boolean(input === null || input === void 0 ? void 0 : input[WATERFALL_SYMBOL]);
 };
-
 var mapBrookToMiddleware = function mapBrookToMiddleware(brook) {
   return function (input, next) {
     return next(brook(input));

package/dist/js/treeshaking/workflow/async.js

@@ -11,16 +11,13 @@ export var isAsyncWorkflow = function isAsyncWorkflow(input) {
 };
 export var createAsyncWorkflow = function createAsyncWorkflow() {
   var pipeline = createAsyncPipeline();
-
   var use = function use() {
     for (var _len = arguments.length, input = new Array(_len), _key = 0; _key < _len; _key++) {
       input[_key] = arguments[_key];
     }
-
     pipeline.use.apply(pipeline, _toConsumableArray(input.map(mapAsyncWorkerToAsyncMiddleware)));
     return workflow;
   };
-
   var run = /*#__PURE__*/function () {
     var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(input) {
       var result;
@@ -33,19 +30,15 @@ export var createAsyncWorkflow = function createAsyncWorkflow() {
                   return [];
                 }
               });
-
               if (!isPromise(result)) {
                 _context.next = 5;
                 break;
               }
-
               return _context.abrupt("return", result.then(function (result) {
                 return result.filter(Boolean);
               }));
-
             case 5:
               return _context.abrupt("return", result.filter(Boolean));
-
             case 6:
             case "end":
               return _context.stop();
@@ -53,20 +46,16 @@ export var createAsyncWorkflow = function createAsyncWorkflow() {
         }
       }, _callee);
     }));
-
     return function run(_x) {
       return _ref.apply(this, arguments);
     };
   }();
-
   var workflow = _objectSpread(_objectSpread({}, pipeline), {}, _defineProperty({
     use: use,
     run: run
   }, ASYNC_WORKFLOW_SYMBOL, true));
-
   return workflow;
 };
-
 var mapAsyncWorkerToAsyncMiddleware = function mapAsyncWorkerToAsyncMiddleware(worker) {
   return /*#__PURE__*/function () {
     var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(input, next) {
@@ -76,19 +65,16 @@ var mapAsyncWorkerToAsyncMiddleware = function mapAsyncWorkerToAsyncMiddleware(w
             case 0:
               _context2.next = 2;
               return worker(input);
-
             case 2:
               _context2.t1 = _context2.sent;
               _context2.t0 = [_context2.t1];
               _context2.t2 = _toConsumableArray;
               _context2.next = 7;
               return next(input);
-
             case 7:
               _context2.t3 = _context2.sent;
               _context2.t4 = (0, _context2.t2)(_context2.t3);
               return _context2.abrupt("return", _context2.t0.concat.call(_context2.t0, _context2.t4));
-
             case 10:
             case "end":
               return _context2.stop();
@@ -96,13 +82,11 @@ var mapAsyncWorkerToAsyncMiddleware = function mapAsyncWorkerToAsyncMiddleware(w
         }
       }, _callee2);
     }));
-
     return function (_x2, _x3) {
       return _ref2.apply(this, arguments);
     };
   }();
 };
-
 function isPromise(obj) {
   return Boolean(obj) && (_typeof(obj) === 'object' || typeof obj === 'function') && typeof obj.then === 'function';
 }

package/dist/js/treeshaking/workflow/parallel.js

@@ -10,16 +10,13 @@ export var isParallelWorkflow = function isParallelWorkflow(input) {
 };
 export var createParallelWorkflow = function createParallelWorkflow() {
   var pipeline = createPipeline();
-
   var use = function use() {
     for (var _len = arguments.length, input = new Array(_len), _key = 0; _key < _len; _key++) {
       input[_key] = arguments[_key];
     }
-
     pipeline.use.apply(pipeline, _toConsumableArray(input.map(mapParallelWorkerToAsyncMiddleware)));
     return workflow;
   };
-
   var run = /*#__PURE__*/function () {
     var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(input) {
       return _regeneratorRuntime().wrap(function _callee$(_context) {
@@ -33,7 +30,6 @@ export var createParallelWorkflow = function createParallelWorkflow() {
               })).then(function (result) {
                 return result.filter(Boolean);
               }));
-
             case 1:
             case "end":
               return _context.stop();
@@ -41,20 +37,16 @@ export var createParallelWorkflow = function createParallelWorkflow() {
         }
       }, _callee);
     }));
-
     return function run(_x) {
       return _ref.apply(this, arguments);
     };
   }();
-
   var workflow = _objectSpread(_objectSpread({}, pipeline), {}, _defineProperty({
     run: run,
     use: use
   }, PARALLEL_WORKFLOW_SYMBOL, true));
-
   return workflow;
 };
-
 var mapParallelWorkerToAsyncMiddleware = function mapParallelWorkerToAsyncMiddleware(worker) {
   return function (input, next) {
     return [worker(input)].concat(_toConsumableArray(next(input)));

package/dist/js/treeshaking/workflow/sync.js

@@ -5,16 +5,13 @@ import { createPipeline } from "../farrow-pipeline";
 var WORKFLOW_SYMBOL = Symbol["for"]('MODERN_WORKFLOW');
 export var createWorkflow = function createWorkflow() {
   var pipeline = createPipeline();
-
   var use = function use() {
     for (var _len = arguments.length, input = new Array(_len), _key = 0; _key < _len; _key++) {
       input[_key] = arguments[_key];
     }
-
     pipeline.use.apply(pipeline, _toConsumableArray(input.map(mapWorkerToMiddleware)));
     return workflow;
   };
-
   var run = function run(input) {
     var result = pipeline.run(input, {
       onLast: function onLast() {
@@ -23,18 +20,15 @@ export var createWorkflow = function createWorkflow() {
     });
     return result.filter(Boolean);
   };
-
   var workflow = _objectSpread(_objectSpread({}, pipeline), {}, _defineProperty({
     use: use,
     run: run
   }, WORKFLOW_SYMBOL, true));
-
   return workflow;
 };
 export var isWorkflow = function isWorkflow(input) {
   return Boolean(input === null || input === void 0 ? void 0 : input[WORKFLOW_SYMBOL]);
 };
-
 var mapWorkerToMiddleware = function mapWorkerToMiddleware(worker) {
   return function (input, next) {
     return [worker(input)].concat(_toConsumableArray(next(input)));

package/dist/types/manager/async.d.ts

@@ -1,6 +1,5 @@
 import type { ToRunners, ToThreads, CommonAPI, PluginOptions } from './types';
 /** Setup function of async plugin. */
-
 export declare type AsyncSetup<Hooks, API = Record<string, never>> = (api: API & CommonAPI<Hooks>) => Partial<ToThreads<Hooks>> | Promise<Partial<ToThreads<Hooks>> | void> | void;
 declare const ASYNC_PLUGIN_SYMBOL = "ASYNC_PLUGIN_SYMBOL";
 export declare type AsyncPlugin<Hooks, API> = {
@@ -17,46 +16,38 @@ export declare type AsyncManager<Hooks, API> = {
    * Determine if a value is a async plugin.
    * @param input
    */
-
   isPlugin: (input: unknown) => input is AsyncPlugin<Hooks, API>;
   /**
    * Register new plugins to current manager.
    * @param plugins one or more plugin.
    */
-
   usePlugin: (...plugins: Array<AsyncPlugin<Hooks, API> | PluginOptions<Hooks, AsyncSetup<Hooks, API>> | (() => PluginOptions<Hooks, AsyncSetup<Hooks, API>>)>) => AsyncManager<Hooks, API>;
   /**
    * Init manager, it will call the setup function of all registered plugins.
    */
-
   init: () => Promise<ToRunners<Hooks>>;
   /**
    * Run callback function.
    * @param callback
    */
-
   run: <O>(cb: () => O) => O;
   /**
    * Register new hooks.
    * @param newHooks
    */
-
   registerHook: (newHooks: Partial<Hooks>) => void;
   /**
    * Return a cloned manager.
    * @param overrideAPI override the default plugin API.
    */
-
   clone: (overrideAPI?: Partial<API & CommonAPI<Hooks>>) => AsyncManager<Hooks, API>;
   /**
    * Clear all registered plugins.
    */
-
   clear: () => void;
   /**
    * Get all runner functions of the hooks.
    */
-
   useRunner: () => ToRunners<Hooks>;
 };
 export declare const createAsyncManager: <Hooks extends Record<string, any>, API extends Record<string, any> = Record<string, never>>(hooks?: Partial<Hooks> | undefined, api?: API | undefined) => AsyncManager<Hooks, API>;