@modern-js/plugin 1.3.6 → 1.4.0-alpha.0

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

@@ -1,11 +1,10 @@
-import _typeof from "@babel/runtime/helpers/esm/typeof";
-import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
 import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
 import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
-import { isPipeline, createPipeline, runWithContainer, createContainer } from "../farrow-pipeline";
+import { isPipeline, createPipeline } from "../farrow-pipeline";
 import { isWaterfall, createWaterfall, isAsyncWaterfall, createAsyncWaterfall } from "../waterfall";
 import { isWorkflow, createWorkflow, isAsyncWorkflow, createAsyncWorkflow, isParallelWorkflow, createParallelWorkflow } from "../workflow";
 import { RunnerContext, useRunner } from "./runner";
+import { checkPlugins, hasOwnProperty, includePlugin, isObject, sortPlugins } from "./shared";
 var SYNC_PLUGIN_SYMBOL = 'SYNC_PLUGIN_SYMBOL';
 export var DEFAULT_OPTIONS = {
   name: 'untitled',
@@ -47,9 +46,7 @@ export var createManager = function createManager(hooks, api) {
         input[_key] = arguments[_key];
       }
 
-      for (var _i = 0, _input = input; _i < _input.length; _i++) {
-        var plugin = _input[_i];
-
+      input.forEach(function (plugin) {
         // already created by createPlugin
         if (isPlugin(plugin)) {
           addPlugin(plugin);
@@ -65,8 +62,7 @@ export var createManager = function createManager(hooks, api) {
         else {
           console.warn("Unknown plugin: ".concat(JSON.stringify(plugin)));
         }
-      }
-
+      });
       return manager;
     };
 
@@ -98,26 +94,20 @@ export var createManager = function createManager(hooks, api) {
       plugins = [];
     };
 
-    var currentContainer = createContainer();
-
-    var init = function init(options) {
-      var container = (options === null || options === void 0 ? void 0 : options.container) || currentContainer;
+    var init = function init() {
       var sortedPlugins = sortPlugins(plugins);
 
       var mergedPluginAPI = _objectSpread(_objectSpread({}, pluginAPI), overrideAPI);
 
       checkPlugins(sortedPlugins);
       var hooksList = sortedPlugins.map(function (plugin) {
-        return runWithContainer(function () {
-          return plugin.setup(mergedPluginAPI);
-        }, container);
+        return plugin.setup(mergedPluginAPI);
       });
-      return generateRunner(hooksList, container, currentHooks);
+      return generateRunner(hooksList, currentHooks);
     };
 
-    var run = function run(cb, options) {
-      var container = (options === null || options === void 0 ? void 0 : options.container) || currentContainer;
-      return runWithContainer(cb, container);
+    var run = function run(cb) {
+      return cb();
     };
 
     var manager = {
@@ -136,7 +126,7 @@ export var createManager = function createManager(hooks, api) {
 
   return clone();
 };
-export var generateRunner = function generateRunner(hooksList, container, hooksMap) {
+export var generateRunner = function generateRunner(hooksList, hooksMap) {
   var runner = {};
   var cloneShape = closeHooksMap(hooksMap);
 
@@ -166,9 +156,7 @@ export var generateRunner = function generateRunner(hooksList, container, hooksM
       }
 
       runner[key] = function (input, options) {
-        return cloneShape[key].run(input, _objectSpread({
-          container: container
-        }, options));
+        return cloneShape[key].run(input, _objectSpread({}, options));
       };
     };
 
@@ -177,7 +165,7 @@ export var generateRunner = function generateRunner(hooksList, container, hooksM
     }
   }
 
-  container.write(RunnerContext, runner);
+  RunnerContext.set(runner);
   return runner;
 };
 export var cloneHook = function cloneHook(hook) {
@@ -221,148 +209,4 @@ export var closeHooksMap = function closeHooksMap(record) {
   }
 
   return result;
-};
-
-var includePlugin = function includePlugin(plugins, input) {
-  var _iterator2 = _createForOfIteratorHelper(plugins),
-      _step2;
-
-  try {
-    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-      var plugin = _step2.value;
-
-      if (plugin.name === input.name) {
-        return true;
-      }
-    }
-  } catch (err) {
-    _iterator2.e(err);
-  } finally {
-    _iterator2.f();
-  }
-
-  return false;
-};
-
-var sortPlugins = function sortPlugins(input) {
-  var plugins = input.slice();
-
-  for (var i = 0; i < plugins.length; i++) {
-    var plugin = plugins[i];
-
-    var _iterator3 = _createForOfIteratorHelper(plugin.pre),
-        _step3;
-
-    try {
-      for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
-        var pre = _step3.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) {
-      _iterator3.e(err);
-    } finally {
-      _iterator3.f();
-    }
-
-    var _iterator4 = _createForOfIteratorHelper(plugin.post),
-        _step4;
-
-    try {
-      for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
-        var post = _step4.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) {
-      _iterator4.e(err);
-    } finally {
-      _iterator4.f();
-    }
-  }
-
-  return plugins;
-};
-
-var checkPlugins = function checkPlugins(plugins) {
-  var _iterator5 = _createForOfIteratorHelper(plugins),
-      _step5;
-
-  try {
-    for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
-      var origin = _step5.value;
-
-      var _iterator6 = _createForOfIteratorHelper(origin.rivals),
-          _step6;
-
-      try {
-        for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
-          var rival = _step6.value;
-
-          var _iterator8 = _createForOfIteratorHelper(plugins),
-              _step8;
-
-          try {
-            for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
-              var plugin = _step8.value;
-
-              if (rival === plugin.name) {
-                throw new Error("".concat(origin.name, " has rival ").concat(plugin.name));
-              }
-            }
-          } catch (err) {
-            _iterator8.e(err);
-          } finally {
-            _iterator8.f();
-          }
-        }
-      } catch (err) {
-        _iterator6.e(err);
-      } finally {
-        _iterator6.f();
-      }
-
-      var _iterator7 = _createForOfIteratorHelper(origin.required),
-          _step7;
-
-      try {
-        var _loop2 = function _loop2() {
-          var required = _step7.value;
-
-          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."));
-          }
-        };
-
-        for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
-          _loop2();
-        }
-      } catch (err) {
-        _iterator7.e(err);
-      } finally {
-        _iterator7.f();
-      }
-    }
-  } catch (err) {
-    _iterator5.e(err);
-  } finally {
-    _iterator5.f();
-  }
-};
-
-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

@@ -3,7 +3,7 @@ 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, useContainer } from "../farrow-pipeline";
+import { createAsyncPipeline } from "../farrow-pipeline";
 var ASYNC_WATERFALL_SYMBOL = Symbol["for"]('MODERN_ASYNC_WATERFALL');
 export var getAsyncBrook = function getAsyncBrook(input) {
   if (typeof input === 'function') {
@@ -35,9 +35,7 @@ export var createAsyncWaterfall = function createAsyncWaterfall() {
   };
 
   var middleware = function middleware(input) {
-    var container = useContainer();
     return pipeline.run(input, {
-      container: container,
       onLast: function onLast(input) {
         return input;
       }

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

@@ -1,7 +1,7 @@
 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 { useContainer, createPipeline } from "../farrow-pipeline";
+import { createPipeline } from "../farrow-pipeline";
 var WATERFALL_SYMBOL = Symbol["for"]('MODERN_WATERFALL');
 export var getBrook = function getBrook(input) {
   if (typeof input === 'function') {
@@ -33,9 +33,7 @@ export var createWaterfall = function createWaterfall() {
   };
 
   var middleware = function middleware(input) {
-    var container = useContainer();
     return pipeline.run(input, {
-      container: container,
       onLast: function onLast(input) {
         return input;
       }

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

@@ -1,7 +1,7 @@
 import _typeof from "@babel/runtime/helpers/esm/typeof";
 import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
 import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
 import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
 import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
 import { createAsyncPipeline } from "../farrow-pipeline";
@@ -22,17 +22,17 @@ export var createAsyncWorkflow = function createAsyncWorkflow() {
   };
 
   var run = /*#__PURE__*/function () {
-    var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(input, options) {
+    var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(input) {
       var result;
       return _regeneratorRuntime().wrap(function _callee$(_context) {
         while (1) {
           switch (_context.prev = _context.next) {
             case 0:
-              result = pipeline.run(input, _objectSpread(_objectSpread({}, options), {}, {
+              result = pipeline.run(input, {
                 onLast: function onLast() {
                   return [];
                 }
-              }));
+              });
 
               if (!isPromise(result)) {
                 _context.next = 5;
@@ -54,7 +54,7 @@ export var createAsyncWorkflow = function createAsyncWorkflow() {
       }, _callee);
     }));
 
-    return function run(_x, _x2) {
+    return function run(_x) {
       return _ref.apply(this, arguments);
     };
   }();
@@ -97,7 +97,7 @@ var mapAsyncWorkerToAsyncMiddleware = function mapAsyncWorkerToAsyncMiddleware(w
       }, _callee2);
     }));
 
-    return function (_x3, _x4) {
+    return function (_x2, _x3) {
       return _ref2.apply(this, arguments);
     };
   }();

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

@@ -1,6 +1,6 @@
 import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
 import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
 import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
 import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
 import { createPipeline } from "../farrow-pipeline";
@@ -21,16 +21,16 @@ export var createParallelWorkflow = function createParallelWorkflow() {
   };
 
   var run = /*#__PURE__*/function () {
-    var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(input, options) {
+    var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(input) {
       return _regeneratorRuntime().wrap(function _callee$(_context) {
         while (1) {
           switch (_context.prev = _context.next) {
             case 0:
-              return _context.abrupt("return", Promise.all(pipeline.run(input, _objectSpread(_objectSpread({}, options), {}, {
+              return _context.abrupt("return", Promise.all(pipeline.run(input, {
                 onLast: function onLast() {
                   return [];
                 }
-              }))).then(function (result) {
+              })).then(function (result) {
                 return result.filter(Boolean);
               }));
 
@@ -42,7 +42,7 @@ export var createParallelWorkflow = function createParallelWorkflow() {
       }, _callee);
     }));
 
-    return function run(_x, _x2) {
+    return function run(_x) {
       return _ref.apply(this, arguments);
     };
   }();

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

@@ -1,7 +1,5 @@
 import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
 import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
-import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
 import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
 import { createPipeline } from "../farrow-pipeline";
 var WORKFLOW_SYMBOL = Symbol["for"]('MODERN_WORKFLOW');
@@ -17,32 +15,14 @@ export var createWorkflow = function createWorkflow() {
     return workflow;
   };
 
-  var run = /*#__PURE__*/function () {
-    var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(input, options) {
-      var result;
-      return _regeneratorRuntime().wrap(function _callee$(_context) {
-        while (1) {
-          switch (_context.prev = _context.next) {
-            case 0:
-              result = pipeline.run(input, _objectSpread(_objectSpread({}, options), {}, {
-                onLast: function onLast() {
-                  return [];
-                }
-              }));
-              return _context.abrupt("return", result.filter(Boolean));
-
-            case 2:
-            case "end":
-              return _context.stop();
-          }
-        }
-      }, _callee);
-    }));
-
-    return function run(_x, _x2) {
-      return _ref.apply(this, arguments);
-    };
-  }();
+  var run = function run(input) {
+    var result = pipeline.run(input, {
+      onLast: function onLast() {
+        return [];
+      }
+    });
+    return result.filter(Boolean);
+  };
 
   var workflow = _objectSpread(_objectSpread({}, pipeline), {}, _defineProperty({
     use: use,

package/dist/types/farrow-pipeline/context.d.ts

@@ -1,7 +1,8 @@
-declare const ContextSymbol: unique symbol;
+/**
+ * modified from https://github.com/farrow-js/farrow/tree/master/packages/farrow-pipeline
+ * license at https://github.com/farrow-js/farrow/blob/master/LICENSE
+ */
 export declare type Context<T = any> = {
-  id: symbol;
-  [ContextSymbol]: T;
   create: (value: T) => Context<T>;
   use: () => {
     value: T;
@@ -9,20 +10,4 @@ export declare type Context<T = any> = {
   get: () => T;
   set: (value: T) => void;
 };
-export declare const createContext: <T>(value: T) => Context<T>;
-export declare type ContextStorage = {
-  [key: string]: Context;
-};
-export declare type Container = {
-  read: <V>(Context: Context<V>) => V;
-  write: <V>(Context: Context<V>, value: V) => void;
-};
-export declare const createContainer: (ContextStorage?: ContextStorage) => Container;
-export declare type Hooks = {
-  useContainer: () => Container;
-};
-export declare const runHooks: <F extends import("./asyncHooksInterface").AnyFn>(f: F, implementations: Hooks) => ReturnType<F>;
-export declare const useContainer: () => Container;
-export declare const fromContainer: (container: Container) => Hooks;
-export declare const runWithContainer: <F extends (...args: any) => any>(f: F, container: Container) => ReturnType<F>;
-export {};
+export declare const createContext: <T>(value: T) => Context<T>;

package/dist/types/farrow-pipeline/index.d.ts

@@ -1,19 +1,5 @@
 /**
  * modified from https://github.com/farrow-js/farrow/tree/master/packages/farrow-pipeline
  * license at https://github.com/farrow-js/farrow/blob/master/LICENSE
- *
- * removed:
- *  - dependencies:
- *    - tslib
- *  - files
- *    - compose.ts
- *  - methods:
- *    - usePipeline
- *    - assertContainer
- *    - assertContext
- *    - isContext
- *    - isContainer
- *    - pipeline.useLazy
- *    - context.assert
  */
 export * from './pipeline';

package/dist/types/farrow-pipeline/pipeline.d.ts

@@ -2,37 +2,28 @@
  * 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, createContainer, ContextStorage, Context, Container, useContainer, runWithContainer } from './context';
+import { createContext, Context } from './context';
 import { Next } from './counter';
 export type { Next };
-export { createContext, createContainer, useContainer, runWithContainer };
-export type { ContextStorage, Context, Container };
+export { createContext };
+export type { Context };
 export declare type Middleware<I = unknown, O = unknown> = (input: I, next: Next<I, O>) => O;
 export declare type Middlewares<I = unknown, O = unknown> = Middleware<I, O>[];
 export declare const isPipeline: (input: any) => input is Pipeline<unknown, unknown>;
 declare const PipelineSymbol: unique symbol;
-export declare type PipelineOptions = {
-  contexts?: ContextStorage;
-};
 export declare type RunPipelineOptions<I = unknown, O = unknown> = {
-  container?: Container;
   onLast?: (input: I) => O;
-  onLastWithContext?: boolean;
 };
 export declare type MiddlewareInput<I = unknown, O = unknown> = Middleware<I, O> | {
   middleware: Middleware<I, O>;
 };
-export declare type MiddlewareType<T extends MiddlewareInput> = T extends MiddlewareInput<infer I, infer O> ? Middleware<I, O> : never;
 export declare type Pipeline<I = unknown, O = unknown> = {
   [PipelineSymbol]: true;
   use: (...inputs: MiddlewareInput<I, O>[]) => Pipeline<I, O>;
   run: (input: I, options?: RunPipelineOptions<I, O>) => O;
   middleware: Middleware<I, O>;
 };
-export declare const createPipeline: <I, O>(options?: PipelineOptions | undefined) => Pipeline<I, O>;
-export declare type PipelineInput<T extends Pipeline> = T extends Pipeline<infer I> ? I : never;
-export declare type PipelineOutput<T extends Pipeline> = T extends Pipeline<any, infer O> ? O : never;
+export declare const createPipeline: <I, O>() => Pipeline<I, O>;
 export declare type MaybeAsync<T> = T | Promise<T>;
-export declare type ThunkMiddlewareInput<I, O> = () => MaybeAsync<MiddlewareInput<I, MaybeAsync<O>>>;
 export declare type AsyncPipeline<I = unknown, O = unknown> = Pipeline<I, MaybeAsync<O>>;
-export declare const createAsyncPipeline: <I, O>(options?: PipelineOptions | undefined) => AsyncPipeline<I, O>;
+export declare const createAsyncPipeline: <I, O>() => AsyncPipeline<I, O>;

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

@@ -1,4 +1,4 @@
-import type { ToRunners, ToThreads, CommonAPI, InitOptions, PluginOptions } from './types';
+import type { ToRunners, ToThreads, CommonAPI, 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;
@@ -6,7 +6,6 @@ declare const ASYNC_PLUGIN_SYMBOL = "ASYNC_PLUGIN_SYMBOL";
 export declare type AsyncPlugin<Hooks, API> = {
   ASYNC_PLUGIN_SYMBOL: typeof ASYNC_PLUGIN_SYMBOL;
 } & 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.
@@ -28,17 +27,15 @@ export declare type AsyncManager<Hooks, API> = {
   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>>;
+  init: () => Promise<ToRunners<Hooks>>;
   /**
-   * Run callback function with current container.
+   * Run callback function.
    * @param callback
-   * @param options passing a custom container.
    */
 
-  run: <O>(cb: () => O, options?: InitOptions) => O;
+  run: <O>(cb: () => O) => O;
   /**
    * Register new hooks.
    * @param newHooks

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

@@ -0,0 +1,12 @@
+import type { AsyncPlugin } from './async';
+import type { Plugin } from './sync';
+export declare const checkPlugins: <Hooks, API>(plugins: Plugin<Hooks, API>[] | AsyncPlugin<Hooks, API>[]) => void;
+export declare function sortPlugins<Hooks, API>(input: Plugin<Hooks, API>[]): Plugin<Hooks, API>[];
+export declare function sortPlugins<Hooks, API>(input: AsyncPlugin<Hooks, API>[]): AsyncPlugin<Hooks, API>[];
+export declare const includePlugin: <P extends {
+  name: string;
+}, I extends {
+  name: string;
+}>(plugins: P[], input: I) => boolean;
+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>;

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

@@ -1,5 +1,4 @@
-import { Container } from '../farrow-pipeline';
-import type { Hook, CommonAPI, ToRunners, ToThreads, InitOptions, PluginOptions } from './types';
+import type { Hook, CommonAPI, ToRunners, ToThreads, PluginOptions } from './types';
 /** Setup function of sync plugin. */
 
 export declare type Setup<Hooks, API = Record<string, never>> = (api: API) => Partial<ToThreads<Hooks>> | void;
@@ -7,7 +6,6 @@ declare const SYNC_PLUGIN_SYMBOL = "SYNC_PLUGIN_SYMBOL";
 export declare type Plugin<Hooks, API> = {
   SYNC_PLUGIN_SYMBOL: typeof SYNC_PLUGIN_SYMBOL;
 } & 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.
@@ -29,17 +27,15 @@ export declare type Manager<Hooks, API> = {
   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>;
+  init: () => ToRunners<Hooks>;
   /**
-   * Run callback function with current container.
+   * Run callback function.
    * @param callback
-   * @param options passing a custom container.
    */
 
-  run: <O>(cb: () => O, options?: InitOptions) => O;
+  run: <O>(cb: () => O) => O;
   /**
    * Register new hooks.
    * @param newHooks
@@ -73,9 +69,7 @@ export declare const DEFAULT_OPTIONS: {
   registerHook: {};
 };
 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 generateRunner: <Hooks extends Record<string, any>>(hooksList: (void | Partial<ToThreads<Hooks>>)[], 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

@@ -1,4 +1,4 @@
-import type { Pipeline, Container, MaybeAsync, Middleware, AsyncPipeline } from '../farrow-pipeline';
+import type { Pipeline, 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. */
@@ -29,11 +29,6 @@ export declare type PluginOptions<Hooks, Setup = undefined> = {
   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> = {

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

@@ -1,4 +1,4 @@
-import { MaybeAsync, Container } from '../farrow-pipeline';
+import { MaybeAsync } from '../farrow-pipeline';
 declare const ASYNC_WATERFALL_SYMBOL: unique symbol;
 export declare type AsyncBrook<I = unknown> = (I: I) => MaybeAsync<I>;
 export declare type AsyncBrookInput<I = unknown> = AsyncBrook<I> | {
@@ -8,7 +8,6 @@ export declare type AsyncBrooks<I = unknown> = AsyncBrook<I>[];
 export declare type AsyncBrookInputs<I = unknown> = AsyncBrookInput<I>[];
 export declare const getAsyncBrook: <I>(input: AsyncBrookInput<I>) => AsyncBrook<I>;
 export declare type RunAsyncWaterfallOptions<I = unknown> = {
-  container?: Container;
   onLast?: AsyncBrook<I>;
 };
 export declare type AsyncWaterfall<I> = {
@@ -17,11 +16,6 @@ export declare type AsyncWaterfall<I> = {
   middleware: AsyncBrook<I>;
   [ASYNC_WATERFALL_SYMBOL]: true;
 };
-export declare type AsyncWaterfall2AsyncBrook<P extends AsyncWaterfall<any>> = P extends AsyncWaterfall<infer I> ? AsyncBrook<I> : never;
-export declare type AsyncWaterfallRecord = Record<string, AsyncWaterfall<any>>;
-export declare type AsyncWaterfalls2Brooks<PS extends AsyncWaterfallRecord | void> = { [K in keyof PS]: PS[K] extends AsyncWaterfall<any> ? AsyncWaterfall2AsyncBrook<PS[K]> : PS[K] extends void ? void : never };
-export declare type RunnerFromAsyncWaterfall<M extends AsyncWaterfall<any>> = M extends AsyncWaterfall<infer VS> ? AsyncWaterfall<VS>['run'] : never;
-export declare type AsyncWaterfalls2Runners<PS extends AsyncWaterfallRecord | void> = { [K in keyof PS]: PS[K] extends AsyncWaterfall<any> ? RunnerFromAsyncWaterfall<PS[K]> : PS[K] extends void ? void : never };
 export declare const createAsyncWaterfall: <I = void>() => AsyncWaterfall<I>;
 export declare const isAsyncWaterfall: (input: any) => input is AsyncWaterfall<any>;
 export {};