@modern-js/plugin 2.41.0 → 2.42.1

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

@@ -3,10 +3,10 @@
  * license at https://github.com/farrow-js/farrow/blob/master/LICENSE
  */
 export type Context<T = any> = {
-  use: () => {
-    value: T;
-  };
-  get: () => T;
-  set: (value: T) => void;
+    use: () => {
+        value: T;
+    };
+    get: () => T;
+    set: (value: T) => void;
 };
-export declare const createContext: <T>(value: T) => Context<T>;
+export declare const createContext: <T>(value: T) => Context<T>;

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

@@ -5,7 +5,7 @@
 export type Next<I = unknown, O = unknown> = (input?: I) => O;
 export type CounterCallback<I = unknown, O = unknown> = (index: number, input: I, next: Next<I, O>) => O;
 export type Counter<I = unknown, O = unknown> = {
-  start: (input: I) => O;
-  dispatch: (index: number, input: I) => O;
+    start: (input: I) => O;
+    dispatch: (index: number, input: I) => O;
 };
-export declare const createCounter: <I, O>(callback: CounterCallback<I, O>) => Counter<I, O>;
+export declare const createCounter: <I, O>(callback: CounterCallback<I, O>) => Counter<I, O>;

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

@@ -12,18 +12,18 @@ export 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 type RunPipelineOptions<I = unknown, O = unknown> = {
-  onLast?: (input: I) => O;
+    onLast?: (input: I) => O;
 };
 export type MiddlewareInput<I = unknown, O = unknown> = Middleware<I, O> | {
-  middleware: Middleware<I, O>;
+    middleware: Middleware<I, O>;
 };
 export 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>;
+    [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 type MaybeAsync<T> = T | Promise<T>;
 export type AsyncPipeline<I = unknown, O = unknown> = Pipeline<I, MaybeAsync<O>>;
-export declare const createAsyncPipeline: <I, O>() => AsyncPipeline<I, O>;
+export declare const createAsyncPipeline: <I, O>() => AsyncPipeline<I, O>;

package/dist/types/index.d.ts

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

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

@@ -3,52 +3,52 @@ import type { ToRunners, ToThreads, CommonAPI, PluginOptions } from './types';
 export 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 type AsyncPlugin<Hooks, API> = {
-  ASYNC_PLUGIN_SYMBOL: typeof ASYNC_PLUGIN_SYMBOL;
+    ASYNC_PLUGIN_SYMBOL: typeof ASYNC_PLUGIN_SYMBOL;
 } & Required<PluginOptions<Hooks, AsyncSetup<Hooks, API>>>;
 export 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>;
+    /**
+     * 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 {};
+export {};

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

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

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

@@ -4,9 +4,9 @@ export declare const checkPlugins: <Hooks, API>(plugins: Plugin<Hooks, API>[] |
 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;
+    name: string;
 }, I extends {
-  name: string;
+    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>;
+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

@@ -3,64 +3,64 @@ import type { Hook, CommonAPI, ToRunners, ToThreads, PluginOptions } from './typ
 export type Setup<Hooks, API = Record<string, never>> = (api: API) => Partial<ToThreads<Hooks>> | void;
 declare const SYNC_PLUGIN_SYMBOL = "SYNC_PLUGIN_SYMBOL";
 export type Plugin<Hooks, API> = {
-  SYNC_PLUGIN_SYMBOL: typeof SYNC_PLUGIN_SYMBOL;
+    SYNC_PLUGIN_SYMBOL: typeof SYNC_PLUGIN_SYMBOL;
 } & Required<PluginOptions<Hooks, Setup<Hooks, API>>>;
 export 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>;
+    /**
+     * 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: {};
+    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 {};
+export {};

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

@@ -7,23 +7,27 @@ export type HooksMap = Record<string, Hook>;
 /** Extract the type of callback function from a hook. */
 export 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 type ToThreads<PS> = { [K in keyof PS]: PS[K] extends Hook ? ToThread<PS[K]> : PS[K] extends void ? void : never };
+export 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 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 type ToRunners<PS> = { [K in keyof PS]: PS[K] extends Hook ? RunnerFromHook<PS[K]> : PS[K] extends void ? void : never };
+export 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 type PluginOptions<Hooks, Setup = undefined, ExtendHooks = Record<string, unknown>> = {
-  name?: string;
-  pre?: string[];
-  post?: string[];
-  setup?: Setup;
-  rivals?: string[];
-  required?: string[];
-  usePlugins?: PluginOptions<any, any>[];
-  registerHook?: Partial<Hooks & ExtendHooks>;
+    name?: string;
+    pre?: string[];
+    post?: string[];
+    setup?: Setup;
+    rivals?: string[];
+    required?: string[];
+    usePlugins?: PluginOptions<any, any>[];
+    registerHook?: Partial<Hooks & ExtendHooks>;
 };
 /** Common api of setup function. */
 export type CommonAPI<Hooks> = {
-  useHookRunners: () => ToRunners<Hooks>;
-};
+    useHookRunners: () => ToRunners<Hooks>;
+};

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

@@ -2,20 +2,20 @@ import { MaybeAsync } from '../farrow-pipeline';
 declare const ASYNC_WATERFALL_SYMBOL: unique symbol;
 export type AsyncBrook<I = unknown> = (I: I) => MaybeAsync<I>;
 export type AsyncBrookInput<I = unknown> = AsyncBrook<I> | {
-  middleware: AsyncBrook<I>;
+    middleware: AsyncBrook<I>;
 };
 export type AsyncBrooks<I = unknown> = AsyncBrook<I>[];
 export type AsyncBrookInputs<I = unknown> = AsyncBrookInput<I>[];
 export declare const getAsyncBrook: <I>(input: AsyncBrookInput<I>) => AsyncBrook<I>;
 export type RunAsyncWaterfallOptions<I = unknown> = {
-  onLast?: AsyncBrook<I>;
+    onLast?: AsyncBrook<I>;
 };
 export type AsyncWaterfall<I> = {
-  run: (input: I, options?: RunAsyncWaterfallOptions<I>) => MaybeAsync<I>;
-  use: (...I: AsyncBrookInputs<I>) => AsyncWaterfall<I>;
-  middleware: AsyncBrook<I>;
-  [ASYNC_WATERFALL_SYMBOL]: true;
+    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 {};
+export {};

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

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

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

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

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

@@ -3,10 +3,10 @@ declare const ASYNC_WORKFLOW_SYMBOL: unique 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) => MaybeAsync<O[]>;
-  use: (...I: AsyncWorkers<I, O>) => AsyncWorkflow<I, O>;
-  [ASYNC_WORKFLOW_SYMBOL]: true;
+    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 {};
+export {};

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

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

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

@@ -1,10 +1,10 @@
 import type { AsyncWorkers } from './async';
 declare const PARALLEL_WORKFLOW_SYMBOL: unique symbol;
 export type ParallelWorkflow<I, O = any> = {
-  run: (input: I) => Promise<O[]>;
-  use: (...I: AsyncWorkers<I, O>) => ParallelWorkflow<I, O>;
-  [PARALLEL_WORKFLOW_SYMBOL]: true;
+    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 {};
+export {};

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

@@ -2,10 +2,10 @@ declare const WORKFLOW_SYMBOL: unique symbol;
 export type Worker<I, O> = (I: I) => O;
 export type Workers<I, O> = Worker<I, O>[];
 export type Workflow<I, O> = {
-  run: (input: I) => O[];
-  use: (...I: Workers<I, O>) => Workflow<I, O>;
-  [WORKFLOW_SYMBOL]: true;
+    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 {};
+export {};

package/package.json

@@ -15,7 +15,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "2.41.0",
+  "version": "2.42.1",
   "jsnext:source": "./src/index.ts",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.js",
@@ -33,15 +33,15 @@
   },
   "dependencies": {
     "@swc/helpers": "0.5.3",
-    "@modern-js/utils": "2.41.0"
+    "@modern-js/utils": "2.42.1"
   },
   "devDependencies": {
     "@types/jest": "^29",
     "@types/node": "^14",
     "typescript": "^5",
     "jest": "^29",
-    "@scripts/build": "2.41.0",
-    "@scripts/jest-config": "2.41.0"
+    "@scripts/jest-config": "2.42.1",
+    "@scripts/build": "2.42.1"
   },
   "sideEffects": false,
   "publishConfig": {