@modern-js/plugin 1.2.1 → 1.3.2

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."); }
@@ -18,47 +20,46 @@ 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; }
 
-// 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];
@@ -67,30 +68,48 @@ export var createManager = function createManager(processes) {
       for (var _i = 0, _input = input; _i < _input.length; _i++) {
         var plugin = _input[_i];
 
+        // 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: ".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 object
+        else if (isObject(plugin)) {
+          addPlugin(createPlugin(plugin.setup, plugin));
+        } // unknown plugin
+        else {
+          console.warn("Unknown plugin: ".concat(JSON.stringify(plugin)));
         }
       }
 
-      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 +121,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 +138,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 +172,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 +198,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 +236,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 +379,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

@@ -34,7 +34,6 @@ export var getAsyncBrook = function getAsyncBrook(input) {
 
   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();
 

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

@@ -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

@@ -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/sync.js

@@ -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: Array<AsyncPlugin<Hooks, API> | PluginOptions<Hooks, AsyncSetup<Hooks, API>> | (() => PluginOptions<Hooks, AsyncSetup<Hooks, API>>)>) => AsyncManager<Hooks, API>;
+  /**
+   * Init manager, it will call the setup function of all registered plugins.
+   * @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: Array<Plugin<Hooks, API> | PluginOptions<Hooks, Setup<Hooks, API>> | (() => 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 {};

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

@@ -0,0 +1,41 @@
+import type { Pipeline, Container, MaybeAsync, Middleware, AsyncPipeline } from 'farrow-pipeline';
+import type { Brook, Waterfall, AsyncBrook, AsyncWaterfall } from '../waterfall';
+import type { Worker, Workflow, AsyncWorker, AsyncWorkflow, ParallelWorkflow } from '../workflow';
+/** All hook types. */
+
+export declare type Hook = Waterfall<any> | AsyncWaterfall<any> | Workflow<any, any> | AsyncWorkflow<any, any> | ParallelWorkflow<any> | Pipeline<any, any> | AsyncPipeline<any, any>;
+export declare type HooksMap = Record<string, Hook>;
+/** Extract the type of callback function from a hook. */
+
+export declare type ToThread<P extends Hook> = 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;
+/** Extract types of callback function from hooks. */
+
+export declare type ToThreads<PS> = { [K in keyof PS]: PS[K] extends Hook ? ToThread<PS[K]> : PS[K] extends void ? void : never };
+/** Extract run method from a hook. */
+
+export declare type RunnerFromHook<P extends Hook> = 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;
+/** Extract all run methods from hooks. */
+
+export declare type ToRunners<PS> = { [K in keyof PS]: PS[K] extends Hook ? RunnerFromHook<PS[K]> : PS[K] extends void ? void : never };
+/** All options to define a plugin. */
+
+export declare type PluginOptions<Hooks, Setup = undefined> = {
+  name?: string;
+  pre?: string[];
+  post?: string[];
+  setup?: Setup;
+  rivals?: string[];
+  required?: string[];
+  usePlugins?: PluginOptions<Hooks, Setup>[];
+  registerHook?: Partial<Hooks>;
+};
+/** Options of manager.init method. */
+
+export declare type InitOptions = {
+  container?: Container;
+};
+/** Common api of setup function. */
+
+export declare type CommonAPI<Hooks> = {
+  useHookRunners: () => ToRunners<Hooks>;
+};

package/package.json

@@ -11,7 +11,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "1.2.1",
+  "version": "1.3.2",
   "jsnext:source": "./src/index.ts",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/js/node/index.js",
@@ -46,11 +46,11 @@
   "sideEffects": false,
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",
-    "access": "public",
-    "types": "./dist/types/index.d.ts"
+    "access": "public"
   },
   "scripts": {
     "new": "modern new",
+    "dev": "modern build --watch",
     "build": "modern build",
     "test": "jest --passWithNoTests"
   },