@modern-js/plugin 1.0.1 → 1.2.0

package/src/waterfall/async.ts

@@ -1,39 +1,39 @@
-import { createAsyncCounter } from '../counter';
 import {
-  Hooks,
-  runHooks,
-  fromContainer,
-  createContainer,
+  createAsyncPipeline,
+  Middleware,
+  MaybeAsync,
+  Container,
   useContainer,
-} from '../context';
-import type { RunWaterfallOptions } from './sync';
+} from 'farrow-pipeline';
 
 const ASYNC_WATERFALL_SYMBOL = Symbol('ASYNC_WATERFALL_SYMBOL');
 
-export type AsyncBrook<I = unknown> = (
-  I: I,
-  // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-) => I | Promise<I> | void | Promise<void>;
+export type AsyncBrook<I = unknown> = (I: I) => MaybeAsync<I>;
 export type AsyncBrookInput<I = unknown> =
   | AsyncBrook<I>
-  | { brook: 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.brook === 'function') {
-    return input.brook;
+  } 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?: RunWaterfallOptions<I>) => Promise<I>;
+  run: (input: I, options?: RunAsyncWaterfallOptions<I>) => MaybeAsync<I>;
   use: (...I: AsyncBrookInputs<I>) => AsyncWaterfall<I>;
-  brook: AsyncBrook<I>;
+  middlware: AsyncBrook<I>;
   [ASYNC_WATERFALL_SYMBOL]: true;
 };
 
@@ -69,51 +69,31 @@ export type AsyncWaterfalls2Runners<PS extends AsyncWaterfallRecord | void> = {
 
 // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
 export const createAsyncWaterfall = <I = void>(): AsyncWaterfall<I> => {
-  const middlewares: AsyncBrooks<I> = [];
-
-  const createCurrentRunner = (hooks: Hooks) =>
-    createAsyncCounter<I, I>(async (index, input, next) => {
-      if (index >= middlewares.length) {
-        return input;
-      }
-
-      return runHooks(
-        async () => next((await middlewares[index](input)) || input),
-        hooks,
-      );
-    });
-
-  const currentContainer = createContainer();
-  const currentHooks = fromContainer(currentContainer);
-  const currentRunner = createCurrentRunner(currentHooks);
+  const pipeline = createAsyncPipeline<I, I>();
 
   const use: AsyncWaterfall<I>['use'] = (...input) => {
-    middlewares.push(...input.map(getAsyncBrook));
+    pipeline.use(
+      ...input.map(getAsyncBrook).map(mapAsyncBrookToAsyncMiddleware),
+    );
     return waterfall;
   };
 
-  const run: AsyncWaterfall<I>['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: AsyncWaterfall<I>['run'] = (input, options) =>
+    // eslint-disable-next-line @typescript-eslint/no-shadow
+    pipeline.run(input, { ...options, onLast: input => input });
 
-  const brook: AsyncWaterfall<I>['brook'] = input => {
+  const middlware: AsyncWaterfall<I>['middlware'] = 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: AsyncWaterfall<I> = {
+    ...pipeline,
     use,
     run,
-    brook,
+    middlware,
     [ASYNC_WATERFALL_SYMBOL]: true as const,
   };
 
@@ -122,3 +102,8 @@ export const createAsyncWaterfall = <I = void>(): AsyncWaterfall<I> => {
 
 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/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,21 +1,25 @@
 // 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 { createManager, createAsyncManager, useRunner } from '../src/manager';
+import { createWaterfall, createAsyncWaterfall } from '../src/waterfall';
+import {
+  createWorkflow,
+  createAsyncWorkflow,
+  createParallelWorkflow,
+} from '../src/workflow';
 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,
-  createParallelWorkflow,
-} from '@/workflow';
 
 describe('async manager', () => {
   it('base usage', async () => {

package/tests/fixtures/async/base/fooManager.ts

@@ -3,7 +3,7 @@ import {
   createWaterfall,
   createWorkflow,
   createManager,
-} from '../../../..';
+} from '../../../../src';
 
 // foo plugin
 // eslint-disable-next-line @typescript-eslint/ban-types

package/tests/fixtures/async/core/index.ts

@@ -3,7 +3,7 @@ import {
   createWaterfall,
   createWorkflow,
   createContext,
-} from '../../../..';
+} from '../../../../src';
 
 // eslint-disable-next-line @typescript-eslint/ban-types
 export type CTX = {};

package/tests/fixtures/async/dynamic/foo.ts

@@ -1,4 +1,4 @@
-import { createAsyncWaterfall } from '../../../..';
+import { createAsyncWaterfall } from '../../../../src';
 import { createPlugin, registeManager, useRunner } from '../core';
 
 // declare new lifecircle type

package/tests/fixtures/sync/base/fooManager.ts

@@ -3,7 +3,7 @@ import {
   createWaterfall,
   createWorkflow,
   createManager,
-} from '../../../..';
+} from '../../../../src';
 
 // foo plugin
 // eslint-disable-next-line @typescript-eslint/ban-types

package/tests/fixtures/sync/core/index.ts

@@ -3,7 +3,7 @@ import {
   createWaterfall,
   createWorkflow,
   createContext,
-} from '../../../..';
+} from '../../../../src';
 
 // eslint-disable-next-line @typescript-eslint/ban-types
 export type CTX = {};

package/tests/fixtures/sync/dynamic/foo.ts

@@ -1,4 +1,4 @@
-import { createAsyncWaterfall } from '../../../..';
+import { createAsyncWaterfall } from '../../../../src';
 import { createPlugin, registeManager, useRunner } from '../core';
 
 // declare new lifecircle type

package/tests/pipeline.test.ts

@@ -1,18 +1,16 @@
 // eslint-disable-next-line eslint-comments/disable-enable-pair
 /* eslint-disable max-lines */
-import { sleep } from './helpers';
+import * as asyncHooksImpl from 'farrow-pipeline/asyncHooks.node';
 import {
   createContext,
   createContainer,
   createPipeline,
   createAsyncPipeline,
-  useAsyncPipeline,
   usePipeline,
   useContainer,
   isPipeline,
-  isAsyncPipeline,
-} from '@/index';
-import * as asyncHooksImpl from '@/asyncHooksImpl';
+} from '../src';
+import { sleep } from './helpers';
 
 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,19 +1,23 @@
 // eslint-disable-next-line eslint-comments/disable-enable-pair
 /* eslint-disable max-lines */
+import {
+  createPipeline,
+  createAsyncPipeline,
+  createContext,
+  createContainer,
+} from 'farrow-pipeline';
+import { createManager, createAsyncManager, useRunner } from '../src/manager';
+import { createWaterfall, createAsyncWaterfall } from '../src/waterfall';
+import {
+  createWorkflow,
+  createAsyncWorkflow,
+  createParallelWorkflow,
+} from '../src/workflow';
 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,
-  createParallelWorkflow,
-} from '@/workflow';
 
 describe('sync manager', () => {
   it('base useage', () => {

package/tests/tsconfig.json

@@ -7,9 +7,7 @@
     "isolatedModules": true,
     "target": "ES5",
     "esModuleInterop": true,
-    "paths": {
-      "@/*": ["../src/*"]
-    },
+    "paths": {},
     "types": ["node", "jest"]
   }
 }