@modern-js/plugin 0.0.0-bundle-deps-202110124831 → 0.0.0-runtime-2021112193858

package/src/waterfall/sync.ts

@@ -1,26 +1,22 @@
-import { createCounter } from '../counter';
 import {
-  Hooks,
-  runHooks,
-  fromContainer,
   Container,
-  createContainer,
   useContainer,
-} from '../context';
+  createPipeline,
+  Middleware,
+} from 'farrow-pipeline';
 
 const WATERFALL_SYMBOL = Symbol('WATERFALL_SYMBOL');
 
-// eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-export type Brook<I = unknown> = (I: I) => I | void;
-export type BrookInput<I = unknown> = Brook<I> | { brook: Brook<I> };
+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.brook === 'function') {
-    return input.brook;
+  } 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 }`);
@@ -35,7 +31,7 @@ export type RunWaterfallOptions<I = unknown> = {
 export type Waterfall<I = void> = {
   run: (input: I, options?: RunWaterfallOptions<I>) => I;
   use: (...I: BrookInputs<I>) => Waterfall<I>;
-  brook: Brook<I>;
+  middleware: Brook<I>;
   [WATERFALL_SYMBOL]: true;
 };
 
@@ -77,53 +73,38 @@ export type Waterfalls2Runners<PS extends WaterfallRecord | void> = {
 
 // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
 export const createWaterfall = <I = void>(): Waterfall<I> => {
-  const middlewares: Brooks<I> = [];
-
-  const createCurrentRunner = (hooks: Hooks) =>
-    createCounter<I, I>((index, input, next) => {
-      if (index >= middlewares.length) {
-        return input;
-      }
-
-      return runHooks(() => next(middlewares[index](input) || input), hooks);
-    });
-
-  const currentContainer = createContainer();
-  const currentHooks = fromContainer(currentContainer);
-  const currentRunner = createCurrentRunner(currentHooks);
+  const pipeline = createPipeline<I, I>();
 
-  const use: Waterfall<I>['use'] = (...input) => {
-    middlewares.push(...input.map(getBrook));
+  const use: Waterfall<I>['use'] = (...brooks) => {
+    pipeline.use(...brooks.map(getBrook).map(mapBrookToMiddleware));
     return waterfall;
   };
 
-  const run: Waterfall<I>['run'] = (input, options) => {
-    const container = options?.container ?? currentContainer;
-    const hooks =
-      container === currentContainer ? currentHooks : fromContainer(container);
-    const runner =
-      container === currentContainer
-        ? currentRunner
-        : createCurrentRunner(hooks);
+  const run: Waterfall<I>['run'] = (input, options) =>
+    // eslint-disable-next-line @typescript-eslint/no-shadow
+    pipeline.run(input, { ...options, onLast: input => input });
 
-    return runner.start(input);
-  };
-
-  const brook: Waterfall<I>['brook'] = input => {
+  const middleware: Waterfall<I>['middleware'] = input => {
     // eslint-disable-next-line react-hooks/rules-of-hooks
     const container = useContainer();
-    return run(input, { container });
+    // eslint-disable-next-line @typescript-eslint/no-shadow
+    return pipeline.run(input, { container, onLast: input => input });
   };
 
-  const waterfall = {
+  const waterfall: Waterfall<I> = {
+    ...pipeline,
     use,
     run,
-    brook,
-    [WATERFALL_SYMBOL]: true as const,
+    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,14 +1,13 @@
-import { createAsyncCounter } from '../counter';
-import { Hooks, runHooks, fromContainer, createContainer } from '../context';
+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) => O | Promise<O>;
+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) => Promise<O[]>;
+  run: (input: I, options?: RunWorkflowOptions) => MaybeAsync<O[]>;
   use: (...I: AsyncWorkers<I, O>) => AsyncWorkflow<I, O>;
   [ASYNC_WORKFLOW_SYMBOL]: true;
 };
@@ -54,43 +53,25 @@ export const createAsyncWorkflow = <I = void, O = unknown>(): AsyncWorkflow<
   I,
   O
 > => {
-  const middlewares: AsyncWorkers<I, O> = [];
-
-  const createCurrentRunner = (hooks: Hooks) =>
-    createAsyncCounter<I, O[]>(async (index, input, next) => {
-      if (index >= middlewares.length) {
-        return [];
-      }
-
-      const middleware = middlewares[index];
-      return runHooks(async () => {
-        const result = await middleware(input);
-        const rest = await next(input);
-        return [result, ...rest];
-      }, hooks);
-    });
-  const currentContainer = createContainer();
-  const currentHooks = fromContainer(currentContainer);
-  const currentRunner = createCurrentRunner(currentHooks);
+  const pipeline = createAsyncPipeline<I, O[]>();
 
   const use: AsyncWorkflow<I, O>['use'] = (...input) => {
-    middlewares.push(...input);
+    pipeline.use(...input.map(mapAsyncWorkerToAsyncMiddleware));
     return workflow;
   };
 
   const run: AsyncWorkflow<I, O>['run'] = async (input, options) => {
-    const container = options?.container ?? currentContainer;
-    const hooks =
-      container === currentContainer ? currentHooks : fromContainer(container);
-    const runner =
-      container === currentContainer
-        ? currentRunner
-        : createCurrentRunner(hooks);
-
-    return runner.start(input);
+    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 = {
+  const workflow: AsyncWorkflow<I, O> = {
+    ...pipeline,
     use,
     run,
     [ASYNC_WORKFLOW_SYMBOL]: true as const,
@@ -98,3 +79,18 @@ export const createAsyncWorkflow = <I = void, O = unknown>(): AsyncWorkflow<
 
   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/parallel.ts

@@ -1,6 +1,5 @@
-import { createAsyncCounter } from '../counter';
-import { Hooks, runHooks, fromContainer, createContainer } from '../context';
-import { AsyncWorker, AsyncWorkers } from './async';
+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');
@@ -69,47 +68,30 @@ export const createParallelWorkflow = <
   I = void,
   O = unknown,
 >(): ParallelWorkflow<I, O> => {
-  const middlewares: AsyncWorkers<I, O> = [];
-
-  const createCurrentRunner = (hooks: Hooks) =>
-    createAsyncCounter<I, O[]>((index, input, next) => {
-      if (index >= middlewares.length) {
-        return Promise.resolve<any[]>([]);
-      }
-
-      const middleware = middlewares[index];
-      return runHooks(
-        async () => Promise.all([middleware(input), ...(await next(input))]),
-        hooks,
-      );
-    });
-
-  const currentContainer = createContainer();
-  const currentHooks = fromContainer(currentContainer);
-  const currentRunner = createCurrentRunner(currentHooks);
+  const pipeline = createPipeline<I, MaybeAsync<O>[]>();
 
   const use: ParallelWorkflow<I, O>['use'] = (...input) => {
-    middlewares.push(...input);
+    pipeline.use(...input.map(mapParallelWorkerToAsyncMiddleware));
     return workflow;
   };
 
-  const run: ParallelWorkflow<I, O>['run'] = async (input, options) => {
-    const container = options?.container ?? currentContainer;
-    const hooks =
-      container === currentContainer ? currentHooks : fromContainer(container);
-    const runner =
-      container === currentContainer
-        ? currentRunner
-        : createCurrentRunner(hooks);
-
-    return runner.start(input);
-  };
+  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 = {
-    use,
+  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,11 +1,4 @@
-import { createCounter } from '../counter';
-import {
-  Hooks,
-  runHooks,
-  fromContainer,
-  Container,
-  createContainer,
-} from '../context';
+import { Container, createPipeline, Middleware } from 'farrow-pipeline';
 
 const WORKFLOW_SYMBOL = Symbol('WORKFLOW_SYMBOL');
 
@@ -58,40 +51,20 @@ export type Workflows2Runners<PS extends WorkflowRecord | void> = {
 
 // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
 export const createWorkflow = <I = void, O = unknown>(): Workflow<I, O> => {
-  const middlewares: Workers<I, O> = [];
-
-  const createCurrentRunner = (hooks: Hooks) =>
-    createCounter<I, O[]>((index, input, next) => {
-      if (index >= middlewares.length) {
-        return [];
-      }
-
-      const middleware = middlewares[index];
-      return runHooks(() => [middleware(input), ...next(input)], hooks);
-    });
-
-  const currentContainer = createContainer();
-  const currentHooks = fromContainer(currentContainer);
-  const currentRunner = createCurrentRunner(currentHooks);
+  const pipeline = createPipeline<I, O[]>();
 
   const use: Workflow<I, O>['use'] = (...input) => {
-    middlewares.push(...input);
+    pipeline.use(...input.map(mapWorkerToMiddleware));
     return workflow;
   };
 
-  const run: Workflow<I, O>['run'] = (input, options) => {
-    const container = options?.container ?? currentContainer;
-    const hooks =
-      container === currentContainer ? currentHooks : fromContainer(container);
-    const runner =
-      container === currentContainer
-        ? currentRunner
-        : createCurrentRunner(hooks);
-
-    return runner.start(input);
+  const run: Workflow<I, O>['run'] = async (input, options) => {
+    const result = pipeline.run(input, { ...options, onLast: () => [] });
+    return result.filter(Boolean);
   };
 
-  const workflow = {
+  const workflow: Workflow<I, O> = {
+    ...pipeline,
     use,
     run,
     [WORKFLOW_SYMBOL]: true as const,
@@ -102,3 +75,8 @@ export const createWorkflow = <I = void, O = unknown>(): Workflow<I, O> => {
 
 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)];

package/tests/async.test.ts

@@ -1,16 +1,20 @@
 // eslint-disable-next-line eslint-comments/disable-enable-pair
 /* eslint-disable max-lines */
+import { enable, disable } from 'farrow-pipeline/asyncHooks.node';
+import {
+  createPipeline,
+  createAsyncPipeline,
+  createContext,
+  createContainer,
+} from 'farrow-pipeline';
 import { main } from './fixtures/async/core';
 import foo from './fixtures/async/base/foo';
 import bar, { getBar } from './fixtures/async/base/bar';
 import dFoo from './fixtures/async/dynamic/foo';
 import dBar, { getNumber } from './fixtures/async/dynamic/bar';
 import { sleep } from './helpers';
-import { createContext, createContainer } from '@/context';
 import { createManager, createAsyncManager, useRunner } from '@/manager';
-import { enable, disable } from '@/asyncHooksImpl';
 import { createWaterfall, createAsyncWaterfall } from '@/waterfall';
-import { createPipeline, createAsyncPipeline } from '@/pipeline';
 import {
   createWorkflow,
   createAsyncWorkflow,

package/tests/pipeline.test.ts

@@ -1,18 +1,16 @@
 // eslint-disable-next-line eslint-comments/disable-enable-pair
 /* eslint-disable max-lines */
+import * as asyncHooksImpl from 'farrow-pipeline/asyncHooks.node';
 import { sleep } from './helpers';
 import {
   createContext,
   createContainer,
   createPipeline,
   createAsyncPipeline,
-  useAsyncPipeline,
   usePipeline,
   useContainer,
   isPipeline,
-  isAsyncPipeline,
 } from '@/index';
-import * as asyncHooksImpl from '@/asyncHooksImpl';
 
 describe('createPipeline', () => {
   it('basic usage', async () => {
@@ -531,7 +529,7 @@ describe('createPipeline', () => {
       pipeline0.use(async input => `${input} from pipeline0`);
 
       pipeline1.use(async input => {
-        const runPipeline1 = useAsyncPipeline(pipeline0);
+        const runPipeline1 = usePipeline(pipeline0);
 
         const text = await runPipeline1(' pipeline1');
 
@@ -543,15 +541,6 @@ describe('createPipeline', () => {
       expect(result).toEqual(`run pipeline1 from pipeline0`);
     });
 
-    it('isAsyncPipeline', () => {
-      const pipeline = createAsyncPipeline();
-
-      expect(isAsyncPipeline(pipeline)).toBeTruthy();
-      expect(isAsyncPipeline({})).toBeFalsy();
-      expect(isAsyncPipeline('test')).toBeFalsy();
-      expect(isAsyncPipeline(null)).toBeFalsy();
-    });
-
     it('support hooks', async () => {
       const pipeline = createAsyncPipeline<number, number>();
 
@@ -599,7 +588,8 @@ describe('createPipeline', () => {
     it('should throw error when all middlewares calling next() and onLast is not exist', async () => {
       const pipeline = createAsyncPipeline<number, number>();
 
-      pipeline.use((input, next) => next(input));
+      // eslint-disable-next-line promise/prefer-await-to-then
+      pipeline.use((input, next) => Promise.resolve().then(() => next(input)));
 
       await expect(() => pipeline.run(0)).rejects.toThrowError();
     });

package/tests/sync.test.ts

@@ -1,14 +1,18 @@
 // eslint-disable-next-line eslint-comments/disable-enable-pair
 /* eslint-disable max-lines */
+import {
+  createPipeline,
+  createAsyncPipeline,
+  createContext,
+  createContainer,
+} from 'farrow-pipeline';
 import { main } from './fixtures/sync/core';
 import foo from './fixtures/sync/base/foo';
 import bar, { getBar } from './fixtures/sync/base/bar';
 import dFoo from './fixtures/sync/dynamic/foo';
 import dBar, { getNumber, setNumber } from './fixtures/sync/dynamic/bar';
-import { createContext, createContainer } from '@/context';
 import { createManager, createAsyncManager, useRunner } from '@/manager';
 import { createWaterfall, createAsyncWaterfall } from '@/waterfall';
-import { createPipeline, createAsyncPipeline } from '@/pipeline';
 import {
   createWorkflow,
   createAsyncWorkflow,

package/tests/waterfall.test.ts

@@ -1,3 +1,4 @@
+import { enable, disable } from 'farrow-pipeline/asyncHooks.node';
 import { sleep } from './helpers';
 import {
   createWaterfall,
@@ -7,7 +8,6 @@ import {
   isWaterfall,
   isAsyncWaterfall,
 } from '@/index';
-import { enable, disable } from '@/asyncHooksImpl';
 
 describe('waterfall', () => {
   it('base usage', () => {

package/dist/js/modern/asyncHooksImpl.js

@@ -1,63 +0,0 @@
-/**
- * Copyright Lucifier129 and other contributors.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file at
- * https://github.com/farrow-js/farrow/blob/master/LICENSE
- *
- */
-import NodeAsyncHooks from 'async_hooks';
-import * as asyncHooksInterface from "./asyncHooksInterface";
-
-const createAsyncHooks = () => {
-  const store = new Map(); // eslint-disable-next-line node/no-unsupported-features/node-builtins
-
-  const hooks = NodeAsyncHooks.createHook({
-    init: (asyncId, _, triggerAsyncId) => {
-      if (store.has(triggerAsyncId)) {
-        const value = store.get(triggerAsyncId);
-        store.set(asyncId, value);
-      }
-    },
-    destroy: asyncId => {
-      if (store.has(asyncId)) {
-        store.delete(asyncId);
-      }
-    }
-  });
-
-  const set = value => {
-    store.set(NodeAsyncHooks.executionAsyncId(), value);
-  };
-
-  const get = () => store.get(NodeAsyncHooks.executionAsyncId());
-
-  const enable = () => {
-    hooks.enable();
-  };
-
-  const disable = () => {
-    hooks.disable();
-    store.clear();
-  };
-
-  return {
-    enable,
-    disable,
-    set,
-    get
-  };
-};
-
-export const enable = () => {
-  const hooks = createAsyncHooks();
-  disable();
-  asyncHooksInterface.impl(hooks);
-  hooks.enable();
-};
-export const disable = () => {
-  var _asyncHooksInterface$;
-
-  (_asyncHooksInterface$ = asyncHooksInterface.asyncHooks) === null || _asyncHooksInterface$ === void 0 ? void 0 : _asyncHooksInterface$.disable();
-  asyncHooksInterface.reset();
-};

package/dist/js/modern/asyncHooksInterface.js

@@ -1,16 +0,0 @@
-/**
- * Copyright Lucifier129 and other contributors.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file at
- * https://github.com/farrow-js/farrow/blob/master/LICENSE
- *
- */
-// eslint-disable-next-line import/no-mutable-exports
-export let asyncHooks;
-export const impl = implimentations => {
-  asyncHooks = implimentations;
-};
-export const reset = () => {
-  asyncHooks = undefined;
-};

package/dist/js/modern/context.js

@@ -1,130 +0,0 @@
-/**
- * Copyright Lucifier129 and other contributors.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file at
- * https://github.com/farrow-js/farrow/blob/master/LICENSE
- *
- */
-import { createHooks } from "./hook";
-const ContextSymbol = Symbol('Context');
-export const isContext = input => Object.prototype.hasOwnProperty.call(input, ContextSymbol);
-export const assertContext = input => {
-  if (!isContext(input)) {
-    throw new Error(`Expected Context, but received ${input}`);
-  }
-};
-export const createContext = value => {
-  const id = Symbol('ContextID'); // eslint-disable-next-line @typescript-eslint/no-shadow
-
-  const create = value => {
-    const use = () => {
-      // eslint-disable-next-line react-hooks/rules-of-hooks
-      const container = useContainer();
-      return Object.seal({
-        get value() {
-          return container.read(Context);
-        },
-
-        set value(v) {
-          container.write(Context, v);
-        }
-
-      });
-    };
-
-    const get = () => {
-      // eslint-disable-next-line react-hooks/rules-of-hooks
-      const container = useContainer();
-      return container.read(Context);
-    };
-
-    const set = v => {
-      // eslint-disable-next-line react-hooks/rules-of-hooks
-      const container = useContainer();
-      container.write(Context, v);
-    };
-
-    const assert = () => {
-      // eslint-disable-next-line @typescript-eslint/no-shadow
-      const value = get();
-
-      if (value === null || value === undefined) {
-        throw new Error( // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-        `Expected value is not null or undefined, but got: ${value}`);
-      }
-
-      return value;
-    };
-
-    const Context = {
-      id,
-      [ContextSymbol]: value,
-      create,
-      use,
-      get,
-      set,
-      assert
-    };
-    return Context;
-  };
-
-  return create(value);
-};
-export const ContainerSymbol = Symbol('Container'); // eslint-disable-next-line @typescript-eslint/no-redeclare
-
-export const isContainer = input => Boolean(input === null || input === void 0 ? void 0 : input[ContainerSymbol]);
-export const assertContainer = input => {
-  if (!isContainer(input)) {
-    throw new Error(`Expected Context, but received ${input}`);
-  }
-};
-
-const createContextMap = storage => {
-  const contextMap = new Map();
-  Object.values(storage).forEach(context => {
-    contextMap.set(context.id, context);
-  });
-  return contextMap;
-};
-
-export const createContainer = (ContextStorage = {}) => {
-  const contextMap = createContextMap(ContextStorage);
-
-  const read = context => {
-    const target = contextMap.get(context.id);
-
-    if (target) {
-      return target[ContextSymbol];
-    }
-
-    return context[ContextSymbol];
-  };
-
-  const write = (context, value) => {
-    contextMap.set(context.id, context.create(value));
-  };
-
-  const container = Object.freeze({
-    [ContainerSymbol]: true,
-    read,
-    write
-  });
-  return container;
-};
-const {
-  run,
-  hooks
-} = createHooks({
-  useContainer: () => {
-    throw new Error(`Can't call useContainer out of scope, it should be placed on top of the function`);
-  }
-});
-export const runHooks = run;
-export const {
-  useContainer
-} = hooks;
-export const fromContainer = container => ({
-  useContainer: () => container
-});
-export const runWithContainer = (f, container) => runHooks(f, fromContainer(container));