@modern-js/plugin 1.21.2-beta.1 → 1.21.2

package/dist/js/treeshaking/farrow-pipeline/pipeline.js

@@ -0,0 +1,81 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+
+/**
+ * modified from https://github.com/farrow-js/farrow/tree/master/packages/farrow-pipeline
+ * license at https://github.com/farrow-js/farrow/blob/master/LICENSE
+ */
+import { createContext } from "./context";
+import { createCounter } from "./counter";
+export { createContext };
+export var isPipeline = function isPipeline(input) {
+  return Boolean(input === null || input === void 0 ? void 0 : input[PipelineSymbol]);
+};
+var PipelineSymbol = Symbol["for"]('MODERN_PIPELINE');
+
+var getMiddleware = function getMiddleware(input) {
+  if (typeof input === 'function') {
+    return input;
+  } else if (input && typeof input.middleware === 'function') {
+    return input.middleware;
+  }
+
+  throw new Error("".concat(input, " is not a Middleware"));
+};
+
+export var createPipeline = function createPipeline() {
+  var _pipeline;
+
+  var middlewares = [];
+
+  var use = function use() {
+    for (var _len = arguments.length, inputs = new Array(_len), _key = 0; _key < _len; _key++) {
+      inputs[_key] = arguments[_key];
+    }
+
+    middlewares.push.apply(middlewares, _toConsumableArray(inputs.map(getMiddleware)));
+    return pipeline;
+  };
+
+  var createCurrentCounter = function createCurrentCounter(onLast) {
+    return createCounter(function (index, input, next) {
+      if (index >= middlewares.length) {
+        if (onLast) {
+          return onLast(input);
+        }
+
+        throw new Error("Expect returning a value, but all middlewares just calling next()");
+      }
+
+      return middlewares[index](input, next);
+    });
+  };
+
+  var currentCounter = createCurrentCounter();
+
+  var getCounter = function getCounter(options) {
+    if (!options) {
+      return currentCounter;
+    }
+
+    return createCurrentCounter(options === null || options === void 0 ? void 0 : options.onLast);
+  };
+
+  var run = function run(input, options) {
+    return getCounter(options).start(input);
+  };
+
+  var middleware = function middleware(input, next) {
+    return run(input, {
+      onLast: next
+    });
+  };
+
+  var pipeline = (_pipeline = {}, _defineProperty(_pipeline, PipelineSymbol, true), _defineProperty(_pipeline, "use", use), _defineProperty(_pipeline, "run", run), _defineProperty(_pipeline, "middleware", middleware), _pipeline);
+  return pipeline;
+};
+export var createAsyncPipeline = function createAsyncPipeline() {
+  var pipeline = createPipeline();
+  return _objectSpread({}, pipeline);
+};

package/dist/js/treeshaking/index.js

@@ -0,0 +1,4 @@
+export * from "./farrow-pipeline";
+export * from "./waterfall";
+export * from "./workflow";
+export * from "./manager";

package/dist/js/treeshaking/manager/async.js

@@ -0,0 +1,146 @@
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import { generateRunner, DEFAULT_OPTIONS } from "./sync";
+import { checkPlugins, isObject, hasOwnProperty, sortPlugins, includePlugin } from "./shared";
+var ASYNC_PLUGIN_SYMBOL = 'ASYNC_PLUGIN_SYMBOL';
+export var createAsyncManager = function createAsyncManager(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, ASYNC_PLUGIN_SYMBOL) && input[ASYNC_PLUGIN_SYMBOL] === ASYNC_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];
+      }
+
+      for (var _i = 0, _input = input; _i < _input.length; _i++) {
+        var plugin = _input[_i];
+
+        // 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 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), {}, {
+        ASYNC_PLUGIN_SYMBOL: ASYNC_PLUGIN_SYMBOL,
+        setup: setup
+      });
+    };
+
+    var clear = function clear() {
+      plugins = [];
+    };
+
+    var init = /*#__PURE__*/function () {
+      var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+        var sortedPlugins, mergedPluginAPI, hooksList;
+        return _regeneratorRuntime().wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                sortedPlugins = sortPlugins(plugins);
+                mergedPluginAPI = _objectSpread(_objectSpread({}, pluginAPI), overrideAPI);
+                checkPlugins(sortedPlugins);
+                _context.next = 5;
+                return Promise.all(sortedPlugins.map(function (plugin) {
+                  return plugin.setup(mergedPluginAPI);
+                }));
+
+              case 5:
+                hooksList = _context.sent;
+                runners = generateRunner(hooksList, currentHooks);
+                return _context.abrupt("return", runners);
+
+              case 8:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee);
+      }));
+
+      return function init() {
+        return _ref.apply(this, arguments);
+      };
+    }();
+
+    var run = function run(cb) {
+      return cb();
+    };
+
+    var manager = {
+      createPlugin: createPlugin,
+      isPlugin: isPlugin,
+      usePlugin: usePlugin,
+      init: init,
+      run: run,
+      clear: clear,
+      clone: clone,
+      registerHook: registerHook,
+      useRunner: useRunner
+    };
+    return manager;
+  };
+
+  return clone();
+};

package/dist/js/treeshaking/manager/index.js

@@ -0,0 +1,3 @@
+export * from "./sync";
+export * from "./async";
+export * from "./types";

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

@@ -0,0 +1,79 @@
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+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));
+        }
+      });
+    });
+    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();
+
+  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;
+}
+export var includePlugin = function includePlugin(plugins, input) {
+  return plugins.some(function (plugin) {
+    return plugin.name === input.name;
+  });
+};
+export var isObject = function isObject(obj) {
+  return obj !== null && _typeof(obj) === 'object';
+};
+export var hasOwnProperty = function hasOwnProperty(obj, prop) {
+  return obj.hasOwnProperty(prop);
+};

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

@@ -0,0 +1,216 @@
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+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: {}
+};
+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 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 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 run = function run(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;
+  };
+
+  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);
+    }
+  }
+
+  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/waterfall/async.js

@@ -0,0 +1,84 @@
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import { createAsyncPipeline } from "../farrow-pipeline";
+var ASYNC_WATERFALL_SYMBOL = Symbol["for"]('MODERN_ASYNC_WATERFALL');
+export var getAsyncBrook = function getAsyncBrook(input) {
+  if (typeof input === 'function') {
+    return 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) {
+        return input;
+      }
+    }));
+  };
+
+  var middleware = function middleware(input) {
+    return pipeline.run(input, {
+      onLast: function onLast(input) {
+        return input;
+      }
+    });
+  };
+
+  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) {
+      return _regeneratorRuntime().wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              _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();
+          }
+        }
+      }, _callee);
+    }));
+
+    return function (_x, _x2) {
+      return _ref.apply(this, arguments);
+    };
+  }();
+};

package/dist/js/treeshaking/waterfall/index.js

@@ -0,0 +1,2 @@
+export * from "./sync";
+export * from "./async";

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

@@ -0,0 +1,59 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import { createPipeline } from "../farrow-pipeline";
+var WATERFALL_SYMBOL = Symbol["for"]('MODERN_WATERFALL');
+export var getBrook = function getBrook(input) {
+  if (typeof input === 'function') {
+    return 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) {
+        return input;
+      }
+    }));
+  };
+
+  var middleware = function middleware(input) {
+    return pipeline.run(input, {
+      onLast: function onLast(input) {
+        return input;
+      }
+    });
+  };
+
+  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));
+  };
+};