@modern-js/plugin 1.21.2-beta.0 → 1.21.2-beta.2

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

@@ -0,0 +1,108 @@
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import { createAsyncPipeline } from "../farrow-pipeline";
+var ASYNC_WORKFLOW_SYMBOL = Symbol["for"]('MODERN_ASYNC_WORKFLOW');
+export var isAsyncWorkflow = function isAsyncWorkflow(input) {
+  return Boolean(input === null || input === void 0 ? void 0 : input[ASYNC_WORKFLOW_SYMBOL]);
+};
+export var createAsyncWorkflow = function createAsyncWorkflow() {
+  var pipeline = createAsyncPipeline();
+
+  var use = function use() {
+    for (var _len = arguments.length, input = new Array(_len), _key = 0; _key < _len; _key++) {
+      input[_key] = arguments[_key];
+    }
+
+    pipeline.use.apply(pipeline, _toConsumableArray(input.map(mapAsyncWorkerToAsyncMiddleware)));
+    return workflow;
+  };
+
+  var run = /*#__PURE__*/function () {
+    var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(input) {
+      var result;
+      return _regeneratorRuntime().wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              result = pipeline.run(input, {
+                onLast: function onLast() {
+                  return [];
+                }
+              });
+
+              if (!isPromise(result)) {
+                _context.next = 5;
+                break;
+              }
+
+              return _context.abrupt("return", result.then(function (result) {
+                return result.filter(Boolean);
+              }));
+
+            case 5:
+              return _context.abrupt("return", result.filter(Boolean));
+
+            case 6:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, _callee);
+    }));
+
+    return function run(_x) {
+      return _ref.apply(this, arguments);
+    };
+  }();
+
+  var workflow = _objectSpread(_objectSpread({}, pipeline), {}, _defineProperty({
+    use: use,
+    run: run
+  }, ASYNC_WORKFLOW_SYMBOL, true));
+
+  return workflow;
+};
+
+var mapAsyncWorkerToAsyncMiddleware = function mapAsyncWorkerToAsyncMiddleware(worker) {
+  return /*#__PURE__*/function () {
+    var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(input, next) {
+      return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+        while (1) {
+          switch (_context2.prev = _context2.next) {
+            case 0:
+              _context2.next = 2;
+              return worker(input);
+
+            case 2:
+              _context2.t1 = _context2.sent;
+              _context2.t0 = [_context2.t1];
+              _context2.t2 = _toConsumableArray;
+              _context2.next = 7;
+              return next(input);
+
+            case 7:
+              _context2.t3 = _context2.sent;
+              _context2.t4 = (0, _context2.t2)(_context2.t3);
+              return _context2.abrupt("return", _context2.t0.concat.call(_context2.t0, _context2.t4));
+
+            case 10:
+            case "end":
+              return _context2.stop();
+          }
+        }
+      }, _callee2);
+    }));
+
+    return function (_x2, _x3) {
+      return _ref2.apply(this, arguments);
+    };
+  }();
+};
+
+function isPromise(obj) {
+  return Boolean(obj) && (_typeof(obj) === 'object' || typeof obj === 'function') && typeof obj.then === 'function';
+}

package/dist/js/treeshaking/workflow/index.js

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

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

@@ -0,0 +1,62 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import { createPipeline } from "../farrow-pipeline";
+var PARALLEL_WORKFLOW_SYMBOL = Symbol["for"]('MODERN_PARALLEL_WORKFLOW');
+export var isParallelWorkflow = function isParallelWorkflow(input) {
+  return Boolean(input === null || input === void 0 ? void 0 : input[PARALLEL_WORKFLOW_SYMBOL]);
+};
+export var createParallelWorkflow = function createParallelWorkflow() {
+  var pipeline = createPipeline();
+
+  var use = function use() {
+    for (var _len = arguments.length, input = new Array(_len), _key = 0; _key < _len; _key++) {
+      input[_key] = arguments[_key];
+    }
+
+    pipeline.use.apply(pipeline, _toConsumableArray(input.map(mapParallelWorkerToAsyncMiddleware)));
+    return workflow;
+  };
+
+  var run = /*#__PURE__*/function () {
+    var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(input) {
+      return _regeneratorRuntime().wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              return _context.abrupt("return", Promise.all(pipeline.run(input, {
+                onLast: function onLast() {
+                  return [];
+                }
+              })).then(function (result) {
+                return result.filter(Boolean);
+              }));
+
+            case 1:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, _callee);
+    }));
+
+    return function run(_x) {
+      return _ref.apply(this, arguments);
+    };
+  }();
+
+  var workflow = _objectSpread(_objectSpread({}, pipeline), {}, _defineProperty({
+    run: run,
+    use: use
+  }, PARALLEL_WORKFLOW_SYMBOL, true));
+
+  return workflow;
+};
+
+var mapParallelWorkerToAsyncMiddleware = function mapParallelWorkerToAsyncMiddleware(worker) {
+  return function (input, next) {
+    return [worker(input)].concat(_toConsumableArray(next(input)));
+  };
+};

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

@@ -0,0 +1,42 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import { createPipeline } from "../farrow-pipeline";
+var WORKFLOW_SYMBOL = Symbol["for"]('MODERN_WORKFLOW');
+export var createWorkflow = function createWorkflow() {
+  var pipeline = createPipeline();
+
+  var use = function use() {
+    for (var _len = arguments.length, input = new Array(_len), _key = 0; _key < _len; _key++) {
+      input[_key] = arguments[_key];
+    }
+
+    pipeline.use.apply(pipeline, _toConsumableArray(input.map(mapWorkerToMiddleware)));
+    return workflow;
+  };
+
+  var run = function run(input) {
+    var result = pipeline.run(input, {
+      onLast: function onLast() {
+        return [];
+      }
+    });
+    return result.filter(Boolean);
+  };
+
+  var workflow = _objectSpread(_objectSpread({}, pipeline), {}, _defineProperty({
+    use: use,
+    run: run
+  }, WORKFLOW_SYMBOL, true));
+
+  return workflow;
+};
+export var isWorkflow = function isWorkflow(input) {
+  return Boolean(input === null || input === void 0 ? void 0 : input[WORKFLOW_SYMBOL]);
+};
+
+var mapWorkerToMiddleware = function mapWorkerToMiddleware(worker) {
+  return function (input, next) {
+    return [worker(input)].concat(_toConsumableArray(next(input)));
+  };
+};

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

@@ -0,0 +1,13 @@
+/**
+ * modified from https://github.com/farrow-js/farrow/tree/master/packages/farrow-pipeline
+ * license at https://github.com/farrow-js/farrow/blob/master/LICENSE
+ */
+export declare type Context<T = any> = {
+  create: (value: T) => Context<T>;
+  use: () => {
+    value: T;
+  };
+  get: () => T;
+  set: (value: T) => void;
+};
+export declare const createContext: <T>(value: T) => Context<T>;

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

@@ -0,0 +1,11 @@
+/**
+ * modified from https://github.com/farrow-js/farrow/tree/master/packages/farrow-pipeline
+ * license at https://github.com/farrow-js/farrow/blob/master/LICENSE
+ */
+export declare type Next<I = unknown, O = unknown> = (input?: I) => O;
+export declare type CounterCallback<I = unknown, O = unknown> = (index: number, input: I, next: Next<I, O>) => O;
+export declare type Counter<I = unknown, O = unknown> = {
+  start: (input: I) => O;
+  dispatch: (index: number, input: I) => O;
+};
+export declare const createCounter: <I, O>(callback: CounterCallback<I, O>) => Counter<I, O>;

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

@@ -0,0 +1,5 @@
+/**
+ * modified from https://github.com/farrow-js/farrow/tree/master/packages/farrow-pipeline
+ * license at https://github.com/farrow-js/farrow/blob/master/LICENSE
+ */
+export * from './pipeline';

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

@@ -0,0 +1,29 @@
+/**
+ * modified from https://github.com/farrow-js/farrow/tree/master/packages/farrow-pipeline
+ * license at https://github.com/farrow-js/farrow/blob/master/LICENSE
+ */
+import { createContext, Context } from './context';
+import { Next } from './counter';
+export type { Next };
+export { createContext };
+export type { Context };
+export declare type Middleware<I = unknown, O = unknown> = (input: I, next: Next<I, O>) => O;
+export declare type Middlewares<I = unknown, O = unknown> = Middleware<I, O>[];
+export declare const isPipeline: (input: any) => input is Pipeline<unknown, unknown>;
+declare const PipelineSymbol: unique symbol;
+export declare type RunPipelineOptions<I = unknown, O = unknown> = {
+  onLast?: (input: I) => O;
+};
+export declare type MiddlewareInput<I = unknown, O = unknown> = Middleware<I, O> | {
+  middleware: Middleware<I, O>;
+};
+export declare type Pipeline<I = unknown, O = unknown> = {
+  [PipelineSymbol]: true;
+  use: (...inputs: MiddlewareInput<I, O>[]) => Pipeline<I, O>;
+  run: (input: I, options?: RunPipelineOptions<I, O>) => O;
+  middleware: Middleware<I, O>;
+};
+export declare const createPipeline: <I, O>() => Pipeline<I, O>;
+export declare type MaybeAsync<T> = T | Promise<T>;
+export declare type AsyncPipeline<I = unknown, O = unknown> = Pipeline<I, MaybeAsync<O>>;
+export declare const createAsyncPipeline: <I, O>() => AsyncPipeline<I, O>;

package/dist/types/index.d.ts

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

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

@@ -0,0 +1,63 @@
+import type { ToRunners, ToThreads, CommonAPI, PluginOptions } from './types';
+/** Setup function of async plugin. */
+
+export declare type AsyncSetup<Hooks, API = Record<string, never>> = (api: API & CommonAPI<Hooks>) => Partial<ToThreads<Hooks>> | Promise<Partial<ToThreads<Hooks>> | void> | void;
+declare const ASYNC_PLUGIN_SYMBOL = "ASYNC_PLUGIN_SYMBOL";
+export declare type AsyncPlugin<Hooks, API> = {
+  ASYNC_PLUGIN_SYMBOL: typeof ASYNC_PLUGIN_SYMBOL;
+} & Required<PluginOptions<Hooks, AsyncSetup<Hooks, API>>>;
+export declare type AsyncManager<Hooks, API> = {
+  /**
+   * Create a sync plugin.
+   * @param setup the setup function.
+   * @param options optional plugin options.
+   */
+  createPlugin: (setup?: AsyncSetup<Hooks, API>, options?: PluginOptions<Hooks, AsyncSetup<Hooks, API>>) => AsyncPlugin<Hooks, API>;
+  /**
+   * Determine if a value is a async plugin.
+   * @param input
+   */
+
+  isPlugin: (input: unknown) => input is AsyncPlugin<Hooks, API>;
+  /**
+   * Register new plugins to current manager.
+   * @param plugins one or more plugin.
+   */
+
+  usePlugin: (...plugins: Array<AsyncPlugin<Hooks, API> | PluginOptions<Hooks, AsyncSetup<Hooks, API>> | (() => PluginOptions<Hooks, AsyncSetup<Hooks, API>>)>) => AsyncManager<Hooks, API>;
+  /**
+   * Init manager, it will call the setup function of all registered plugins.
+   */
+
+  init: () => Promise<ToRunners<Hooks>>;
+  /**
+   * Run callback function.
+   * @param callback
+   */
+
+  run: <O>(cb: () => O) => O;
+  /**
+   * Register new hooks.
+   * @param newHooks
+   */
+
+  registerHook: (newHooks: Partial<Hooks>) => void;
+  /**
+   * Return a cloned manager.
+   * @param overrideAPI override the default plugin API.
+   */
+
+  clone: (overrideAPI?: Partial<API & CommonAPI<Hooks>>) => AsyncManager<Hooks, API>;
+  /**
+   * Clear all registered plugins.
+   */
+
+  clear: () => void;
+  /**
+   * Get all runner functions of the hooks.
+   */
+
+  useRunner: () => ToRunners<Hooks>;
+};
+export declare const createAsyncManager: <Hooks extends Record<string, any>, API extends Record<string, any> = Record<string, never>>(hooks?: Partial<Hooks> | undefined, api?: API | undefined) => AsyncManager<Hooks, API>;
+export {};

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

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

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

@@ -0,0 +1,12 @@
+import type { AsyncPlugin } from './async';
+import type { Plugin } from './sync';
+export declare const checkPlugins: <Hooks, API>(plugins: Plugin<Hooks, API>[] | AsyncPlugin<Hooks, API>[]) => void;
+export declare function sortPlugins<Hooks, API>(input: Plugin<Hooks, API>[]): Plugin<Hooks, API>[];
+export declare function sortPlugins<Hooks, API>(input: AsyncPlugin<Hooks, API>[]): AsyncPlugin<Hooks, API>[];
+export declare const includePlugin: <P extends {
+  name: string;
+}, I extends {
+  name: string;
+}>(plugins: P[], input: I) => boolean;
+export declare const isObject: (obj: unknown) => obj is Record<string, any>;
+export declare const hasOwnProperty: <X extends Record<string, unknown>, Y extends PropertyKey>(obj: X, prop: Y) => obj is X & Record<Y, unknown>;

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

@@ -0,0 +1,75 @@
+import type { Hook, CommonAPI, ToRunners, ToThreads, PluginOptions } from './types';
+/** Setup function of sync plugin. */
+
+export declare type Setup<Hooks, API = Record<string, never>> = (api: API) => Partial<ToThreads<Hooks>> | void;
+declare const SYNC_PLUGIN_SYMBOL = "SYNC_PLUGIN_SYMBOL";
+export declare type Plugin<Hooks, API> = {
+  SYNC_PLUGIN_SYMBOL: typeof SYNC_PLUGIN_SYMBOL;
+} & Required<PluginOptions<Hooks, Setup<Hooks, API>>>;
+export declare type Manager<Hooks, API> = {
+  /**
+   * Create a sync plugin.
+   * @param setup the setup function.
+   * @param options optional plugin options.
+   */
+  createPlugin: (setup?: Setup<Hooks, API>, options?: PluginOptions<Hooks, Setup<Hooks, API>>) => Plugin<Hooks, API>;
+  /**
+   * Determine if a value is a sync plugin.
+   * @param input
+   */
+
+  isPlugin: (input: unknown) => input is Plugin<Hooks, API>;
+  /**
+   * Register new plugins to current manager.
+   * @param plugins one or more plugin.
+   */
+
+  usePlugin: (...plugins: Array<Plugin<Hooks, API> | PluginOptions<Hooks, Setup<Hooks, API>> | (() => PluginOptions<Hooks, Setup<Hooks, API>>)>) => Manager<Hooks, API>;
+  /**
+   * Init manager, it will call the setup function of all registered plugins.
+   */
+
+  init: () => ToRunners<Hooks>;
+  /**
+   * Run callback function.
+   * @param callback
+   */
+
+  run: <O>(cb: () => O) => O;
+  /**
+   * Register new hooks.
+   * @param newHooks
+   */
+
+  registerHook: (hewHooks: Partial<Hooks>) => void;
+  /**
+   * Clear all registered plugins.
+   */
+
+  clear: () => void;
+  /**
+   * Return a cloned manager.
+   * @param overrideAPI override the default plugin API.
+   */
+
+  clone: (overrideAPI?: Partial<API & CommonAPI<Hooks>>) => Manager<Hooks, API>;
+  /**
+   * Get all runner functions of the hooks.
+   */
+
+  useRunner: () => ToRunners<Hooks>;
+};
+export declare const DEFAULT_OPTIONS: {
+  name: string;
+  pre: never[];
+  post: never[];
+  rivals: never[];
+  required: never[];
+  usePlugins: never[];
+  registerHook: {};
+};
+export declare const createManager: <Hooks extends Record<string, any>, API extends Record<string, any> = Record<string, never>>(hooks?: Partial<Hooks> | undefined, api?: API | undefined) => Manager<Hooks, API>;
+export declare const generateRunner: <Hooks extends Record<string, any>>(hooksList: (void | Partial<ToThreads<Hooks>>)[], hooksMap?: Hooks | undefined) => ToRunners<Hooks>;
+export declare const cloneHook: (hook: Hook) => Hook;
+export declare const cloneHooksMap: <Hooks>(record: Hooks) => Hooks;
+export {};

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

@@ -0,0 +1,36 @@
+import type { Pipeline, MaybeAsync, Middleware, AsyncPipeline } from '../farrow-pipeline';
+import type { Brook, Waterfall, AsyncBrook, AsyncWaterfall } from '../waterfall';
+import type { Worker, Workflow, AsyncWorker, AsyncWorkflow, ParallelWorkflow } from '../workflow';
+/** All hook types. */
+
+export declare type Hook = Waterfall<any> | AsyncWaterfall<any> | Workflow<any, any> | AsyncWorkflow<any, any> | ParallelWorkflow<any> | Pipeline<any, any> | AsyncPipeline<any, any>;
+export declare type HooksMap = Record<string, Hook>;
+/** Extract the type of callback function from a hook. */
+
+export declare type ToThread<P extends Hook> = 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;
+/** Extract types of callback function from hooks. */
+
+export declare type ToThreads<PS> = { [K in keyof PS]: PS[K] extends Hook ? ToThread<PS[K]> : PS[K] extends void ? void : never };
+/** Extract run method from a hook. */
+
+export declare type RunnerFromHook<P extends Hook> = 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;
+/** Extract all run methods from hooks. */
+
+export declare type ToRunners<PS> = { [K in keyof PS]: PS[K] extends Hook ? RunnerFromHook<PS[K]> : PS[K] extends void ? void : never };
+/** All options to define a plugin. */
+
+export declare type PluginOptions<Hooks, Setup = undefined, ExtendHooks = Record<string, unknown>> = {
+  name?: string;
+  pre?: string[];
+  post?: string[];
+  setup?: Setup;
+  rivals?: string[];
+  required?: string[];
+  usePlugins?: PluginOptions<Hooks, Setup>[];
+  registerHook?: Partial<Hooks & ExtendHooks>;
+};
+/** Common api of setup function. */
+
+export declare type CommonAPI<Hooks> = {
+  useHookRunners: () => ToRunners<Hooks>;
+};

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

@@ -0,0 +1,21 @@
+import { MaybeAsync } from '../farrow-pipeline';
+declare const ASYNC_WATERFALL_SYMBOL: unique symbol;
+export declare type AsyncBrook<I = unknown> = (I: I) => MaybeAsync<I>;
+export declare type AsyncBrookInput<I = unknown> = AsyncBrook<I> | {
+  middleware: AsyncBrook<I>;
+};
+export declare type AsyncBrooks<I = unknown> = AsyncBrook<I>[];
+export declare type AsyncBrookInputs<I = unknown> = AsyncBrookInput<I>[];
+export declare const getAsyncBrook: <I>(input: AsyncBrookInput<I>) => AsyncBrook<I>;
+export declare type RunAsyncWaterfallOptions<I = unknown> = {
+  onLast?: AsyncBrook<I>;
+};
+export declare type AsyncWaterfall<I> = {
+  run: (input: I, options?: RunAsyncWaterfallOptions<I>) => MaybeAsync<I>;
+  use: (...I: AsyncBrookInputs<I>) => AsyncWaterfall<I>;
+  middleware: AsyncBrook<I>;
+  [ASYNC_WATERFALL_SYMBOL]: true;
+};
+export declare const createAsyncWaterfall: <I = void>() => AsyncWaterfall<I>;
+export declare const isAsyncWaterfall: (input: any) => input is AsyncWaterfall<any>;
+export {};

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

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

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

@@ -0,0 +1,20 @@
+declare const WATERFALL_SYMBOL: unique symbol;
+export declare type Brook<I = unknown> = (I: I) => I;
+export declare type BrookInput<I = unknown> = Brook<I> | {
+  middleware: Brook<I>;
+};
+export declare type Brooks<I = unknown> = Brook<I>[];
+export declare type BrookInputs<I = unknown> = BrookInput<I>[];
+export declare const getBrook: <I>(input: BrookInput<I>) => Brook<I>;
+export declare type RunWaterfallOptions<I = unknown> = {
+  onLast?: Brook<I>;
+};
+export declare type Waterfall<I = void> = {
+  run: (input: I, options?: RunWaterfallOptions<I>) => I;
+  use: (...I: BrookInputs<I>) => Waterfall<I>;
+  middleware: Brook<I>;
+  [WATERFALL_SYMBOL]: true;
+};
+export declare const createWaterfall: <I = void>() => Waterfall<I>;
+export declare const isWaterfall: (input: any) => input is Waterfall<any>;
+export {};

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

@@ -0,0 +1,12 @@
+import { MaybeAsync } from '../farrow-pipeline';
+declare const ASYNC_WORKFLOW_SYMBOL: unique symbol;
+export declare type AsyncWorker<I, O> = (I: I) => MaybeAsync<O>;
+export declare type AsyncWorkers<I, O> = AsyncWorker<I, O>[];
+export declare type AsyncWorkflow<I, O> = {
+  run: (input: I) => MaybeAsync<O[]>;
+  use: (...I: AsyncWorkers<I, O>) => AsyncWorkflow<I, O>;
+  [ASYNC_WORKFLOW_SYMBOL]: true;
+};
+export declare const isAsyncWorkflow: (input: any) => input is AsyncWorkflow<any, any>;
+export declare const createAsyncWorkflow: <I = void, O = unknown>() => AsyncWorkflow<I, O>;
+export {};

package/dist/types/workflow/index.d.ts

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

package/dist/types/workflow/parallel.d.ts

@@ -0,0 +1,10 @@
+import type { AsyncWorkers } from './async';
+declare const PARALLEL_WORKFLOW_SYMBOL: unique symbol;
+export declare type ParallelWorkflow<I, O = any> = {
+  run: (input: I) => Promise<O[]>;
+  use: (...I: AsyncWorkers<I, O>) => ParallelWorkflow<I, O>;
+  [PARALLEL_WORKFLOW_SYMBOL]: true;
+};
+export declare const isParallelWorkflow: (input: any) => input is ParallelWorkflow<any, any>;
+export declare const createParallelWorkflow: <I = void, O = unknown>() => ParallelWorkflow<I, O>;
+export {};

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

@@ -0,0 +1,11 @@
+declare const WORKFLOW_SYMBOL: unique symbol;
+export declare type Worker<I, O> = (I: I) => O;
+export declare type Workers<I, O> = Worker<I, O>[];
+export declare type Workflow<I, O> = {
+  run: (input: I) => O[];
+  use: (...I: Workers<I, O>) => Workflow<I, O>;
+  [WORKFLOW_SYMBOL]: true;
+};
+export declare const createWorkflow: <I = void, O = unknown>() => Workflow<I, O>;
+export declare const isWorkflow: (input: any) => input is Workflow<unknown, unknown>;
+export {};

package/package.json

@@ -11,7 +11,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "1.21.2-beta.0",
+  "version": "1.21.2-beta.2",
   "jsnext:source": "./src/index.ts",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/js/node/index.js",
@@ -24,7 +24,7 @@
         "import": "./dist/js/modern/index.js",
         "require": "./dist/js/node/index.js"
       },
-      "types": "./dist/types/index.d.ts",
+      "types": "./dist/types//index.d.js",
       "default": "./dist/js/treeshaking/index.js"
     }
   },