@modern-js/plugin 1.2.0 → 1.3.1

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)];