@modern-js/plugin 1.1.2 → 1.3.0

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

@@ -1,3 +1,5 @@
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+
 function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
 
 function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
@@ -12,53 +14,52 @@ function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o =
 
 function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
 
-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 ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
 
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else 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; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 
 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; }
 
-// eslint-disable-next-line eslint-comments/disable-enable-pair
-
-/* eslint-disable max-lines */
 import { isPipeline, createPipeline, runWithContainer, createContainer } from 'farrow-pipeline';
 import { isWaterfall, createWaterfall, isAsyncWaterfall, createAsyncWaterfall } from "../waterfall";
 import { isWorkflow, createWorkflow, isAsyncWorkflow, createAsyncWorkflow, isParallelWorkflow, createParallelWorkflow } from "../workflow";
-import { RunnerContext, useRunner } from "./runner"; // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-
+import { RunnerContext, useRunner } from "./runner";
 var SYNC_PLUGIN_SYMBOL = 'SYNC_PLUGIN_SYMBOL';
 export var DEFAULT_OPTIONS = {
   name: 'untitled',
   pre: [],
   post: [],
   rivals: [],
-  required: []
+  required: [],
+  usePlugins: [],
+  registerHook: {}
 };
-export var createManager = function createManager(processes) {
+export var createManager = function createManager(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), {}, {
-      SYNC_PLUGIN_SYMBOL: SYNC_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, SYNC_PLUGIN_SYMBOL) && input[SYNC_PLUGIN_SYMBOL] === SYNC_PLUGIN_SYMBOL;
+    return isObject(input) && hasOwnProperty(input, SYNC_PLUGIN_SYMBOL) && input[SYNC_PLUGIN_SYMBOL] === SYNC_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 (!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];
@@ -68,11 +69,11 @@ export var createManager = function createManager(processes) {
         var plugin = _input[_i];
 
         if (isPlugin(plugin)) {
-          if (!includePlugin(plugins, plugin)) {
-            plugins.push(_objectSpread(_objectSpread({}, plugin), {}, {
-              index: plugins.length
-            }));
-          }
+          addPlugin(plugin);
+        } else if (typeof plugin === 'function') {
+          var _options = plugin();
+
+          addPlugin(createPlugin(_options.setup, _options));
         } else {
           // eslint-disable-next-line @typescript-eslint/ban-ts-comment
           // @ts-expect-error
@@ -80,17 +81,31 @@ export var createManager = function createManager(processes) {
         }
       }
 
-      return {
-        createPlugin: createPlugin,
-        isPlugin: isPlugin,
-        usePlugin: usePlugin,
-        init: init,
-        run: run,
-        clear: clear,
-        registe: registe,
-        useRunner: useRunner,
-        clone: clone
-      };
+      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() {
@@ -102,13 +117,16 @@ export var createManager = function createManager(processes) {
     var init = function init(options) {
       var container = (options === null || options === void 0 ? void 0 : options.container) || currentContainer;
       var sortedPlugins = sortPlugins(plugins);
+
+      var mergedPluginAPI = _objectSpread(_objectSpread({}, pluginAPI), overrideAPI);
+
       checkPlugins(sortedPlugins);
       var hooksList = sortedPlugins.map(function (plugin) {
         return runWithContainer(function () {
-          return plugin.initializer();
+          return plugin.setup(mergedPluginAPI);
         }, container);
       });
-      return generateRunner(hooksList, container, processes);
+      return generateRunner(hooksList, container, currentHooks);
     };
 
     var run = function run(cb, options) {
@@ -116,26 +134,27 @@ export var createManager = function createManager(processes) {
       return runWithContainer(cb, container);
     };
 
-    return {
+    var manager = {
       createPlugin: createPlugin,
       isPlugin: isPlugin,
       usePlugin: usePlugin,
       init: init,
       clear: clear,
       run: run,
-      registe: registe,
+      registerHook: registerHook,
       useRunner: useRunner,
       clone: clone
     };
+    return manager;
   };
 
   return clone();
 };
-export var generateRunner = function generateRunner(hooksList, container, processes) {
+export var generateRunner = function generateRunner(hooksList, container, hooksMap) {
   var runner = {};
-  var cloneShape = cloneProgressRecord(processes);
+  var cloneShape = closeHooksMap(hooksMap);
 
-  if (processes) {
+  if (hooksMap) {
     var _loop = function _loop(key) {
       var _iterator = _createForOfIteratorHelper(hooksList),
           _step;
@@ -149,8 +168,6 @@ export var generateRunner = function generateRunner(hooksList, container, proces
           }
 
           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
@@ -177,36 +194,35 @@ export var generateRunner = function generateRunner(hooksList, container, proces
   container.write(RunnerContext, runner);
   return runner;
 };
-export var cloneProgress = function cloneProgress(progress) {
-  if (isWaterfall(progress)) {
+export var cloneHook = function cloneHook(hook) {
+  if (isWaterfall(hook)) {
     return createWaterfall();
   }
 
-  if (isAsyncWaterfall(progress)) {
+  if (isAsyncWaterfall(hook)) {
     return createAsyncWaterfall();
   }
 
-  if (isWorkflow(progress)) {
+  if (isWorkflow(hook)) {
     return createWorkflow();
   }
 
-  if (isAsyncWorkflow(progress)) {
+  if (isAsyncWorkflow(hook)) {
     return createAsyncWorkflow();
   }
 
-  if (isParallelWorkflow(progress)) {
+  if (isParallelWorkflow(hook)) {
     return createParallelWorkflow();
   }
 
-  if (isPipeline(progress)) {
+  if (isPipeline(hook)) {
     return createPipeline();
   } // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
 
 
-  throw new Error("Unknown progress: ".concat(progress));
-}; // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-
-export var cloneProgressRecord = function cloneProgressRecord(record) {
+  throw new Error("Unknown hook: ".concat(hook));
+};
+export var closeHooksMap = function closeHooksMap(record) {
   if (!record) {
     return record;
   }
@@ -216,7 +232,7 @@ export var cloneProgressRecord = function cloneProgressRecord(record) {
   for (var 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;
@@ -359,6 +375,9 @@ var checkPlugins = function checkPlugins(plugins) {
   }
 };
 
+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/waterfall/async.js

@@ -4,9 +4,9 @@ function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try
 
 function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
 
-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 ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
 
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else 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; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 
 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; }
 
@@ -27,14 +27,13 @@ var ASYNC_WATERFALL_SYMBOL = Symbol('ASYNC_WATERFALL_SYMBOL');
 export var getAsyncBrook = function 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
 
 
   throw new Error("".concat(input, " is not a AsyncBrook or { brook: AsyncBrook }"));
 };
-// eslint-disable-next-line @typescript-eslint/no-invalid-void-type
 export var createAsyncWaterfall = function createAsyncWaterfall() {
   var pipeline = createAsyncPipeline();
 
@@ -57,7 +56,7 @@ export var createAsyncWaterfall = function createAsyncWaterfall() {
     );
   };
 
-  var middlware = function middlware(input) {
+  var middleware = function middleware(input) {
     // eslint-disable-next-line react-hooks/rules-of-hooks
     var container = useContainer(); // eslint-disable-next-line @typescript-eslint/no-shadow
 
@@ -72,7 +71,7 @@ export var createAsyncWaterfall = function createAsyncWaterfall() {
   var waterfall = _objectSpread(_objectSpread({}, pipeline), {}, _defineProperty({
     use: use,
     run: run,
-    middlware: middlware
+    middleware: middleware
   }, ASYNC_WATERFALL_SYMBOL, true));
 
   return waterfall;

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

@@ -1,6 +1,6 @@
-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 ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
 
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else 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; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 
 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; }
 
@@ -28,7 +28,6 @@ export var getBrook = function getBrook(input) {
 
   throw new Error("".concat(input, " is not a Brook or { brook: Brook }"));
 };
-// eslint-disable-next-line @typescript-eslint/no-invalid-void-type
 export var createWaterfall = function createWaterfall() {
   var pipeline = createPipeline();
 

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

@@ -1,10 +1,10 @@
-function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
 
 import _regeneratorRuntime from "@babel/runtime/regenerator";
 
-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 ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
 
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else 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; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 
 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; }
 
@@ -28,8 +28,7 @@ import { createAsyncPipeline } from 'farrow-pipeline';
 var ASYNC_WORKFLOW_SYMBOL = Symbol('ASYNC_WORKFLOW_SYMBOL');
 export var isAsyncWorkflow = function isAsyncWorkflow(input) {
   return Boolean(input === null || input === void 0 ? void 0 : input[ASYNC_WORKFLOW_SYMBOL]);
-}; // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-
+};
 export var createAsyncWorkflow = function createAsyncWorkflow() {
   var pipeline = createAsyncPipeline();
 

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

@@ -1,8 +1,8 @@
 import _regeneratorRuntime from "@babel/runtime/regenerator";
 
-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 ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
 
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else 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; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 
 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; }
 

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

@@ -1,8 +1,8 @@
 import _regeneratorRuntime from "@babel/runtime/regenerator";
 
-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 ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
 
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else 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; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 
 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; }
 
@@ -24,7 +24,6 @@ function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len
 
 import { createPipeline } from 'farrow-pipeline';
 var WORKFLOW_SYMBOL = Symbol('WORKFLOW_SYMBOL');
-// eslint-disable-next-line @typescript-eslint/no-invalid-void-type
 export var createWorkflow = function createWorkflow() {
   var pipeline = createPipeline();
 

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

@@ -1,27 +1,66 @@
-import { ProgressRecord, Progresses2Threads, Progresses2Runners, PluginOptions, ClearDraftProgress, InitOptions } from './sync';
-export declare type AsyncInitializer<O> = () => void | O | Promise<O | void>;
+import type { ToRunners, ToThreads, CommonAPI, InitOptions, 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<O> = {
-  initializer: AsyncInitializer<O>;
+export declare type AsyncPlugin<Hooks, API> = {
   ASYNC_PLUGIN_SYMBOL: typeof ASYNC_PLUGIN_SYMBOL;
-} & Required<PluginOptions>;
-export declare type IndexAsyncPlugin<O> = AsyncPlugin<O> & {
-  index: number;
-};
-export declare type AsyncPlugins<O> = AsyncPlugin<O>[];
-export declare type AsyncIndexPlugins<O> = IndexAsyncPlugin<O>[];
-export declare type AsyncPluginFromAsyncManager<M extends AsyncManager<any, any>> = M extends AsyncManager<infer EP, infer PR> ? AsyncPlugin<Partial<Progresses2Threads<PR & ClearDraftProgress<EP>>>> : never;
-export declare type PluginFromAsyncManager<M extends AsyncManager<any, any>> = M extends AsyncManager<infer EP, infer PR> ? AsyncPlugin<Partial<Progresses2Threads<PR & ClearDraftProgress<EP>>>> : never;
-export declare type AsyncManager<EP extends Record<string, any>, PR extends ProgressRecord | void = void> = {
-  createPlugin: (initializer: AsyncInitializer<Partial<Progresses2Threads<PR & ClearDraftProgress<EP>>>>, options?: PluginOptions) => AsyncPlugin<Partial<Progresses2Threads<PR & ClearDraftProgress<EP>>>>;
-  isPlugin: (input: Record<string, unknown>) => input is AsyncPlugin<Partial<Progresses2Threads<PR & ClearDraftProgress<EP>>>>;
-  usePlugin: (...input: AsyncPlugins<Partial<Progresses2Threads<PR & ClearDraftProgress<EP>>>>) => AsyncManager<EP, PR>;
-  init: (options?: InitOptions) => Promise<Progresses2Runners<PR & ClearDraftProgress<EP>>>;
+} & Required<PluginOptions<Hooks, AsyncSetup<Hooks, API>>>;
+export declare type PluginFromAsyncManager<M extends AsyncManager<any, any>> = M extends AsyncManager<infer Hooks, infer API> ? AsyncPlugin<Hooks, API> : never;
+export declare type AsyncManager<Hooks, API> = {
+  /**
+   * Create a sync plugin.
+   * @param setup the setup function.
+   * @param options optional plugin options.
+   */
+  createPlugin: (setup?: AsyncSetup<Hooks, API>, options?: PluginOptions<Hooks, AsyncSetup<Hooks, API>>) => AsyncPlugin<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: AsyncPlugin<Hooks, API>[] | Array<() => PluginOptions<Hooks, AsyncSetup<Hooks, API>>>) => AsyncManager<Hooks, API>;
+  /**
+   * Init manager, it will call the setup function of all registered plugins.
+   * @param options passing a custom container.
+   */
+
+  init: (options?: InitOptions) => Promise<ToRunners<Hooks>>;
+  /**
+   * Run callback function with current container.
+   * @param callback
+   * @param options passing a custom container.
+   */
+
   run: <O>(cb: () => O, options?: InitOptions) => O;
-  registe: (newShape: Partial<EP>) => void;
-  clone: () => AsyncManager<EP, PR>;
+  /**
+   * 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;
-  useRunner: () => Progresses2Runners<PR & ClearDraftProgress<EP>>;
+  /**
+   * Get all runner functions of the hooks.
+   */
+
+  useRunner: () => ToRunners<Hooks>;
 };
-export declare const createAsyncManager: <EP extends Record<string, any> = {}, PR extends void | ProgressRecord = void>(processes?: PR | undefined) => AsyncManager<EP, PR>;
+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>;
 export {};

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

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

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

@@ -1,50 +1,81 @@
-import { Middleware, Pipeline, AsyncPipeline, MaybeAsync, Container } from 'farrow-pipeline';
-import { Waterfall, Brook, AsyncWaterfall, AsyncBrook } from '../waterfall';
-import { Worker, Workflow, AsyncWorker, AsyncWorkflow, ParallelWorkflow } from '../workflow';
-export declare type Initializer<O> = () => O | void;
+import { Container } from 'farrow-pipeline';
+import type { Hook, CommonAPI, ToRunners, ToThreads, InitOptions, PluginOptions } from './types';
+/** Setup function of sync plugin. */
+
+export declare type Setup<Hooks, API = Record<string, never>> = (api: API) => Partial<ToThreads<Hooks>> | void;
 declare const SYNC_PLUGIN_SYMBOL = "SYNC_PLUGIN_SYMBOL";
-export declare type Plugin<O> = {
-  initializer: Initializer<O>;
+export declare type Plugin<Hooks, API> = {
   SYNC_PLUGIN_SYMBOL: typeof SYNC_PLUGIN_SYMBOL;
-} & Required<PluginOptions>;
-export declare type IndexPlugin<O> = Plugin<O> & {
-  index: number;
-};
-export declare type Plugins<O> = Plugin<O>[];
-export declare type IndexPlugins<O> = IndexPlugin<O>[];
-export declare type PluginOptions = {
-  name?: string;
-  pre?: string[];
-  post?: string[];
-  rivals?: string[];
-  required?: string[];
-};
-export declare type Progress = Waterfall<any> | AsyncWaterfall<any> | Workflow<any, any> | AsyncWorkflow<any, any> | ParallelWorkflow<any> | Pipeline<any, any> | AsyncPipeline<any, any>;
-export declare type Progress2Thread<P extends Progress> = P extends Workflow<infer I, infer O> ? Worker<I, O> : P extends AsyncWorkflow<infer I, infer O> ? AsyncWorker<I, O> : P extends ParallelWorkflow<infer I, infer O> ? AsyncWorker<I, O> : P extends Waterfall<infer I> ? Brook<I> : P extends AsyncWaterfall<infer I> ? AsyncBrook<I> : P extends Pipeline<infer I, infer O> ? Middleware<I, O> : P extends AsyncPipeline<infer I, infer O> ? Middleware<I, MaybeAsync<O>> : never;
-export declare type ProgressRecord = Record<string, Progress>;
-export declare type Progresses2Threads<PS extends ProgressRecord | void> = { [K in keyof PS]: PS[K] extends Progress ? Progress2Thread<PS[K]> : PS[K] extends void ? void : never };
-export declare type RunnerFromProgress<P extends Progress> = P extends Waterfall<infer I> ? Waterfall<I>['run'] : P extends AsyncWaterfall<infer I> ? AsyncWaterfall<I>['run'] : P extends Workflow<infer I, infer O> ? Workflow<I, O>['run'] : P extends AsyncWorkflow<infer I, infer O> ? AsyncWorkflow<I, O>['run'] : P extends ParallelWorkflow<infer I, infer O> ? ParallelWorkflow<I, O>['run'] : P extends Pipeline<infer I, infer O> ? Pipeline<I, O>['run'] : P extends AsyncPipeline<infer I, infer O> ? AsyncPipeline<I, O>['run'] : never;
-export declare type Progresses2Runners<PS extends ProgressRecord | void> = { [K in keyof PS]: PS[K] extends Progress ? RunnerFromProgress<PS[K]> : PS[K] extends void ? void : never };
-export declare type ClearDraftProgress<I extends Record<string, any>> = { [K in keyof I]: I[K] extends Progress ? I[K] : never };
-export declare type PluginFromManager<M extends Manager<any, any>> = M extends Manager<infer EP, infer PR> ? Plugin<Partial<Progresses2Threads<PR & ClearDraftProgress<EP>>>> : never;
-export declare type InitOptions = {
-  container?: Container;
-};
-export declare type Manager<EP extends Record<string, any>, PR extends ProgressRecord | void = void> = {
-  createPlugin: (initializer: Initializer<Partial<Progresses2Threads<PR & ClearDraftProgress<EP>>>>, options?: PluginOptions) => Plugin<Partial<Progresses2Threads<PR & ClearDraftProgress<EP>>>>;
-  isPlugin: (input: Record<string, unknown>) => input is Plugin<Partial<Progresses2Threads<PR & ClearDraftProgress<EP>>>>;
-  usePlugin: (...input: Plugins<Partial<Progresses2Threads<PR & ClearDraftProgress<EP>>>>) => Manager<EP, PR>;
-  init: (options?: InitOptions) => Progresses2Runners<PR & ClearDraftProgress<EP>>;
+} & Required<PluginOptions<Hooks, Setup<Hooks, API>>>;
+export declare type PluginFromManager<M extends Manager<any, any>> = M extends Manager<infer Hooks, infer API> ? Plugin<Hooks, API> : never;
+export declare type Manager<Hooks, API> = {
+  /**
+   * Create a sync plugin.
+   * @param setup the setup function.
+   * @param options optional plugin options.
+   */
+  createPlugin: (setup?: Setup<Hooks, API>, options?: PluginOptions<Hooks, Setup<Hooks, API>>) => Plugin<Hooks, API>;
+  /**
+   * Determine if a value is a sync plugin.
+   * @param input
+   */
+
+  isPlugin: (input: unknown) => input is Plugin<Hooks, API>;
+  /**
+   * Register new plugins to current manager.
+   * @param plugins one or more plugin.
+   */
+
+  usePlugin: (...plugins: Plugin<Hooks, API>[] | Array<() => PluginOptions<Hooks, Setup<Hooks, API>>>) => Manager<Hooks, API>;
+  /**
+   * Init manager, it will call the setup function of all registered plugins.
+   * @param options passing a custom container.
+   */
+
+  init: (options?: InitOptions) => ToRunners<Hooks>;
+  /**
+   * Run callback function with current container.
+   * @param callback
+   * @param options passing a custom container.
+   */
+
   run: <O>(cb: () => O, options?: InitOptions) => O;
-  registe: (newShape: Partial<EP>) => void;
+  /**
+   * Register new hooks.
+   * @param newHooks
+   */
+
+  registerHook: (hewHooks: Partial<Hooks>) => void;
+  /**
+   * Clear all registered plugins.
+   */
+
   clear: () => void;
-  clone: () => Manager<EP, PR>;
-  useRunner: () => Progresses2Runners<PR & ClearDraftProgress<EP>>;
+  /**
+   * Return a cloned manager.
+   * @param overrideAPI override the default plugin API.
+   */
+
+  clone: (overrideAPI?: Partial<API & CommonAPI<Hooks>>) => Manager<Hooks, API>;
+  /**
+   * Get all runner functions of the hooks.
+   */
+
+  useRunner: () => ToRunners<Hooks>;
+};
+export declare const DEFAULT_OPTIONS: {
+  name: string;
+  pre: never[];
+  post: never[];
+  rivals: never[];
+  required: never[];
+  usePlugins: never[];
+  registerHook: {};
 };
-export declare const DEFAULT_OPTIONS: Required<PluginOptions>;
-export declare const createManager: <EP extends Record<string, any> = {}, PR extends void | ProgressRecord = void>(processes?: PR | undefined) => Manager<EP, PR>;
-export declare const generateRunner: <EP extends Record<string, any> = {}, PR extends void | ProgressRecord = void>(hooksList: (void | Partial<Progresses2Threads<PR & ClearDraftProgress<EP>>>)[], container: Container, processes?: PR | undefined) => Progresses2Runners<PR & ClearDraftProgress<EP>>;
-export declare const cloneProgress: (progress: Progress) => Progress;
-export declare const cloneProgressRecord: <PR extends void | ProgressRecord>(record: PR) => PR;
+export declare const createManager: <Hooks, API extends Record<string, any> = Record<string, never>>(hooks?: Partial<Hooks> | undefined, api?: API | undefined) => Manager<Hooks, API>;
+export declare const generateRunner: <Hooks extends Record<string, any>>(hooksList: (void | Partial<ToThreads<Hooks>>)[], container: Container, hooksMap?: Hooks | undefined) => ToRunners<Hooks>;
+export declare const cloneHook: (hook: Hook) => Hook;
+export declare const closeHooksMap: <Hooks>(record: Hooks) => Hooks;
+export declare const isObject: (obj: unknown) => obj is Record<string, any>;
 export declare const hasOwnProperty: <X extends Record<string, unknown>, Y extends PropertyKey>(obj: X, prop: Y) => obj is X & Record<Y, unknown>;
 export {};