@modern-js/plugin 1.2.0 → 1.2.1

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @modern-js/plugin
 
+## 1.2.1
+
+### Patch Changes
+
+- 83166714: change .npmignore
+
 ## 1.2.0
 
 ### Minor Changes

package/dist/js/modern/waterfall/async.js

@@ -9,8 +9,8 @@ const ASYNC_WATERFALL_SYMBOL = Symbol('ASYNC_WATERFALL_SYMBOL');
 export const getAsyncBrook = input => {
   if (typeof input === 'function') {
     return input;
-  } else if (input && typeof input.middlware === 'function') {
-    return input.middlware;
+  } else if (input && typeof input.middleware === 'function') {
+    return input.middleware;
   } // eslint-disable-next-line @typescript-eslint/no-base-to-string,@typescript-eslint/restrict-template-expressions
 
 
@@ -30,7 +30,7 @@ export const createAsyncWaterfall = () => {
     onLast: input => input
   }));
 
-  const middlware = input => {
+  const middleware = input => {
     // eslint-disable-next-line react-hooks/rules-of-hooks
     const container = useContainer(); // eslint-disable-next-line @typescript-eslint/no-shadow
 
@@ -43,7 +43,7 @@ export const createAsyncWaterfall = () => {
   const waterfall = _objectSpread(_objectSpread({}, pipeline), {}, {
     use,
     run,
-    middlware,
+    middleware,
     [ASYNC_WATERFALL_SYMBOL]: true
   });
 

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

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

package/dist/js/treeshaking/waterfall/async.js

@@ -27,8 +27,8 @@ 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
 
 
@@ -57,7 +57,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 +72,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/types/waterfall/async.d.ts

@@ -2,7 +2,7 @@ import { MaybeAsync, Container } 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> | {
-  middlware: AsyncBrook<I>;
+  middleware: AsyncBrook<I>;
 };
 export declare type AsyncBrooks<I = unknown> = AsyncBrook<I>[];
 export declare type AsyncBrookInputs<I = unknown> = AsyncBrookInput<I>[];
@@ -14,7 +14,7 @@ export declare type RunAsyncWaterfallOptions<I = unknown> = {
 export declare type AsyncWaterfall<I> = {
   run: (input: I, options?: RunAsyncWaterfallOptions<I>) => MaybeAsync<I>;
   use: (...I: AsyncBrookInputs<I>) => AsyncWaterfall<I>;
-  middlware: AsyncBrook<I>;
+  middleware: AsyncBrook<I>;
   [ASYNC_WATERFALL_SYMBOL]: true;
 };
 export declare type AsyncWaterfall2AsyncBrook<P extends AsyncWaterfall<any>> = P extends AsyncWaterfall<infer I> ? AsyncBrook<I> : never;

package/package.json

@@ -11,7 +11,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "1.2.0",
+  "version": "1.2.1",
   "jsnext:source": "./src/index.ts",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/js/node/index.js",

package/src/index.ts

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

package/src/manager/async.ts

@@ -1,248 +0,0 @@
-import { runWithContainer, createContainer } from 'farrow-pipeline';
-import {
-  ProgressRecord,
-  Progresses2Threads,
-  Progresses2Runners,
-  PluginOptions,
-  ClearDraftProgress,
-  InitOptions,
-  generateRunner,
-  hasOwnProperty,
-  DEFAULT_OPTIONS,
-} from './sync';
-import { useRunner } from './runner';
-
-// eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-export type AsyncInitializer<O> = () => void | O | Promise<O | void>;
-
-const ASYNC_PLUGIN_SYMBOL = 'ASYNC_PLUGIN_SYMBOL';
-
-export type AsyncPlugin<O> = {
-  initializer: AsyncInitializer<O>;
-  ASYNC_PLUGIN_SYMBOL: typeof ASYNC_PLUGIN_SYMBOL;
-} & Required<PluginOptions>;
-
-export type IndexAsyncPlugin<O> = AsyncPlugin<O> & {
-  index: number;
-};
-
-export type AsyncPlugins<O> = AsyncPlugin<O>[];
-export type AsyncIndexPlugins<O> = IndexAsyncPlugin<O>[];
-
-export type AsyncPluginFromAsyncManager<M extends AsyncManager<any, any>> =
-  M extends AsyncManager<infer EP, infer PR>
-    ? AsyncPlugin<Partial<Progresses2Threads<PR & ClearDraftProgress<EP>>>>
-    : never;
-
-export type PluginFromAsyncManager<M extends AsyncManager<any, any>> =
-  M extends AsyncManager<infer EP, infer PR>
-    ? AsyncPlugin<Partial<Progresses2Threads<PR & ClearDraftProgress<EP>>>>
-    : never;
-
-export type AsyncManager<
-  EP extends Record<string, any>,
-  // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-  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>>>;
-  run: <O>(cb: () => O, options?: InitOptions) => O;
-  registe: (newShape: Partial<EP>) => void;
-  clone: () => AsyncManager<EP, PR>;
-  clear: () => void;
-  useRunner: () => Progresses2Runners<PR & ClearDraftProgress<EP>>;
-};
-
-export const createAsyncManager = <
-  // eslint-disable-next-line @typescript-eslint/ban-types
-  EP extends Record<string, any> = {},
-  // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-  PR extends ProgressRecord | void = void,
->(
-  processes?: PR,
-): AsyncManager<EP, PR> => {
-  let index = 0;
-  const createPlugin: AsyncManager<EP, PR>['createPlugin'] = (
-    initializer,
-    options = {},
-  ) => ({
-    ...DEFAULT_OPTIONS,
-    name: `No.${index++} plugin`,
-    ...options,
-    ASYNC_PLUGIN_SYMBOL,
-    initializer,
-  });
-
-  const isPlugin: AsyncManager<EP, PR>['isPlugin'] = (
-    input,
-  ): input is AsyncPlugin<
-    Partial<Progresses2Threads<PR & ClearDraftProgress<EP>>>
-  > =>
-    hasOwnProperty(input, ASYNC_PLUGIN_SYMBOL) &&
-    input[ASYNC_PLUGIN_SYMBOL] === ASYNC_PLUGIN_SYMBOL;
-
-  const registe: AsyncManager<EP, PR>['registe'] = extraProcesses => {
-    // eslint-disable-next-line no-param-reassign
-    processes = {
-      ...extraProcesses,
-      ...processes,
-    } as any;
-  };
-
-  const clone = () => {
-    let plugins: AsyncIndexPlugins<
-      Partial<Progresses2Threads<PR & ClearDraftProgress<EP>>>
-    > = [];
-
-    const usePlugin: AsyncManager<EP, PR>['usePlugin'] = (...input) => {
-      for (const plugin of input) {
-        if (isPlugin(plugin)) {
-          if (!includeAsyncPlugin(plugins, plugin)) {
-            plugins.push({
-              ...plugin,
-              index: plugins.length,
-            });
-          }
-        } else {
-          // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-          // @ts-expect-error
-          console.warn(`Unknown plugin: ${plugin.name}`);
-        }
-      }
-
-      return manager;
-    };
-
-    const clear = () => {
-      plugins = [];
-    };
-
-    const currentContainer = createContainer();
-
-    const init: AsyncManager<EP, PR>['init'] = async options => {
-      const container = options?.container || currentContainer;
-
-      const sortedPlugins = sortAsyncPlugins(plugins);
-
-      checkAsyncPlugins(sortedPlugins);
-
-      const hooksList = await Promise.all(
-        sortedPlugins.map(plugin =>
-          runWithContainer(() => plugin.initializer(), container),
-        ),
-      );
-
-      return generateRunner<EP, PR>(hooksList, container, processes);
-    };
-
-    const run: AsyncManager<EP, PR>['run'] = (cb, options) => {
-      const container = options?.container || currentContainer;
-
-      return runWithContainer(cb, container);
-    };
-
-    const manager = {
-      createPlugin,
-      isPlugin,
-      usePlugin,
-      init,
-      run,
-      clear,
-      clone,
-      registe,
-      useRunner,
-    };
-
-    return manager;
-  };
-
-  return clone();
-};
-
-const includeAsyncPlugin = <O>(
-  plugins: AsyncPlugins<O>,
-  input: AsyncPlugin<O>,
-): boolean => {
-  for (const plugin of plugins) {
-    if (plugin.name === input.name) {
-      return true;
-    }
-  }
-
-  return false;
-};
-
-const sortAsyncPlugins = <O>(
-  input: AsyncIndexPlugins<O>,
-): AsyncIndexPlugins<O> => {
-  let plugins = input.slice();
-
-  for (let i = 0; i < plugins.length; i++) {
-    const plugin = plugins[i];
-
-    for (const pre of plugin.pre) {
-      for (let j = i + 1; j < plugins.length; j++) {
-        if (plugins[j].name === pre) {
-          plugins = [
-            ...plugins.slice(0, i),
-            plugins[j],
-            ...plugins.slice(i, j),
-            ...plugins.slice(j + 1, plugins.length),
-          ];
-        }
-      }
-    }
-
-    for (const post of plugin.post) {
-      for (let j = 0; j < i; j++) {
-        if (plugins[j].name === post) {
-          plugins = [
-            ...plugins.slice(0, j),
-            ...plugins.slice(j + 1, i + 1),
-            plugins[j],
-            ...plugins.slice(i + 1, plugins.length),
-          ];
-        }
-      }
-    }
-  }
-
-  return plugins;
-};
-
-const checkAsyncPlugins = <O>(plugins: AsyncIndexPlugins<O>) => {
-  for (const origin of plugins) {
-    for (const rival of origin.rivals) {
-      for (const plugin of plugins) {
-        if (rival === plugin.name) {
-          throw new Error(`${origin.name} has rival ${plugin.name}`);
-        }
-      }
-    }
-
-    for (const required of origin.required) {
-      if (!plugins.some(plugin => plugin.name === required)) {
-        throw new Error(
-          `The plugin: ${required} is required when plugin: ${origin.name} is exist.`,
-        );
-      }
-    }
-  }
-};

package/src/manager/index.ts

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

package/src/manager/runner.ts

@@ -1,15 +0,0 @@
-import { createContext } from 'farrow-pipeline';
-
-export const RunnerContext = createContext<any>(null);
-
-export const useRunner = () => {
-  const runner = RunnerContext.use().value;
-
-  if (!runner) {
-    throw new Error(
-      `Can't call useRunner out of scope, it should be placed in hooks of plugin`,
-    );
-  }
-
-  return runner;
-};

package/src/manager/sync.ts

@@ -1,458 +0,0 @@
-// eslint-disable-next-line eslint-comments/disable-enable-pair
-/* eslint-disable max-lines */
-import {
-  Middleware,
-  Pipeline,
-  isPipeline,
-  createPipeline,
-  AsyncPipeline,
-  MaybeAsync,
-  runWithContainer,
-  createContainer,
-  Container,
-} from 'farrow-pipeline';
-import {
-  Waterfall,
-  Brook,
-  isWaterfall,
-  createWaterfall,
-  AsyncWaterfall,
-  AsyncBrook,
-  isAsyncWaterfall,
-  createAsyncWaterfall,
-} from '../waterfall';
-import {
-  Worker,
-  Workflow,
-  isWorkflow,
-  createWorkflow,
-  AsyncWorker,
-  AsyncWorkflow,
-  isAsyncWorkflow,
-  createAsyncWorkflow,
-  ParallelWorkflow,
-  isParallelWorkflow,
-  createParallelWorkflow,
-} from '../workflow';
-import { RunnerContext, useRunner } from './runner';
-
-// eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-export type Initializer<O> = () => O | void;
-
-const SYNC_PLUGIN_SYMBOL = 'SYNC_PLUGIN_SYMBOL';
-
-export type Plugin<O> = {
-  initializer: Initializer<O>;
-  SYNC_PLUGIN_SYMBOL: typeof SYNC_PLUGIN_SYMBOL;
-} & Required<PluginOptions>;
-
-export type IndexPlugin<O> = Plugin<O> & {
-  index: number;
-};
-
-export type Plugins<O> = Plugin<O>[];
-export type IndexPlugins<O> = IndexPlugin<O>[];
-
-export type PluginOptions = {
-  name?: string;
-  pre?: string[];
-  post?: string[];
-  rivals?: string[];
-  required?: string[];
-};
-
-export type Progress =
-  | Waterfall<any>
-  | AsyncWaterfall<any>
-  | Workflow<any, any>
-  | AsyncWorkflow<any, any>
-  | ParallelWorkflow<any>
-  | Pipeline<any, any>
-  | AsyncPipeline<any, any>;
-
-export 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 type ProgressRecord = Record<string, Progress>;
-
-// eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-export type Progresses2Threads<PS extends ProgressRecord | void> = {
-  [K in keyof PS]: PS[K] extends Progress
-    ? Progress2Thread<PS[K]>
-    : // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-    PS[K] extends void
-    ? // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-      void
-    : never;
-};
-
-export 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;
-
-// eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-export type Progresses2Runners<PS extends ProgressRecord | void> = {
-  [K in keyof PS]: PS[K] extends Progress
-    ? RunnerFromProgress<PS[K]>
-    : // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-    PS[K] extends void
-    ? // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-      void
-    : never;
-};
-
-export type ClearDraftProgress<I extends Record<string, any>> = {
-  [K in keyof I]: I[K] extends Progress ? I[K] : never;
-};
-
-export type PluginFromManager<M extends Manager<any, any>> = M extends Manager<
-  infer EP,
-  infer PR
->
-  ? Plugin<Partial<Progresses2Threads<PR & ClearDraftProgress<EP>>>>
-  : never;
-export type InitOptions = {
-  container?: Container;
-};
-export type Manager<
-  EP extends Record<string, any>,
-  // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-  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>>;
-  run: <O>(cb: () => O, options?: InitOptions) => O;
-  registe: (newShape: Partial<EP>) => void;
-  clear: () => void;
-  clone: () => Manager<EP, PR>;
-  useRunner: () => Progresses2Runners<PR & ClearDraftProgress<EP>>;
-};
-
-export const DEFAULT_OPTIONS: Required<PluginOptions> = {
-  name: 'untitled',
-  pre: [],
-  post: [],
-  rivals: [],
-  required: [],
-};
-
-export const createManager = <
-  // eslint-disable-next-line @typescript-eslint/ban-types
-  EP extends Record<string, any> = {},
-  // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-  PR extends ProgressRecord | void = void,
->(
-  processes?: PR,
-): Manager<EP, PR> => {
-  let index = 0;
-  const createPlugin: Manager<EP, PR>['createPlugin'] = (
-    initializer,
-    options = {},
-  ) => ({
-    ...DEFAULT_OPTIONS,
-    name: `No.${index++} plugin`,
-    ...options,
-    SYNC_PLUGIN_SYMBOL,
-    initializer,
-  });
-
-  const isPlugin: Manager<EP, PR>['isPlugin'] = (
-    input,
-  ): input is Plugin<
-    Partial<Progresses2Threads<PR & ClearDraftProgress<EP>>>
-  > =>
-    hasOwnProperty(input, SYNC_PLUGIN_SYMBOL) &&
-    input[SYNC_PLUGIN_SYMBOL] === SYNC_PLUGIN_SYMBOL;
-
-  const registe: Manager<EP, PR>['registe'] = extraProcesses => {
-    // eslint-disable-next-line no-param-reassign
-    processes = {
-      ...extraProcesses,
-      ...processes,
-    } as any;
-  };
-
-  const clone = () => {
-    let plugins: IndexPlugins<
-      Partial<Progresses2Threads<PR & ClearDraftProgress<EP>>>
-    > = [];
-
-    const usePlugin: Manager<EP, PR>['usePlugin'] = (...input) => {
-      for (const plugin of input) {
-        if (isPlugin(plugin)) {
-          if (!includePlugin(plugins, plugin)) {
-            plugins.push({
-              ...plugin,
-              index: plugins.length,
-            });
-          }
-        } else {
-          // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-          // @ts-expect-error
-          console.warn(`Unknown plugin: ${plugin.name}`);
-        }
-      }
-
-      return {
-        createPlugin,
-        isPlugin,
-        usePlugin,
-        init,
-        run,
-        clear,
-        registe,
-        useRunner,
-        clone,
-      };
-    };
-
-    const clear = () => {
-      plugins = [];
-    };
-
-    const currentContainer = createContainer();
-
-    const init: Manager<EP, PR>['init'] = options => {
-      const container = options?.container || currentContainer;
-
-      const sortedPlugins = sortPlugins(plugins);
-
-      checkPlugins(sortedPlugins);
-
-      const hooksList = sortedPlugins.map(plugin =>
-        runWithContainer(() => plugin.initializer(), container),
-      );
-
-      return generateRunner<EP, PR>(hooksList, container, processes);
-    };
-
-    const run: Manager<EP, PR>['run'] = (cb, options) => {
-      const container = options?.container || currentContainer;
-
-      return runWithContainer(cb, container);
-    };
-
-    return {
-      createPlugin,
-      isPlugin,
-      usePlugin,
-      init,
-      clear,
-      run,
-      registe,
-      useRunner,
-      clone,
-    };
-  };
-
-  return clone();
-};
-
-export const generateRunner = <
-  // eslint-disable-next-line @typescript-eslint/ban-types
-  EP extends Record<string, any> = {},
-  // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-  PR extends ProgressRecord | void = void,
->(
-  // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-  hooksList: (void | Partial<
-    Progresses2Threads<PR & ClearDraftProgress<EP>>
-  >)[],
-  container: Container,
-  processes?: PR,
-): Progresses2Runners<PR & ClearDraftProgress<EP>> => {
-  const runner = {};
-  const cloneShape = cloneProgressRecord(processes);
-
-  if (processes) {
-    for (const key in cloneShape) {
-      for (const hooks of hooksList) {
-        if (!hooks) {
-          continue;
-        }
-        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
-      // @ts-expect-error
-      runner[key] = (input: any, options: any) =>
-        (cloneShape[key] as any).run(input, {
-          container,
-          ...options,
-        });
-    }
-  }
-
-  container.write(RunnerContext, runner);
-  return runner as any;
-};
-
-export const cloneProgress = (progress: Progress): Progress => {
-  if (isWaterfall(progress)) {
-    return createWaterfall();
-  }
-
-  if (isAsyncWaterfall(progress)) {
-    return createAsyncWaterfall();
-  }
-
-  if (isWorkflow(progress)) {
-    return createWorkflow();
-  }
-
-  if (isAsyncWorkflow(progress)) {
-    return createAsyncWorkflow();
-  }
-
-  if (isParallelWorkflow(progress)) {
-    return createParallelWorkflow();
-  }
-
-  if (isPipeline(progress)) {
-    return createPipeline();
-  }
-
-  // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-  throw new Error(`Unknown progress: ${progress}`);
-};
-
-// eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-export const cloneProgressRecord = <PR extends ProgressRecord | void>(
-  record: PR,
-): PR => {
-  if (!record) {
-    return record;
-  }
-
-  const result: PR = {} as any;
-
-  for (const key in record) {
-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-    // @ts-expect-error
-    result[key] = cloneProgress(record[key]);
-  }
-
-  return result;
-};
-
-const includePlugin = <O>(plugins: Plugins<O>, input: Plugin<O>): boolean => {
-  for (const plugin of plugins) {
-    if (plugin.name === input.name) {
-      return true;
-    }
-  }
-
-  return false;
-};
-
-const sortPlugins = <O>(input: IndexPlugins<O>): IndexPlugins<O> => {
-  let plugins = input.slice();
-
-  for (let i = 0; i < plugins.length; i++) {
-    const plugin = plugins[i];
-
-    for (const pre of plugin.pre) {
-      for (let j = i + 1; j < plugins.length; j++) {
-        if (plugins[j].name === pre) {
-          plugins = [
-            ...plugins.slice(0, i),
-            plugins[j],
-            ...plugins.slice(i, j),
-            ...plugins.slice(j + 1, plugins.length),
-          ];
-        }
-      }
-    }
-
-    for (const post of plugin.post) {
-      for (let j = 0; j < i; j++) {
-        if (plugins[j].name === post) {
-          plugins = [
-            ...plugins.slice(0, j),
-            ...plugins.slice(j + 1, i + 1),
-            plugins[j],
-            ...plugins.slice(i + 1, plugins.length),
-          ];
-        }
-      }
-    }
-  }
-
-  return plugins;
-};
-
-const checkPlugins = <O>(plugins: Plugins<O>) => {
-  for (const origin of plugins) {
-    for (const rival of origin.rivals) {
-      for (const plugin of plugins) {
-        if (rival === plugin.name) {
-          throw new Error(`${origin.name} has rival ${plugin.name}`);
-        }
-      }
-    }
-
-    for (const required of origin.required) {
-      if (!plugins.some(plugin => plugin.name === required)) {
-        throw new Error(
-          `The plugin: ${required} is required when plugin: ${origin.name} is exist.`,
-        );
-      }
-    }
-  }
-};
-
-export const hasOwnProperty = <
-  X extends Record<string, unknown>,
-  Y extends PropertyKey,
->(
-  obj: X,
-  prop: Y,
-): obj is X & Record<Y, unknown> => obj.hasOwnProperty(prop);

package/src/waterfall/async.ts

@@ -1,109 +0,0 @@
-import {
-  createAsyncPipeline,
-  Middleware,
-  MaybeAsync,
-  Container,
-  useContainer,
-} from 'farrow-pipeline';
-
-const ASYNC_WATERFALL_SYMBOL = Symbol('ASYNC_WATERFALL_SYMBOL');
-
-export type AsyncBrook<I = unknown> = (I: I) => MaybeAsync<I>;
-export type AsyncBrookInput<I = unknown> =
-  | AsyncBrook<I>
-  | { middlware: AsyncBrook<I> };
-export type AsyncBrooks<I = unknown> = AsyncBrook<I>[];
-export type AsyncBrookInputs<I = unknown> = AsyncBrookInput<I>[];
-
-export const getAsyncBrook = <I>(input: AsyncBrookInput<I>) => {
-  if (typeof input === 'function') {
-    return input;
-  } else if (input && typeof input.middlware === 'function') {
-    return input.middlware;
-  }
-  // eslint-disable-next-line @typescript-eslint/no-base-to-string,@typescript-eslint/restrict-template-expressions
-  throw new Error(`${input} is not a AsyncBrook or { brook: AsyncBrook }`);
-};
-
-export type RunAsyncWaterfallOptions<I = unknown> = {
-  container?: Container;
-  onLast?: AsyncBrook<I>;
-};
-
-export type AsyncWaterfall<I> = {
-  run: (input: I, options?: RunAsyncWaterfallOptions<I>) => MaybeAsync<I>;
-  use: (...I: AsyncBrookInputs<I>) => AsyncWaterfall<I>;
-  middlware: AsyncBrook<I>;
-  [ASYNC_WATERFALL_SYMBOL]: true;
-};
-
-export type AsyncWaterfall2AsyncBrook<P extends AsyncWaterfall<any>> =
-  P extends AsyncWaterfall<infer I> ? AsyncBrook<I> : never;
-
-export type AsyncWaterfallRecord = Record<string, AsyncWaterfall<any>>;
-
-// eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-export type AsyncWaterfalls2Brooks<PS extends AsyncWaterfallRecord | void> = {
-  [K in keyof PS]: PS[K] extends AsyncWaterfall<any>
-    ? AsyncWaterfall2AsyncBrook<PS[K]>
-    : // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-    PS[K] extends void
-    ? // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-      void
-    : never;
-};
-
-export type RunnerFromAsyncWaterfall<M extends AsyncWaterfall<any>> =
-  M extends AsyncWaterfall<infer VS> ? AsyncWaterfall<VS>['run'] : never;
-
-// eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-export type AsyncWaterfalls2Runners<PS extends AsyncWaterfallRecord | void> = {
-  [K in keyof PS]: PS[K] extends AsyncWaterfall<any>
-    ? RunnerFromAsyncWaterfall<PS[K]>
-    : // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-    PS[K] extends void
-    ? // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-      void
-    : never;
-};
-
-// eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-export const createAsyncWaterfall = <I = void>(): AsyncWaterfall<I> => {
-  const pipeline = createAsyncPipeline<I, I>();
-
-  const use: AsyncWaterfall<I>['use'] = (...input) => {
-    pipeline.use(
-      ...input.map(getAsyncBrook).map(mapAsyncBrookToAsyncMiddleware),
-    );
-    return waterfall;
-  };
-
-  const run: AsyncWaterfall<I>['run'] = (input, options) =>
-    // eslint-disable-next-line @typescript-eslint/no-shadow
-    pipeline.run(input, { ...options, onLast: input => input });
-
-  const middlware: AsyncWaterfall<I>['middlware'] = input => {
-    // eslint-disable-next-line react-hooks/rules-of-hooks
-    const container = useContainer();
-    // eslint-disable-next-line @typescript-eslint/no-shadow
-    return pipeline.run(input, { container, onLast: input => input });
-  };
-
-  const waterfall: AsyncWaterfall<I> = {
-    ...pipeline,
-    use,
-    run,
-    middlware,
-    [ASYNC_WATERFALL_SYMBOL]: true as const,
-  };
-
-  return waterfall;
-};
-
-export const isAsyncWaterfall = (input: any): input is AsyncWaterfall<any> =>
-  Boolean(input?.[ASYNC_WATERFALL_SYMBOL]);
-
-const mapAsyncBrookToAsyncMiddleware =
-  <I>(brook: AsyncBrook<I>): Middleware<I, MaybeAsync<I>> =>
-  async (input, next) =>
-    next(await brook(input));

package/src/waterfall/index.ts

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

package/src/waterfall/sync.ts

@@ -1,110 +0,0 @@
-import {
-  Container,
-  useContainer,
-  createPipeline,
-  Middleware,
-} from 'farrow-pipeline';
-
-const WATERFALL_SYMBOL = Symbol('WATERFALL_SYMBOL');
-
-export type Brook<I = unknown> = (I: I) => I;
-export type BrookInput<I = unknown> = Brook<I> | { middleware: Brook<I> };
-export type Brooks<I = unknown> = Brook<I>[];
-export type BrookInputs<I = unknown> = BrookInput<I>[];
-
-export const getBrook = <I>(input: BrookInput<I>) => {
-  if (typeof input === 'function') {
-    return input;
-  } 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(`${input} is not a Brook or { brook: Brook }`);
-};
-
-export type RunWaterfallOptions<I = unknown> = {
-  container?: Container;
-  onLast?: Brook<I>;
-};
-
-// eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-export type Waterfall<I = void> = {
-  run: (input: I, options?: RunWaterfallOptions<I>) => I;
-  use: (...I: BrookInputs<I>) => Waterfall<I>;
-  middleware: Brook<I>;
-  [WATERFALL_SYMBOL]: true;
-};
-
-export type Waterfall2Brook<P extends Waterfall<any>> = P extends Waterfall<
-  infer I
->
-  ? Brook<I>
-  : never;
-
-export type WaterfallRecord = Record<string, Waterfall<any>>;
-
-// eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-export type Waterfalls2Brooks<PS extends WaterfallRecord | void> = {
-  [K in keyof PS]: PS[K] extends Waterfall<any>
-    ? Waterfall2Brook<PS[K]>
-    : // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-    PS[K] extends void
-    ? // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-      void
-    : never;
-};
-
-export type RunnerFromWaterfall<M extends Waterfall<any>> = M extends Waterfall<
-  infer VS
->
-  ? Waterfall<VS>['run']
-  : never;
-
-// eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-export type Waterfalls2Runners<PS extends WaterfallRecord | void> = {
-  [K in keyof PS]: PS[K] extends Waterfall<any>
-    ? RunnerFromWaterfall<PS[K]>
-    : // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-    PS[K] extends void
-    ? // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-      void
-    : never;
-};
-
-// eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-export const createWaterfall = <I = void>(): Waterfall<I> => {
-  const pipeline = createPipeline<I, I>();
-
-  const use: Waterfall<I>['use'] = (...brooks) => {
-    pipeline.use(...brooks.map(getBrook).map(mapBrookToMiddleware));
-    return waterfall;
-  };
-
-  const run: Waterfall<I>['run'] = (input, options) =>
-    // eslint-disable-next-line @typescript-eslint/no-shadow
-    pipeline.run(input, { ...options, onLast: input => input });
-
-  const middleware: Waterfall<I>['middleware'] = input => {
-    // eslint-disable-next-line react-hooks/rules-of-hooks
-    const container = useContainer();
-    // eslint-disable-next-line @typescript-eslint/no-shadow
-    return pipeline.run(input, { container, onLast: input => input });
-  };
-
-  const waterfall: Waterfall<I> = {
-    ...pipeline,
-    use,
-    run,
-    middleware,
-    [WATERFALL_SYMBOL]: true,
-  };
-  return waterfall;
-};
-
-export const isWaterfall = (input: any): input is Waterfall<any> =>
-  Boolean(input?.[WATERFALL_SYMBOL]);
-
-const mapBrookToMiddleware =
-  <I>(brook: Brook<I>): Middleware<I, I> =>
-  (input, next) =>
-    next(brook(input));

package/src/workflow/async.ts

@@ -1,96 +0,0 @@
-import { MaybeAsync, createAsyncPipeline, Middleware } from 'farrow-pipeline';
-import type { RunWorkflowOptions } from './sync';
-
-const ASYNC_WORKFLOW_SYMBOL = Symbol('ASYNC_WORKFLOW_SYMBOL');
-
-export type AsyncWorker<I, O> = (I: I) => MaybeAsync<O>;
-export type AsyncWorkers<I, O> = AsyncWorker<I, O>[];
-
-export type AsyncWorkflow<I, O> = {
-  run: (input: I, options?: RunWorkflowOptions) => MaybeAsync<O[]>;
-  use: (...I: AsyncWorkers<I, O>) => AsyncWorkflow<I, O>;
-  [ASYNC_WORKFLOW_SYMBOL]: true;
-};
-
-export type AsyncWorkflow2AsyncWorker<W extends AsyncWorkflow<any, any>> =
-  W extends AsyncWorkflow<infer I, infer O> ? AsyncWorker<I, O> : never;
-
-export type AsyncWorkflowRecord = Record<string, AsyncWorkflow<any, any>>;
-
-// eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-export type AsyncWorkflows2AsyncWorkers<PS extends AsyncWorkflowRecord | void> =
-  {
-    [K in keyof PS]: PS[K] extends AsyncWorkflow<any, any>
-      ? AsyncWorkflow2AsyncWorker<PS[K]>
-      : // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-      PS[K] extends void
-      ? // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-        void
-      : never;
-  };
-
-export type RunnerFromAsyncWorkflow<W extends AsyncWorkflow<any, any>> =
-  W extends AsyncWorkflow<infer I, infer O>
-    ? AsyncWorkflow<I, O>['run']
-    : never;
-
-// eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-export type AsyncWorkflows2Runners<PS extends AsyncWorkflowRecord | void> = {
-  [K in keyof PS]: PS[K] extends AsyncWorkflow<any, any>
-    ? RunnerFromAsyncWorkflow<PS[K]>
-    : // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-    PS[K] extends void
-    ? // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-      void
-    : never;
-};
-
-export const isAsyncWorkflow = (input: any): input is AsyncWorkflow<any, any> =>
-  Boolean(input?.[ASYNC_WORKFLOW_SYMBOL]);
-
-// eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-export const createAsyncWorkflow = <I = void, O = unknown>(): AsyncWorkflow<
-  I,
-  O
-> => {
-  const pipeline = createAsyncPipeline<I, O[]>();
-
-  const use: AsyncWorkflow<I, O>['use'] = (...input) => {
-    pipeline.use(...input.map(mapAsyncWorkerToAsyncMiddleware));
-    return workflow;
-  };
-
-  const run: AsyncWorkflow<I, O>['run'] = async (input, options) => {
-    const result = pipeline.run(input, { ...options, onLast: () => [] });
-    if (isPromise(result)) {
-      // eslint-disable-next-line @typescript-eslint/no-shadow,promise/prefer-await-to-then
-      return result.then(result => result.filter(Boolean));
-    } else {
-      return result.filter(Boolean);
-    }
-  };
-
-  const workflow: AsyncWorkflow<I, O> = {
-    ...pipeline,
-    use,
-    run,
-    [ASYNC_WORKFLOW_SYMBOL]: true as const,
-  };
-
-  return workflow;
-};
-
-const mapAsyncWorkerToAsyncMiddleware =
-  <I, O>(worker: AsyncWorker<I, O>): Middleware<I, MaybeAsync<O[]>> =>
-  async (input, next) =>
-    [await worker(input), ...(await next(input))];
-
-function isPromise(obj: any): obj is Promise<any> {
-  /* eslint-disable promise/prefer-await-to-then */
-  return (
-    Boolean(obj) &&
-    (typeof obj === 'object' || typeof obj === 'function') &&
-    typeof obj.then === 'function'
-  );
-  /* eslint-enable promise/prefer-await-to-then */
-}

package/src/workflow/index.ts

@@ -1,3 +0,0 @@
-export * from './sync';
-export * from './parallel';
-export * from './async';

package/src/workflow/parallel.ts

@@ -1,97 +0,0 @@
-import { MaybeAsync, createPipeline, Middleware } from 'farrow-pipeline';
-import type { AsyncWorker, AsyncWorkers } from './async';
-import type { RunWorkflowOptions } from './sync';
-
-const PARALLEL_WORKFLOW_SYMBOL = Symbol('PARALLEL_WORKFLOW_SYMBOL');
-
-export type ParallelWorkflow<I, O = any> = {
-  run: (input: I, options?: RunWorkflowOptions) => Promise<O[]>;
-  use: (...I: AsyncWorkers<I, O>) => ParallelWorkflow<I, O>;
-  [PARALLEL_WORKFLOW_SYMBOL]: true;
-};
-
-export type ParallelWorkflow2Worker<W extends ParallelWorkflow<any>> =
-  W extends ParallelWorkflow<infer CS, infer O> ? AsyncWorker<CS, O> : never;
-
-export type ParallelWorkflowRecord = Record<string, ParallelWorkflow<any>>;
-
-export type ParallelWorkflows2Workers<
-  // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-  PS extends ParallelWorkflowRecord | void,
-> = {
-  [K in keyof PS]: PS[K] extends ParallelWorkflow<any>
-    ? ParallelWorkflow2Worker<PS[K]>
-    : // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-    PS[K] extends void
-    ? // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-      void
-    : never;
-};
-
-export type ParallelWorkflows2AsyncWorkers<
-  // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-  PS extends ParallelWorkflowRecord | void,
-> = {
-  [K in keyof PS]: PS[K] extends ParallelWorkflow<any>
-    ? ParallelWorkflow2Worker<PS[K]>
-    : // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-    PS[K] extends void
-    ? // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-      void
-    : never;
-};
-
-export type RunnerFromParallelWorkflow<W extends ParallelWorkflow<any>> =
-  W extends ParallelWorkflow<infer CS, infer O>
-    ? ParallelWorkflow<CS, O>['run']
-    : never;
-
-export type ParallelWorkflows2Runners<
-  // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-  PS extends ParallelWorkflowRecord | void,
-> = {
-  [K in keyof PS]: PS[K] extends ParallelWorkflow<any>
-    ? RunnerFromParallelWorkflow<PS[K]>
-    : // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-    PS[K] extends void
-    ? // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-      void
-    : never;
-};
-
-export const isParallelWorkflow = (
-  input: any,
-): input is ParallelWorkflow<any> => Boolean(input?.[PARALLEL_WORKFLOW_SYMBOL]);
-
-export const createParallelWorkflow = <
-  // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-  I = void,
-  O = unknown,
->(): ParallelWorkflow<I, O> => {
-  const pipeline = createPipeline<I, MaybeAsync<O>[]>();
-
-  const use: ParallelWorkflow<I, O>['use'] = (...input) => {
-    pipeline.use(...input.map(mapParallelWorkerToAsyncMiddleware));
-    return workflow;
-  };
-
-  const run: ParallelWorkflow<I, O>['run'] = async (input, options) =>
-    // eslint-disable-next-line promise/prefer-await-to-then
-    Promise.all(pipeline.run(input, { ...options, onLast: () => [] })).then(
-      result => result.filter(Boolean),
-    );
-
-  const workflow: ParallelWorkflow<I, O> = {
-    ...pipeline,
-    run,
-    use,
-    [PARALLEL_WORKFLOW_SYMBOL]: true as const,
-  };
-
-  return workflow;
-};
-
-const mapParallelWorkerToAsyncMiddleware =
-  <I, O>(worker: AsyncWorker<I, O>): Middleware<I, MaybeAsync<O>[]> =>
-  (input, next) =>
-    [worker(input), ...next(input)];

package/src/workflow/sync.ts

@@ -1,82 +0,0 @@
-import { Container, createPipeline, Middleware } from 'farrow-pipeline';
-
-const WORKFLOW_SYMBOL = Symbol('WORKFLOW_SYMBOL');
-
-export type Worker<I, O> = (I: I) => O;
-export type Workers<I, O> = Worker<I, O>[];
-
-export type RunWorkflowOptions = {
-  container?: Container;
-};
-
-export type Workflow<I, O> = {
-  run: (input: I, options?: RunWorkflowOptions) => void;
-  use: (...I: Workers<I, O>) => Workflow<I, O>;
-  [WORKFLOW_SYMBOL]: true;
-};
-
-export type Workflow2Worker<W extends Workflow<any, any>> = W extends Workflow<
-  infer I,
-  infer O
->
-  ? Worker<I, O>
-  : never;
-
-export type WorkflowRecord = Record<string, Workflow<any, any>>;
-
-// eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-export type Workflows2Workers<PS extends WorkflowRecord | void> = {
-  [K in keyof PS]: PS[K] extends Workflow<any, any>
-    ? Workflow2Worker<PS[K]>
-    : // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-    PS[K] extends void
-    ? // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-      void
-    : never;
-};
-
-export type RunnerFromWorkflow<W extends Workflow<any, any>> =
-  W extends Workflow<infer I, infer O> ? Workflow<I, O>['run'] : never;
-
-// eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-export type Workflows2Runners<PS extends WorkflowRecord | void> = {
-  [K in keyof PS]: PS[K] extends Workflow<any, any>
-    ? RunnerFromWorkflow<PS[K]>
-    : // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-    PS[K] extends void
-    ? // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-      void
-    : never;
-};
-
-// eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-export const createWorkflow = <I = void, O = unknown>(): Workflow<I, O> => {
-  const pipeline = createPipeline<I, O[]>();
-
-  const use: Workflow<I, O>['use'] = (...input) => {
-    pipeline.use(...input.map(mapWorkerToMiddleware));
-    return workflow;
-  };
-
-  const run: Workflow<I, O>['run'] = async (input, options) => {
-    const result = pipeline.run(input, { ...options, onLast: () => [] });
-    return result.filter(Boolean);
-  };
-
-  const workflow: Workflow<I, O> = {
-    ...pipeline,
-    use,
-    run,
-    [WORKFLOW_SYMBOL]: true as const,
-  };
-
-  return workflow;
-};
-
-export const isWorkflow = (input: any): input is Workflow<unknown, unknown> =>
-  Boolean(input?.[WORKFLOW_SYMBOL]);
-
-const mapWorkerToMiddleware =
-  <I, O>(worker: Worker<I, O>): Middleware<I, O[]> =>
-  (input, next) =>
-    [worker(input), ...next(input)];