@modern-js/plugin 2.0.0-beta.3 → 2.0.0-beta.4

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

@@ -1,35 +1,35 @@
-import _typeof from "@babel/runtime/helpers/esm/typeof";
 import { dagSort } from "../utils/pluginDagSort";
-export var checkPlugins = function checkPlugins(plugins) {
-  plugins.forEach(function (origin) {
-    origin.rivals.forEach(function (rival) {
-      plugins.forEach(function (plugin) {
-        if (rival === plugin.name) {
-          throw new Error("".concat(origin.name, " has rival ").concat(plugin.name));
-        }
-      });
+var checkPlugins = function(plugins) {
+    plugins.forEach(function(origin) {
+        origin.rivals.forEach(function(rival) {
+            plugins.forEach(function(plugin) {
+                if (rival === plugin.name) {
+                    throw new Error("".concat(origin.name, " has rival ").concat(plugin.name));
+                }
+            });
+        });
+        origin.required.forEach(function(required) {
+            if (!plugins.some(function(plugin) {
+                return plugin.name === required;
+            })) {
+                throw new Error("The plugin: ".concat(required, " is required when plugin: ").concat(origin.name, " is exist."));
+            }
+        });
     });
-    origin.required.forEach(function (required) {
-      if (!plugins.some(function (plugin) {
-        return plugin.name === required;
-      })) {
-        throw new Error("The plugin: ".concat(required, " is required when plugin: ").concat(origin.name, " is exist."));
-      }
-    });
-  });
 };
-export function sortPlugins(input) {
-  var plugins = input.slice();
-  return dagSort(plugins);
+function sortPlugins(input) {
+    var plugins = input.slice();
+    return dagSort(plugins);
 }
-export var includePlugin = function includePlugin(plugins, input) {
-  return plugins.some(function (plugin) {
-    return plugin.name === input.name;
-  });
+var includePlugin = function(plugins, input) {
+    return plugins.some(function(plugin) {
+        return plugin.name === input.name;
+    });
+};
+var isObject = function(obj) {
+    return obj !== null && typeof obj === "object";
 };
-export var isObject = function isObject(obj) {
-  return obj !== null && _typeof(obj) === 'object';
+var hasOwnProperty = function(obj, prop) {
+    return obj.hasOwnProperty(prop);
 };
-export var hasOwnProperty = function hasOwnProperty(obj, prop) {
-  return obj.hasOwnProperty(prop);
-};
+export { checkPlugins, hasOwnProperty, includePlugin, isObject, sortPlugins };

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

@@ -1,181 +1,226 @@
-import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
-import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+function _defineProperty(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _objectSpread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _defineProperty(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _objectSpreadProps(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
 import { isPipeline, createPipeline } from "../farrow-pipeline";
 import { isWaterfall, createWaterfall, isAsyncWaterfall, createAsyncWaterfall } from "../waterfall";
 import { isWorkflow, createWorkflow, isAsyncWorkflow, createAsyncWorkflow, isParallelWorkflow, createParallelWorkflow } from "../workflow";
 import { checkPlugins, hasOwnProperty, includePlugin, isObject, sortPlugins } from "./shared";
-var SYNC_PLUGIN_SYMBOL = 'SYNC_PLUGIN_SYMBOL';
-export var DEFAULT_OPTIONS = {
-  name: 'untitled',
-  pre: [],
-  post: [],
-  rivals: [],
-  required: [],
-  usePlugins: [],
-  registerHook: {}
+var SYNC_PLUGIN_SYMBOL = "SYNC_PLUGIN_SYMBOL";
+var DEFAULT_OPTIONS = {
+    name: "untitled",
+    pre: [],
+    post: [],
+    rivals: [],
+    required: [],
+    usePlugins: [],
+    registerHook: {}
 };
-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
-        else if (typeof plugin === 'function') {
-          var _options = plugin();
-          addPlugin(createPlugin(_options.setup, _options));
-        }
-        // plain plugin object
-        else if (isObject(plugin)) {
-          addPlugin(createPlugin(plugin.setup, plugin));
-        }
-        // unknown plugin
-        else {
-          console.warn("Unknown plugin: ".concat(JSON.stringify(plugin)));
-        }
-      });
-      return manager;
+var createManager = function(hooks, api) {
+    var index = 0;
+    var runners;
+    var currentHooks = _objectSpread({}, hooks);
+    var useRunner = function() {
+        return runners;
     };
-    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), {}, {
-        SYNC_PLUGIN_SYMBOL: SYNC_PLUGIN_SYMBOL,
-        setup: setup
-      });
-    };
-    var clear = function clear() {
-      plugins = [];
+    var registerHook = function(extraHooks) {
+        currentHooks = _objectSpread({}, extraHooks, currentHooks);
     };
-    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);
-      });
-      runners = generateRunner(hooksList, currentHooks);
-      return runners;
+    var isPlugin = function(input) {
+        return isObject(input) && hasOwnProperty(input, SYNC_PLUGIN_SYMBOL) && input[SYNC_PLUGIN_SYMBOL] === SYNC_PLUGIN_SYMBOL;
     };
-    var run = function run(cb) {
-      return cb();
+    var pluginAPI = _objectSpreadProps(_objectSpread({}, api), {
+        useHookRunners: useRunner
+    });
+    var clone = function(overrideAPI) {
+        var plugins = [];
+        var addPlugin = function(plugin) {
+            if (!includePlugin(plugins, plugin)) {
+                plugins.push(_objectSpread({}, plugin));
+            }
+        };
+        var usePlugin = function() {
+            for(var _len = arguments.length, input = new Array(_len), _key = 0; _key < _len; _key++){
+                input[_key] = arguments[_key];
+            }
+            input.forEach(function(plugin) {
+                if (isPlugin(plugin)) {
+                    addPlugin(plugin);
+                } else if (typeof plugin === "function") {
+                    var options = plugin();
+                    addPlugin(createPlugin(options.setup, options));
+                } else if (isObject(plugin)) {
+                    addPlugin(createPlugin(plugin.setup, plugin));
+                } else {
+                    console.warn("Unknown plugin: ".concat(JSON.stringify(plugin)));
+                }
+            });
+            return manager;
+        };
+        var createPlugin = function() {
+            var setup = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : function() {}, options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+            var ref;
+            if ((ref = options.usePlugins) === null || ref === void 0 ? void 0 : ref.length) {
+                options.usePlugins.forEach(function(plugin) {
+                    usePlugin(createPlugin(plugin.setup, plugin));
+                });
+            }
+            if (options.registerHook) {
+                registerHook(options.registerHook);
+            }
+            return _objectSpreadProps(_objectSpread(_objectSpreadProps(_objectSpread({}, DEFAULT_OPTIONS), {
+                name: "No.".concat(index++, " plugin")
+            }), options), {
+                SYNC_PLUGIN_SYMBOL: SYNC_PLUGIN_SYMBOL,
+                setup: setup
+            });
+        };
+        var clear = function() {
+            plugins = [];
+        };
+        var init = function() {
+            var sortedPlugins = sortPlugins(plugins);
+            var mergedPluginAPI = _objectSpread({}, pluginAPI, overrideAPI);
+            checkPlugins(sortedPlugins);
+            var hooksList = sortedPlugins.map(function(plugin) {
+                return plugin.setup(mergedPluginAPI);
+            });
+            runners = generateRunner(hooksList, currentHooks);
+            return runners;
+        };
+        var run = function(cb) {
+            return cb();
+        };
+        var manager = {
+            createPlugin: createPlugin,
+            isPlugin: isPlugin,
+            usePlugin: usePlugin,
+            init: init,
+            clear: clear,
+            run: run,
+            registerHook: registerHook,
+            useRunner: useRunner,
+            clone: clone
+        };
+        return manager;
     };
-    var manager = {
-      createPlugin: createPlugin,
-      isPlugin: isPlugin,
-      usePlugin: usePlugin,
-      init: init,
-      clear: clear,
-      run: run,
-      registerHook: registerHook,
-      useRunner: useRunner,
-      clone: clone
-    };
-    return manager;
-  };
-  return clone();
+    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;
-      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
-        // @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);
+var generateRunner = function(hooksList, hooksMap) {
+    var runner = {};
+    var cloneShape = cloneHooksMap(hooksMap);
+    if (hooksMap) {
+        var _loop = function(key) {
+            var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+            try {
+                for(var _iterator = hooksList[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                    var hooks = _step.value;
+                    if (!hooks) {
+                        continue;
+                    }
+                    if (hooks[key]) {
+                        cloneShape[key].use(hooks[key]);
+                    }
+                }
+            } catch (err) {
+                _didIteratorError = true;
+                _iteratorError = err;
+            } finally{
+                try {
+                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                        _iterator.return();
+                    }
+                } finally{
+                    if (_didIteratorError) {
+                        throw _iteratorError;
+                    }
+                }
+            }
+            runner[key] = function(input, options) {
+                return cloneShape[key].run(input, _objectSpread({}, options));
+            };
+        };
+        for(var key in cloneShape)_loop(key);
+    }
+    return runner;
+};
+var cloneHook = function(hook) {
+    if (isWaterfall(hook)) {
+        return createWaterfall();
     }
-  }
-  return runner;
+    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 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));
+var cloneHooksMap = function(record) {
+    if (!record) {
+        return record;
+    }
+    var result = {};
+    for(var key in record){
+        result[key] = cloneHook(record[key]);
+    }
+    return result;
 };
-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;
-};
+export { DEFAULT_OPTIONS, cloneHook, cloneHooksMap, createManager, generateRunner };

package/dist/js/treeshaking/manager/types.js

@@ -0,0 +1 @@
+"use strict";

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

@@ -1,74 +1,69 @@
-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];
+var dagSort = function(plugins) {
+    var _loop = function() {
+        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(function(item) {
+            return !allLines.find(function(l) {
+                return l[1] === item[key];
+            });
+        });
+    };
+    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";
+    var getPluginByAny = function getPluginByAny(q) {
+        var target = plugins.find(function(item) {
+            return typeof q === "string" ? item[key] === q : item[key] === q[key];
+        });
+        if (!target) {
+            throw new Error("plugin ".concat(q, " not existed"));
+        }
+        return target;
+    };
+    var allLines = [];
+    plugins.forEach(function(item) {
+        item[preKey].forEach(function(p) {
+            if (plugins.find(function(ap) {
+                return ap.name === p;
+            })) {
+                allLines.push([
+                    getPluginByAny(p)[key],
+                    getPluginByAny(item)[key]
+                ]);
+            }
+        });
+        item[postKey].forEach(function(pt) {
+            if (plugins.find(function(ap) {
+                return ap.name === pt;
+            })) {
+                allLines.push([
+                    getPluginByAny(item)[key],
+                    getPluginByAny(pt)[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 zeroEndPoints = plugins.filter(function(item) {
+        return !allLines.find(function(l) {
+            return l[1] === item[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;
-};
+    var sortedPoint = [];
+    while(zeroEndPoints.length)_loop();
+    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;
+};
+export { dagSort };