@modern-js/plugin 1.2.0 → 1.3.1

package/dist/js/node/manager/sync.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.hasOwnProperty = exports.generateRunner = exports.createManager = exports.cloneProgressRecord = exports.cloneProgress = exports.DEFAULT_OPTIONS = void 0;
+exports.isObject = exports.hasOwnProperty = exports.generateRunner = exports.createManager = exports.closeHooksMap = exports.cloneHook = exports.DEFAULT_OPTIONS = void 0;
 
 var _farrowPipeline = require("farrow-pipeline");
 
@@ -25,56 +25,77 @@ const DEFAULT_OPTIONS = {
   pre: [],
   post: [],
   rivals: [],
-  required: []
+  required: [],
+  usePlugins: [],
+  registerHook: {}
 };
 exports.DEFAULT_OPTIONS = DEFAULT_OPTIONS;
 
-const createManager = processes => {
+const createManager = (hooks, api) => {
   let index = 0;
 
-  const createPlugin = (initializer, options = {}) => _objectSpread(_objectSpread(_objectSpread({}, DEFAULT_OPTIONS), {}, {
-    name: `No.${index++} plugin`
-  }, options), {}, {
-    SYNC_PLUGIN_SYMBOL,
-    initializer
-  });
-
-  const isPlugin = input => hasOwnProperty(input, SYNC_PLUGIN_SYMBOL) && input[SYNC_PLUGIN_SYMBOL] === SYNC_PLUGIN_SYMBOL;
+  let currentHooks = _objectSpread({}, hooks);
 
-  const registe = extraProcesses => {
-    // eslint-disable-next-line no-param-reassign
-    processes = _objectSpread(_objectSpread({}, extraProcesses), processes);
+  const registerHook = extraHooks => {
+    currentHooks = _objectSpread(_objectSpread({}, extraHooks), currentHooks);
   };
 
-  const clone = () => {
+  const isPlugin = input => isObject(input) && hasOwnProperty(input, SYNC_PLUGIN_SYMBOL) && input[SYNC_PLUGIN_SYMBOL] === SYNC_PLUGIN_SYMBOL;
+
+  const pluginAPI = _objectSpread(_objectSpread({}, api), {}, {
+    useHookRunners: _runner.useRunner
+  });
+
+  const clone = overrideAPI => {
     let plugins = [];
 
+    const addPlugin = plugin => {
+      if (!includePlugin(plugins, plugin)) {
+        plugins.push(_objectSpread({}, plugin));
+      }
+    };
+
     const usePlugin = (...input) => {
       for (const plugin of input) {
+        // already created by createPlugin
         if (isPlugin(plugin)) {
-          if (!includePlugin(plugins, plugin)) {
-            plugins.push(_objectSpread(_objectSpread({}, plugin), {}, {
-              index: plugins.length
-            }));
-          }
-        } else {
-          // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-          // @ts-expect-error
-          console.warn(`Unknown plugin: ${plugin.name}`);
+          addPlugin(plugin);
+        } // using function to return plugin options
+        else if (typeof plugin === 'function') {
+          const options = plugin();
+          addPlugin(createPlugin(options.setup, options));
+        } // plain plugin options with `setup` param
+        else if (plugin.setup) {
+          addPlugin(createPlugin(plugin.setup, plugin));
+        } // unknown plugin
+        else {
+          console.warn(`Unknown plugin: ${plugin.name || ''}`);
         }
       }
 
-      return {
-        createPlugin,
-        isPlugin,
-        usePlugin,
-        init,
-        run,
-        clear,
-        registe,
-        useRunner: _runner.useRunner,
-        clone
-      };
+      return manager;
+    };
+
+    const createPlugin = ( // eslint-disable-next-line @typescript-eslint/no-empty-function
+    setup = () => {}, options = {}) => {
+      var _options$usePlugins;
+
+      if ((_options$usePlugins = options.usePlugins) !== null && _options$usePlugins !== void 0 && _options$usePlugins.length) {
+        options.usePlugins.forEach(plugin => {
+          usePlugin(createPlugin(plugin.setup, plugin));
+        });
+      }
+
+      if (options.registerHook) {
+        registerHook(options.registerHook);
+      }
+
+      return _objectSpread(_objectSpread(_objectSpread({}, DEFAULT_OPTIONS), {}, {
+        name: `No.${index++} plugin`
+      }, options), {}, {
+        SYNC_PLUGIN_SYMBOL,
+        setup
+      });
     };
 
     const clear = () => {
@@ -86,9 +107,12 @@ const createManager = processes => {
     const init = options => {
       const container = (options === null || options === void 0 ? void 0 : options.container) || currentContainer;
       const sortedPlugins = sortPlugins(plugins);
+
+      const mergedPluginAPI = _objectSpread(_objectSpread({}, pluginAPI), overrideAPI);
+
       checkPlugins(sortedPlugins);
-      const hooksList = sortedPlugins.map(plugin => (0, _farrowPipeline.runWithContainer)(() => plugin.initializer(), container));
-      return generateRunner(hooksList, container, processes);
+      const hooksList = sortedPlugins.map(plugin => (0, _farrowPipeline.runWithContainer)(() => plugin.setup(mergedPluginAPI), container));
+      return generateRunner(hooksList, container, currentHooks);
     };
 
     const run = (cb, options) => {
@@ -96,17 +120,18 @@ const createManager = processes => {
       return (0, _farrowPipeline.runWithContainer)(cb, container);
     };
 
-    return {
+    const manager = {
       createPlugin,
       isPlugin,
       usePlugin,
       init,
       clear,
       run,
-      registe,
+      registerHook,
       useRunner: _runner.useRunner,
       clone
     };
+    return manager;
   };
 
   return clone();
@@ -114,11 +139,11 @@ const createManager = processes => {
 
 exports.createManager = createManager;
 
-const generateRunner = (hooksList, container, processes) => {
+const generateRunner = (hooksList, container, hooksMap) => {
   const runner = {};
-  const cloneShape = cloneProgressRecord(processes);
+  const cloneShape = closeHooksMap(hooksMap);
 
-  if (processes) {
+  if (hooksMap) {
     for (const key in cloneShape) {
       for (const hooks of hooksList) {
         if (!hooks) {
@@ -126,8 +151,6 @@ const generateRunner = (hooksList, container, processes) => {
         }
 
         if (hooks[key]) {
-          // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-          // @ts-expect-error
           cloneShape[key].use(hooks[key]);
         }
       } // eslint-disable-next-line @typescript-eslint/ban-ts-comment
@@ -146,39 +169,38 @@ const generateRunner = (hooksList, container, processes) => {
 
 exports.generateRunner = generateRunner;
 
-const cloneProgress = progress => {
-  if ((0, _waterfall.isWaterfall)(progress)) {
+const cloneHook = hook => {
+  if ((0, _waterfall.isWaterfall)(hook)) {
     return (0, _waterfall.createWaterfall)();
   }
 
-  if ((0, _waterfall.isAsyncWaterfall)(progress)) {
+  if ((0, _waterfall.isAsyncWaterfall)(hook)) {
     return (0, _waterfall.createAsyncWaterfall)();
   }
 
-  if ((0, _workflow.isWorkflow)(progress)) {
+  if ((0, _workflow.isWorkflow)(hook)) {
     return (0, _workflow.createWorkflow)();
   }
 
-  if ((0, _workflow.isAsyncWorkflow)(progress)) {
+  if ((0, _workflow.isAsyncWorkflow)(hook)) {
     return (0, _workflow.createAsyncWorkflow)();
   }
 
-  if ((0, _workflow.isParallelWorkflow)(progress)) {
+  if ((0, _workflow.isParallelWorkflow)(hook)) {
     return (0, _workflow.createParallelWorkflow)();
   }
 
-  if ((0, _farrowPipeline.isPipeline)(progress)) {
+  if ((0, _farrowPipeline.isPipeline)(hook)) {
     return (0, _farrowPipeline.createPipeline)();
   } // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
 
 
-  throw new Error(`Unknown progress: ${progress}`);
-}; // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-
+  throw new Error(`Unknown hook: ${hook}`);
+};
 
-exports.cloneProgress = cloneProgress;
+exports.cloneHook = cloneHook;
 
-const cloneProgressRecord = record => {
+const closeHooksMap = record => {
   if (!record) {
     return record;
   }
@@ -188,13 +210,13 @@ const cloneProgressRecord = record => {
   for (const key in record) {
     // eslint-disable-next-line @typescript-eslint/ban-ts-comment
     // @ts-expect-error
-    result[key] = cloneProgress(record[key]);
+    result[key] = cloneHook(record[key]);
   }
 
   return result;
 };
 
-exports.cloneProgressRecord = cloneProgressRecord;
+exports.closeHooksMap = closeHooksMap;
 
 const includePlugin = (plugins, input) => {
   for (const plugin of plugins) {
@@ -250,6 +272,10 @@ const checkPlugins = plugins => {
   }
 };
 
+const isObject = obj => obj !== null && typeof obj === 'object';
+
+exports.isObject = isObject;
+
 const hasOwnProperty = (obj, prop) => obj.hasOwnProperty(prop);
 
 exports.hasOwnProperty = hasOwnProperty;

package/dist/js/node/waterfall/async.js

@@ -18,8 +18,8 @@ const ASYNC_WATERFALL_SYMBOL = Symbol('ASYNC_WATERFALL_SYMBOL');
 const getAsyncBrook = input => {
   if (typeof input === 'function') {
     return input;
-  } else if (input && typeof input.middlware === 'function') {
-    return input.middlware;
+  } else if (input && typeof input.middleware === 'function') {
+    return input.middleware;
   } // eslint-disable-next-line @typescript-eslint/no-base-to-string,@typescript-eslint/restrict-template-expressions
 
 
@@ -28,7 +28,6 @@ const getAsyncBrook = input => {
 
 exports.getAsyncBrook = getAsyncBrook;
 
-// eslint-disable-next-line @typescript-eslint/no-invalid-void-type
 const createAsyncWaterfall = () => {
   const pipeline = (0, _farrowPipeline.createAsyncPipeline)();
 
@@ -42,7 +41,7 @@ const createAsyncWaterfall = () => {
     onLast: input => input
   }));
 
-  const middlware = input => {
+  const middleware = input => {
     // eslint-disable-next-line react-hooks/rules-of-hooks
     const container = (0, _farrowPipeline.useContainer)(); // eslint-disable-next-line @typescript-eslint/no-shadow
 
@@ -55,7 +54,7 @@ const createAsyncWaterfall = () => {
   const waterfall = _objectSpread(_objectSpread({}, pipeline), {}, {
     use,
     run,
-    middlware,
+    middleware,
     [ASYNC_WATERFALL_SYMBOL]: true
   });
 

package/dist/js/node/waterfall/sync.js

@@ -28,7 +28,6 @@ const getBrook = input => {
 
 exports.getBrook = getBrook;
 
-// eslint-disable-next-line @typescript-eslint/no-invalid-void-type
 const createWaterfall = () => {
   const pipeline = (0, _farrowPipeline.createPipeline)();
 

package/dist/js/node/workflow/async.js

@@ -15,8 +15,7 @@ function _defineProperty(obj, key, value) { if (key in obj) { Object.definePrope
 
 const ASYNC_WORKFLOW_SYMBOL = Symbol('ASYNC_WORKFLOW_SYMBOL');
 
-const isAsyncWorkflow = input => Boolean(input === null || input === void 0 ? void 0 : input[ASYNC_WORKFLOW_SYMBOL]); // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-
+const isAsyncWorkflow = input => Boolean(input === null || input === void 0 ? void 0 : input[ASYNC_WORKFLOW_SYMBOL]);
 
 exports.isAsyncWorkflow = isAsyncWorkflow;
 

package/dist/js/node/workflow/sync.js

@@ -15,7 +15,6 @@ function _defineProperty(obj, key, value) { if (key in obj) { Object.definePrope
 
 const WORKFLOW_SYMBOL = Symbol('WORKFLOW_SYMBOL');
 
-// eslint-disable-next-line @typescript-eslint/no-invalid-void-type
 const createWorkflow = () => {
   const pipeline = (0, _farrowPipeline.createPipeline)();
 

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

@@ -25,35 +25,35 @@ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { va
 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; }
 
 import { runWithContainer, createContainer } from 'farrow-pipeline';
-import { generateRunner, hasOwnProperty, DEFAULT_OPTIONS } from "./sync";
-import { useRunner } from "./runner"; // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-
+import { isObject, generateRunner, hasOwnProperty, DEFAULT_OPTIONS } from "./sync";
+import { useRunner } from "./runner";
 var ASYNC_PLUGIN_SYMBOL = 'ASYNC_PLUGIN_SYMBOL';
-export var createAsyncManager = function createAsyncManager(processes) {
+export var createAsyncManager = function createAsyncManager(hooks, api) {
   var index = 0;
 
-  var createPlugin = function createPlugin(initializer) {
-    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-    return _objectSpread(_objectSpread(_objectSpread({}, DEFAULT_OPTIONS), {}, {
-      name: "No.".concat(index++, " plugin")
-    }, options), {}, {
-      ASYNC_PLUGIN_SYMBOL: ASYNC_PLUGIN_SYMBOL,
-      initializer: initializer
-    });
+  var currentHooks = _objectSpread({}, hooks);
+
+  var registerHook = function registerHook(extraHooks) {
+    currentHooks = _objectSpread(_objectSpread({}, extraHooks), currentHooks);
   };
 
   var isPlugin = function isPlugin(input) {
-    return hasOwnProperty(input, ASYNC_PLUGIN_SYMBOL) && input[ASYNC_PLUGIN_SYMBOL] === ASYNC_PLUGIN_SYMBOL;
+    return isObject(input) && hasOwnProperty(input, ASYNC_PLUGIN_SYMBOL) && input[ASYNC_PLUGIN_SYMBOL] === ASYNC_PLUGIN_SYMBOL;
   };
 
-  var registe = function registe(extraProcesses) {
-    // eslint-disable-next-line no-param-reassign
-    processes = _objectSpread(_objectSpread({}, extraProcesses), processes);
-  };
+  var pluginAPI = _objectSpread(_objectSpread({}, api), {}, {
+    useHookRunners: useRunner
+  });
 
-  var clone = function clone() {
+  var clone = function clone(overrideAPI) {
     var plugins = [];
 
+    var addPlugin = function addPlugin(plugin) {
+      if (!includeAsyncPlugin(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];
@@ -62,22 +62,50 @@ export var createAsyncManager = function createAsyncManager(processes) {
       for (var _i = 0, _input = input; _i < _input.length; _i++) {
         var plugin = _input[_i];
 
+        // already created by createPlugin
         if (isPlugin(plugin)) {
-          if (!includeAsyncPlugin(plugins, plugin)) {
-            plugins.push(_objectSpread(_objectSpread({}, plugin), {}, {
-              index: plugins.length
-            }));
-          }
-        } else {
-          // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-          // @ts-expect-error
-          console.warn("Unknown plugin: ".concat(plugin.name));
+          addPlugin(plugin);
+        } // using function to return plugin options
+        else if (typeof plugin === 'function') {
+          var _options = plugin();
+
+          addPlugin(createPlugin(_options.setup, _options));
+        } // plain plugin options with `setup` param
+        else if (plugin.setup) {
+          addPlugin(createPlugin(plugin.setup, plugin));
+        } // unknown plugin
+        else {
+          console.warn("Unknown plugin: ".concat(plugin.name || ''));
         }
       }
 
       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 = [];
     };
@@ -86,26 +114,27 @@ export var createAsyncManager = function createAsyncManager(processes) {
 
     var init = /*#__PURE__*/function () {
       var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(options) {
-        var container, sortedPlugins, hooksList;
+        var container, sortedPlugins, mergedPluginAPI, hooksList;
         return _regeneratorRuntime.wrap(function _callee$(_context) {
           while (1) {
             switch (_context.prev = _context.next) {
               case 0:
                 container = (options === null || options === void 0 ? void 0 : options.container) || currentContainer;
                 sortedPlugins = sortAsyncPlugins(plugins);
+                mergedPluginAPI = _objectSpread(_objectSpread({}, pluginAPI), overrideAPI);
                 checkAsyncPlugins(sortedPlugins);
-                _context.next = 5;
+                _context.next = 6;
                 return Promise.all(sortedPlugins.map(function (plugin) {
                   return runWithContainer(function () {
-                    return plugin.initializer();
+                    return plugin.setup(mergedPluginAPI);
                   }, container);
                 }));
 
-              case 5:
+              case 6:
                 hooksList = _context.sent;
-                return _context.abrupt("return", generateRunner(hooksList, container, processes));
+                return _context.abrupt("return", generateRunner(hooksList, container, currentHooks));
 
-              case 7:
+              case 8:
               case "end":
                 return _context.stop();
             }
@@ -131,7 +160,7 @@ export var createAsyncManager = function createAsyncManager(processes) {
       run: run,
       clear: clear,
       clone: clone,
-      registe: registe,
+      registerHook: registerHook,
       useRunner: useRunner
     };
     return manager;

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

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