@modern-js/plugin 2.69.4 → 3.0.0-alpha.0

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

@@ -1,11 +0,0 @@
-/**
- * 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 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;
-};
-export declare const createCounter: <I, O>(callback: CounterCallback<I, O>) => Counter<I, O>;

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

@@ -1,29 +0,0 @@
-/**
- * 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 { type Context, createContext } from './context';
-import { type Next } from './counter';
-export type { Next };
-export { createContext };
-export type { Context };
-export type Middleware<I = unknown, O = unknown> = (input: I, next: Next<I, O>) => O;
-export type Middlewares<I = unknown, O = unknown> = Middleware<I, O>[];
-export declare const isPipeline: (input: any) => input is Pipeline;
-declare const PipelineSymbol: unique symbol;
-export type RunPipelineOptions<I = unknown, O = unknown> = {
-    onLast?: (input: I) => O;
-};
-export type MiddlewareInput<I = unknown, O = unknown> = 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>;
-};
-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>;

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

@@ -1,54 +0,0 @@
-import type { CommonAPI, PluginOptions, ToRunners, ToThreads } from './types';
-/** Setup function of async plugin. */
-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;
-} & 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>;
-};
-export declare const createAsyncManager: <Hooks extends Record<string, any>, API extends Record<string, any> = Record<string, never>>(hooks?: Partial<Hooks>, api?: API) => AsyncManager<Hooks, API>;
-export {};

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

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

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

@@ -1,12 +0,0 @@
-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

@@ -1,66 +0,0 @@
-import type { CommonAPI, Hook, PluginOptions, ToRunners, ToThreads } from './types';
-/** Setup function of sync plugin. */
-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;
-} & 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>;
-};
-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>, api?: API) => Manager<Hooks, API>;
-export declare const generateRunner: <Hooks extends Record<string, any>>(hooksList: (void | Partial<ToThreads<Hooks>>)[], hooksMap?: Hooks) => 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

@@ -1,33 +0,0 @@
-import type { AsyncPipeline, MaybeAsync, Middleware, Pipeline } from '../farrow-pipeline';
-import type { AsyncBrook, AsyncWaterfall, Brook, Waterfall } from '../waterfall';
-import type { AsyncInterruptWorker, AsyncInterruptWorkflow, AsyncWorker, AsyncWorkflow, ParallelWorkflow, SyncParallelWorkflow, Worker, Workflow } from '../workflow';
-/** All hook types. */
-export type Hook = Waterfall<any> | AsyncWaterfall<any> | Workflow<any, any> | AsyncWorkflow<any, any> | ParallelWorkflow<any> | SyncParallelWorkflow<any> | Pipeline<any, any> | AsyncPipeline<any, any> | AsyncInterruptWorkflow<any, any>;
-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 SyncParallelWorkflow<infer I, infer O> ? Worker<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>> : P extends AsyncInterruptWorkflow<infer I, infer O> ? AsyncInterruptWorker<I, 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;
-};
-/** 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 SyncParallelWorkflow<infer I, infer O> ? SyncParallelWorkflow<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'] : P extends AsyncInterruptWorkflow<infer I, infer O> ? AsyncInterruptWorkflow<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;
-};
-/** 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>;
-};
-/** Common api of setup function. */
-export type CommonAPI<Hooks> = {
-    useHookRunners: () => ToRunners<Hooks>;
-};

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

@@ -1,21 +0,0 @@
-import { type 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>;
-};
-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>;
-};
-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;
-};
-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

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

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

@@ -1,20 +0,0 @@
-declare const WATERFALL_SYMBOL: unique symbol;
-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 declare const getBrook: <I>(input: BrookInput<I>) => Brook<I>;
-export type RunWaterfallOptions<I = unknown> = {
-    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;
-};
-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

@@ -1,12 +0,0 @@
-import { type MaybeAsync } from '../farrow-pipeline';
-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;
-};
-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

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

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

@@ -1,12 +0,0 @@
-import { type MaybeAsync } from '../farrow-pipeline';
-declare const ASYNC_INTERRUPT_WORKFLOW_SYMBOL: unique symbol;
-export type AsyncInterruptWorker<I, O> = (I: I, interrupt: (result: any) => void) => MaybeAsync<O>;
-export type AsyncInterruptWorkers<I, O> = AsyncInterruptWorker<I, O>[];
-export type AsyncInterruptWorkflow<I, O> = {
-    run: (input: I) => MaybeAsync<O[]>;
-    use: (...I: AsyncInterruptWorkers<I, O>) => AsyncInterruptWorkflow<I, O>;
-    [ASYNC_INTERRUPT_WORKFLOW_SYMBOL]: true;
-};
-export declare const isAsyncInterruptWorkflow: (input: any) => input is AsyncInterruptWorkflow<any, any>;
-export declare const createAsyncInterruptWorkflow: <I = void, O = unknown>() => AsyncInterruptWorkflow<I, O>;
-export {};

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

@@ -1,10 +0,0 @@
-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;
-};
-export declare const isParallelWorkflow: (input: any) => input is ParallelWorkflow<any>;
-export declare const createParallelWorkflow: <I = void, O = unknown>() => ParallelWorkflow<I, O>;
-export {};

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

@@ -1,11 +0,0 @@
-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;
-};
-export declare const createWorkflow: <I = void, O = unknown>() => Workflow<I, O>;
-export declare const isWorkflow: (input: any) => input is Workflow<unknown, unknown>;
-export {};

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

@@ -1,10 +0,0 @@
-import type { Workers } from './sync';
-declare const SYNC_PARALLEL_WORKFLOW_SYMBOL: unique symbol;
-export type SyncParallelWorkflow<I, O = any> = {
-    run: (input: I) => O[];
-    use: (...I: Workers<I, O>) => SyncParallelWorkflow<I, O>;
-    [SYNC_PARALLEL_WORKFLOW_SYMBOL]: true;
-};
-export declare const isSyncParallelWorkflow: (input: any) => input is SyncParallelWorkflow<any>;
-export declare const createSyncParallelWorkflow: <I = void, O = unknown>() => SyncParallelWorkflow<I, O>;
-export {};