@modern-js/plugin 2.0.0-beta.7 → 2.0.1

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @modern-js/plugin
 
+## 2.0.1
+
+## 2.0.0
+
+### Major Changes
+
+- dda38c9c3e: chore: v2
+
 ## 2.0.0-beta.7
 
 ### Major Changes

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

@@ -2,7 +2,7 @@
  * 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> = {
+export type Context<T = any> = {
   create: (value: T) => Context<T>;
   use: () => {
     value: T;

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

@@ -2,9 +2,9 @@
  * 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> = {
+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;
 };

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

@@ -7,23 +7,23 @@ 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 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<unknown, unknown>;
 declare const PipelineSymbol: unique symbol;
-export declare type RunPipelineOptions<I = unknown, O = unknown> = {
+export type RunPipelineOptions<I = unknown, O = unknown> = {
   onLast?: (input: I) => O;
 };
-export declare type MiddlewareInput<I = unknown, O = unknown> = Middleware<I, O> | {
+export type MiddlewareInput<I = unknown, O = unknown> = Middleware<I, O> | {
   middleware: Middleware<I, O>;
 };
-export declare type Pipeline<I = unknown, O = unknown> = {
+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 declare type MaybeAsync<T> = T | Promise<T>;
-export declare type AsyncPipeline<I = unknown, O = unknown> = Pipeline<I, MaybeAsync<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,12 +1,12 @@
 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;
+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 declare type AsyncPlugin<Hooks, API> = {
+export type AsyncPlugin<Hooks, API> = {
   ASYNC_PLUGIN_SYMBOL: typeof ASYNC_PLUGIN_SYMBOL;
 } & Required<PluginOptions<Hooks, AsyncSetup<Hooks, API>>>;
-export declare type AsyncManager<Hooks, API> = {
+export type AsyncManager<Hooks, API> = {
   /**
    * Create a sync plugin.
    * @param setup the setup function.

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

@@ -1,12 +1,12 @@
 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;
+export 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> = {
+export type Plugin<Hooks, API> = {
   SYNC_PLUGIN_SYMBOL: typeof SYNC_PLUGIN_SYMBOL;
 } & Required<PluginOptions<Hooks, Setup<Hooks, API>>>;
-export declare type Manager<Hooks, API> = {
+export type Manager<Hooks, API> = {
   /**
    * Create a sync plugin.
    * @param setup the setup function.

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

@@ -3,23 +3,23 @@ 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>;
+export type Hook = Waterfall<any> | AsyncWaterfall<any> | Workflow<any, any> | AsyncWorkflow<any, any> | ParallelWorkflow<any> | Pipeline<any, any> | AsyncPipeline<any, any>;
+export 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;
+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 declare 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 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;
+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 declare 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 declare type PluginOptions<Hooks, Setup = undefined, ExtendHooks = Record<string, unknown>> = {
+export type PluginOptions<Hooks, Setup = undefined, ExtendHooks = Record<string, unknown>> = {
   name?: string;
   pre?: string[];
   post?: string[];
@@ -31,6 +31,6 @@ export declare type PluginOptions<Hooks, Setup = undefined, ExtendHooks = Record
 };
 /** Common api of setup function. */
 
-export declare type CommonAPI<Hooks> = {
+export type CommonAPI<Hooks> = {
   useHookRunners: () => ToRunners<Hooks>;
 };

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

@@ -1,16 +1,16 @@
 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> | {
+export type AsyncBrook<I = unknown> = (I: I) => MaybeAsync<I>;
+export 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 type AsyncBrooks<I = unknown> = AsyncBrook<I>[];
+export type AsyncBrookInputs<I = unknown> = AsyncBrookInput<I>[];
 export declare const getAsyncBrook: <I>(input: AsyncBrookInput<I>) => AsyncBrook<I>;
-export declare type RunAsyncWaterfallOptions<I = unknown> = {
+export type RunAsyncWaterfallOptions<I = unknown> = {
   onLast?: AsyncBrook<I>;
 };
-export declare type AsyncWaterfall<I> = {
+export type AsyncWaterfall<I> = {
   run: (input: I, options?: RunAsyncWaterfallOptions<I>) => MaybeAsync<I>;
   use: (...I: AsyncBrookInputs<I>) => AsyncWaterfall<I>;
   middleware: AsyncBrook<I>;

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

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

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

@@ -1,8 +1,8 @@
 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> = {
+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;

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

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

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

@@ -1,7 +1,7 @@
 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> = {
+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;

package/package.json

@@ -11,7 +11,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "2.0.0-beta.7",
+  "version": "2.0.1",
   "jsnext:source": "./src/index.ts",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/js/node/index.js",
@@ -36,8 +36,8 @@
     "@types/node": "^14",
     "typescript": "^4",
     "jest": "^27",
-    "@scripts/build": "2.0.0-beta.7",
-    "@scripts/jest-config": "2.0.0-beta.7"
+    "@scripts/build": "2.0.1",
+    "@scripts/jest-config": "2.0.1"
   },
   "sideEffects": false,
   "publishConfig": {