@modern-js/plugin 1.3.8 → 1.4.0-alpha.0

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

@@ -1,6 +1,6 @@
 import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
 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";
@@ -21,16 +21,16 @@ export var createParallelWorkflow = function createParallelWorkflow() {
   };
 
   var run = /*#__PURE__*/function () {
-    var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(input, options) {
+    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, _objectSpread(_objectSpread({}, options), {}, {
+              return _context.abrupt("return", Promise.all(pipeline.run(input, {
                 onLast: function onLast() {
                   return [];
                 }
-              }))).then(function (result) {
+              })).then(function (result) {
                 return result.filter(Boolean);
               }));
 
@@ -42,7 +42,7 @@ export var createParallelWorkflow = function createParallelWorkflow() {
       }, _callee);
     }));
 
-    return function run(_x, _x2) {
+    return function run(_x) {
       return _ref.apply(this, arguments);
     };
   }();

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

@@ -15,12 +15,12 @@ export var createWorkflow = function createWorkflow() {
     return workflow;
   };
 
-  var run = function run(input, options) {
-    var result = pipeline.run(input, _objectSpread(_objectSpread({}, options), {}, {
+  var run = function run(input) {
+    var result = pipeline.run(input, {
       onLast: function onLast() {
         return [];
       }
-    }));
+    });
     return result.filter(Boolean);
   };
 

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

@@ -1,7 +1,8 @@
-declare const ContextSymbol: unique symbol;
+/**
+ * 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> = {
-  id: symbol;
-  [ContextSymbol]: T;
   create: (value: T) => Context<T>;
   use: () => {
     value: T;
@@ -9,20 +10,4 @@ export declare type Context<T = any> = {
   get: () => T;
   set: (value: T) => void;
 };
-export declare const createContext: <T>(value: T) => Context<T>;
-export declare type ContextStorage = {
-  [key: string]: Context;
-};
-export declare type Container = {
-  read: <V>(Context: Context<V>) => V;
-  write: <V>(Context: Context<V>, value: V) => void;
-};
-export declare const createContainer: (ContextStorage?: ContextStorage) => Container;
-export declare type Hooks = {
-  useContainer: () => Container;
-};
-export type { AnyFn } from './asyncHooksInterface';
-export declare const runHooks: <F extends import("./asyncHooksInterface").AnyFn>(f: F, implementations: Hooks) => ReturnType<F>;
-export declare const useContainer: () => Container;
-export declare const fromContainer: (container: Container) => Hooks;
-export declare const runWithContainer: <F extends (...args: any) => any>(f: F, container: Container) => ReturnType<F>;
+export declare const createContext: <T>(value: T) => Context<T>;

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

@@ -1,19 +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
- *
- * removed:
- *  - dependencies:
- *    - tslib
- *  - files
- *    - compose.ts
- *  - methods:
- *    - usePipeline
- *    - assertContainer
- *    - assertContext
- *    - isContext
- *    - isContainer
- *    - pipeline.useLazy
- *    - context.assert
  */
 export * from './pipeline';

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

@@ -2,37 +2,28 @@
  * 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, createContainer, ContextStorage, Context, Container, useContainer, runWithContainer } from './context';
+import { createContext, Context } from './context';
 import { Next } from './counter';
 export type { Next };
-export { createContext, createContainer, useContainer, runWithContainer };
-export type { ContextStorage, Context, Container };
+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 PipelineOptions = {
-  contexts?: ContextStorage;
-};
 export declare type RunPipelineOptions<I = unknown, O = unknown> = {
-  container?: Container;
   onLast?: (input: I) => O;
-  onLastWithContext?: boolean;
 };
 export declare type MiddlewareInput<I = unknown, O = unknown> = Middleware<I, O> | {
   middleware: Middleware<I, O>;
 };
-export declare type MiddlewareType<T extends MiddlewareInput> = T extends MiddlewareInput<infer I, infer O> ? Middleware<I, O> : never;
 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>(options?: PipelineOptions | undefined) => Pipeline<I, O>;
-export declare type PipelineInput<T extends Pipeline> = T extends Pipeline<infer I> ? I : never;
-export declare type PipelineOutput<T extends Pipeline> = T extends Pipeline<any, infer O> ? O : never;
+export declare const createPipeline: <I, O>() => Pipeline<I, O>;
 export declare type MaybeAsync<T> = T | Promise<T>;
-export declare type ThunkMiddlewareInput<I, O> = () => MaybeAsync<MiddlewareInput<I, MaybeAsync<O>>>;
 export declare type AsyncPipeline<I = unknown, O = unknown> = Pipeline<I, MaybeAsync<O>>;
-export declare const createAsyncPipeline: <I, O>(options?: PipelineOptions | undefined) => AsyncPipeline<I, O>;
+export declare const createAsyncPipeline: <I, O>() => AsyncPipeline<I, O>;

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

@@ -1,4 +1,4 @@
-import type { ToRunners, ToThreads, CommonAPI, InitOptions, PluginOptions } from './types';
+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;
@@ -6,7 +6,6 @@ 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 PluginFromAsyncManager<M extends AsyncManager<any, any>> = M extends AsyncManager<infer Hooks, infer API> ? AsyncPlugin<Hooks, API> : never;
 export declare type AsyncManager<Hooks, API> = {
   /**
    * Create a sync plugin.
@@ -28,17 +27,15 @@ export declare type AsyncManager<Hooks, API> = {
   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.
-   * @param options passing a custom container.
    */
 
-  init: (options?: InitOptions) => Promise<ToRunners<Hooks>>;
+  init: () => Promise<ToRunners<Hooks>>;
   /**
-   * Run callback function with current container.
+   * Run callback function.
    * @param callback
-   * @param options passing a custom container.
    */
 
-  run: <O>(cb: () => O, options?: InitOptions) => O;
+  run: <O>(cb: () => O) => O;
   /**
    * Register new hooks.
    * @param newHooks

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

@@ -1,3 +1,2 @@
-export type { Context } from '../farrow-pipeline/context';
 export declare const RunnerContext: import("../farrow-pipeline").Context<any>;
 export declare const useRunner: () => any;

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

@@ -1,5 +1,4 @@
-import { Container } from '../farrow-pipeline';
-import type { Hook, CommonAPI, ToRunners, ToThreads, InitOptions, PluginOptions } from './types';
+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;
@@ -7,7 +6,6 @@ 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 PluginFromManager<M extends Manager<any, any>> = M extends Manager<infer Hooks, infer API> ? Plugin<Hooks, API> : never;
 export declare type Manager<Hooks, API> = {
   /**
    * Create a sync plugin.
@@ -29,17 +27,15 @@ export declare type Manager<Hooks, API> = {
   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.
-   * @param options passing a custom container.
    */
 
-  init: (options?: InitOptions) => ToRunners<Hooks>;
+  init: () => ToRunners<Hooks>;
   /**
-   * Run callback function with current container.
+   * Run callback function.
    * @param callback
-   * @param options passing a custom container.
    */
 
-  run: <O>(cb: () => O, options?: InitOptions) => O;
+  run: <O>(cb: () => O) => O;
   /**
    * Register new hooks.
    * @param newHooks
@@ -73,7 +69,7 @@ export declare const DEFAULT_OPTIONS: {
   registerHook: {};
 };
 export declare const createManager: <Hooks, 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>>)[], container: Container, hooksMap?: Hooks | undefined) => ToRunners<Hooks>;
+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 closeHooksMap: <Hooks>(record: Hooks) => Hooks;
 export {};

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

@@ -1,4 +1,4 @@
-import type { Pipeline, Container, MaybeAsync, Middleware, AsyncPipeline } from '../farrow-pipeline';
+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. */
@@ -29,11 +29,6 @@ export declare type PluginOptions<Hooks, Setup = undefined> = {
   usePlugins?: PluginOptions<Hooks, Setup>[];
   registerHook?: Partial<Hooks>;
 };
-/** Options of manager.init method. */
-
-export declare type InitOptions = {
-  container?: Container;
-};
 /** Common api of setup function. */
 
 export declare type CommonAPI<Hooks> = {

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

@@ -1,4 +1,4 @@
-import { MaybeAsync, Container } from '../farrow-pipeline';
+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> | {
@@ -8,7 +8,6 @@ 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> = {
-  container?: Container;
   onLast?: AsyncBrook<I>;
 };
 export declare type AsyncWaterfall<I> = {
@@ -17,11 +16,6 @@ export declare type AsyncWaterfall<I> = {
   middleware: AsyncBrook<I>;
   [ASYNC_WATERFALL_SYMBOL]: true;
 };
-export declare type AsyncWaterfall2AsyncBrook<P extends AsyncWaterfall<any>> = P extends AsyncWaterfall<infer I> ? AsyncBrook<I> : never;
-export declare type AsyncWaterfallRecord = Record<string, AsyncWaterfall<any>>;
-export declare type AsyncWaterfalls2Brooks<PS extends AsyncWaterfallRecord | void> = { [K in keyof PS]: PS[K] extends AsyncWaterfall<any> ? AsyncWaterfall2AsyncBrook<PS[K]> : PS[K] extends void ? void : never };
-export declare type RunnerFromAsyncWaterfall<M extends AsyncWaterfall<any>> = M extends AsyncWaterfall<infer VS> ? AsyncWaterfall<VS>['run'] : never;
-export declare type AsyncWaterfalls2Runners<PS extends AsyncWaterfallRecord | void> = { [K in keyof PS]: PS[K] extends AsyncWaterfall<any> ? RunnerFromAsyncWaterfall<PS[K]> : PS[K] extends void ? void : never };
 export declare const createAsyncWaterfall: <I = void>() => AsyncWaterfall<I>;
 export declare const isAsyncWaterfall: (input: any) => input is AsyncWaterfall<any>;
 export {};

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

@@ -1,4 +1,3 @@
-import { Container } from '../farrow-pipeline';
 declare const WATERFALL_SYMBOL: unique symbol;
 export declare type Brook<I = unknown> = (I: I) => I;
 export declare type BrookInput<I = unknown> = Brook<I> | {
@@ -8,7 +7,6 @@ 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> = {
-  container?: Container;
   onLast?: Brook<I>;
 };
 export declare type Waterfall<I = void> = {
@@ -17,11 +15,6 @@ export declare type Waterfall<I = void> = {
   middleware: Brook<I>;
   [WATERFALL_SYMBOL]: true;
 };
-export declare type Waterfall2Brook<P extends Waterfall<any>> = P extends Waterfall<infer I> ? Brook<I> : never;
-export declare type WaterfallRecord = Record<string, Waterfall<any>>;
-export declare type Waterfalls2Brooks<PS extends WaterfallRecord | void> = { [K in keyof PS]: PS[K] extends Waterfall<any> ? Waterfall2Brook<PS[K]> : PS[K] extends void ? void : never };
-export declare type RunnerFromWaterfall<M extends Waterfall<any>> = M extends Waterfall<infer VS> ? Waterfall<VS>['run'] : never;
-export declare type Waterfalls2Runners<PS extends WaterfallRecord | void> = { [K in keyof PS]: PS[K] extends Waterfall<any> ? RunnerFromWaterfall<PS[K]> : PS[K] extends void ? void : never };
 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,18 +1,12 @@
 import { MaybeAsync } from '../farrow-pipeline';
-import type { RunWorkflowOptions } from './sync';
 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, options?: RunWorkflowOptions) => MaybeAsync<O[]>;
+  run: (input: I) => MaybeAsync<O[]>;
   use: (...I: AsyncWorkers<I, O>) => AsyncWorkflow<I, O>;
   [ASYNC_WORKFLOW_SYMBOL]: true;
 };
-export declare type AsyncWorkflow2AsyncWorker<W extends AsyncWorkflow<any, any>> = W extends AsyncWorkflow<infer I, infer O> ? AsyncWorker<I, O> : never;
-export declare type AsyncWorkflowRecord = Record<string, AsyncWorkflow<any, any>>;
-export declare type AsyncWorkflows2AsyncWorkers<PS extends AsyncWorkflowRecord | void> = { [K in keyof PS]: PS[K] extends AsyncWorkflow<any, any> ? AsyncWorkflow2AsyncWorker<PS[K]> : PS[K] extends void ? void : never };
-export declare type RunnerFromAsyncWorkflow<W extends AsyncWorkflow<any, any>> = W extends AsyncWorkflow<infer I, infer O> ? AsyncWorkflow<I, O>['run'] : never;
-export declare type AsyncWorkflows2Runners<PS extends AsyncWorkflowRecord | void> = { [K in keyof PS]: PS[K] extends AsyncWorkflow<any, any> ? RunnerFromAsyncWorkflow<PS[K]> : PS[K] extends void ? void : never };
 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/parallel.d.ts

@@ -1,17 +1,10 @@
-import type { AsyncWorker, AsyncWorkers } from './async';
-import type { RunWorkflowOptions } from './sync';
+import type { AsyncWorkers } from './async';
 declare const PARALLEL_WORKFLOW_SYMBOL: unique symbol;
 export declare type ParallelWorkflow<I, O = any> = {
-  run: (input: I, options?: RunWorkflowOptions) => Promise<O[]>;
+  run: (input: I) => Promise<O[]>;
   use: (...I: AsyncWorkers<I, O>) => ParallelWorkflow<I, O>;
   [PARALLEL_WORKFLOW_SYMBOL]: true;
 };
-export declare type ParallelWorkflow2Worker<W extends ParallelWorkflow<any>> = W extends ParallelWorkflow<infer CS, infer O> ? AsyncWorker<CS, O> : never;
-export declare type ParallelWorkflowRecord = Record<string, ParallelWorkflow<any>>;
-export declare type ParallelWorkflows2Workers<PS extends ParallelWorkflowRecord | void> = { [K in keyof PS]: PS[K] extends ParallelWorkflow<any> ? ParallelWorkflow2Worker<PS[K]> : PS[K] extends void ? void : never };
-export declare type ParallelWorkflows2AsyncWorkers<PS extends ParallelWorkflowRecord | void> = { [K in keyof PS]: PS[K] extends ParallelWorkflow<any> ? ParallelWorkflow2Worker<PS[K]> : PS[K] extends void ? void : never };
-export declare type RunnerFromParallelWorkflow<W extends ParallelWorkflow<any>> = W extends ParallelWorkflow<infer CS, infer O> ? ParallelWorkflow<CS, O>['run'] : never;
-export declare type ParallelWorkflows2Runners<PS extends ParallelWorkflowRecord | void> = { [K in keyof PS]: PS[K] extends ParallelWorkflow<any> ? RunnerFromParallelWorkflow<PS[K]> : PS[K] extends void ? void : never };
 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

@@ -1,20 +1,11 @@
-import { Container } from '../farrow-pipeline';
 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 RunWorkflowOptions = {
-  container?: Container;
-};
 export declare type Workflow<I, O> = {
-  run: (input: I, options?: RunWorkflowOptions) => void;
+  run: (input: I) => void;
   use: (...I: Workers<I, O>) => Workflow<I, O>;
   [WORKFLOW_SYMBOL]: true;
 };
-export declare type Workflow2Worker<W extends Workflow<any, any>> = W extends Workflow<infer I, infer O> ? Worker<I, O> : never;
-export declare type WorkflowRecord = Record<string, Workflow<any, any>>;
-export declare type Workflows2Workers<PS extends WorkflowRecord | void> = { [K in keyof PS]: PS[K] extends Workflow<any, any> ? Workflow2Worker<PS[K]> : PS[K] extends void ? void : never };
-export declare type RunnerFromWorkflow<W extends Workflow<any, any>> = W extends Workflow<infer I, infer O> ? Workflow<I, O>['run'] : never;
-export declare type Workflows2Runners<PS extends WorkflowRecord | void> = { [K in keyof PS]: PS[K] extends Workflow<any, any> ? RunnerFromWorkflow<PS[K]> : PS[K] extends void ? void : never };
 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.3.8",
+  "version": "1.4.0-alpha.0",
   "jsnext:source": "./src/index.ts",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/js/node/index.js",
@@ -25,17 +25,6 @@
         "require": "./dist/js/node/index.js"
       },
       "default": "./dist/js/treeshaking/index.js"
-    },
-    "./node": {
-      "jsnext:source": "./src/farrow-pipeline/asyncHooks.node.ts",
-      "default": "./dist/js/node/farrow-pipeline/asyncHooks.node.js"
-    }
-  },
-  "typesVersions": {
-    "*": {
-      "node": [
-        "./dist/types/farrow-pipeline/asyncHooks.node.d.ts"
-      ]
     }
   },
   "dependencies": {

package/dist/js/modern/farrow-pipeline/asyncHooks.node.js

@@ -1,80 +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 NodeAsyncHooks from 'async_hooks';
-import * as asyncHooksInterface from "./asyncHooksInterface";
-
-const createAsyncHooks = () => {
-  const store = new Map(); // eslint-disable-next-line node/no-unsupported-features/node-builtins
-
-  const hooks = NodeAsyncHooks.createHook({
-    init: (asyncId, _, triggerAsyncId) => {
-      if (store.has(triggerAsyncId)) {
-        const value = store.get(triggerAsyncId);
-
-        if (value) {
-          store.set(asyncId, value);
-        }
-      }
-    },
-    destroy: asyncId => {
-      if (store.has(asyncId)) {
-        store.delete(asyncId);
-      }
-    }
-  });
-
-  const set = value => {
-    store.set(NodeAsyncHooks.executionAsyncId(), value);
-  };
-
-  const get = () => {
-    return store.get(NodeAsyncHooks.executionAsyncId());
-  };
-
-  const clear = () => {
-    store.clear();
-  };
-
-  const enable = () => {
-    hooks.enable();
-  };
-
-  const disable = () => {
-    hooks.disable();
-    store.clear();
-  };
-
-  const entries = () => {
-    return store.entries();
-  };
-
-  return {
-    enable,
-    disable,
-    set,
-    get,
-    clear,
-    entries
-  };
-};
-
-let enabled = false;
-export const enable = () => {
-  if (enabled) {
-    return;
-  }
-
-  enabled = true;
-  const hooks = createAsyncHooks();
-  asyncHooksInterface.impl(hooks);
-  hooks.enable();
-};
-export const disable = () => {
-  var _asyncHooksInterface$;
-
-  enabled = false;
-  (_asyncHooksInterface$ = asyncHooksInterface.asyncHooks) === null || _asyncHooksInterface$ === void 0 ? void 0 : _asyncHooksInterface$.disable();
-  asyncHooksInterface.reset();
-};

package/dist/js/modern/farrow-pipeline/asyncHooksInterface.js

@@ -1,12 +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
- */
-// eslint-disable-next-line import/no-mutable-exports
-export let asyncHooks;
-export const impl = implimentations => {
-  asyncHooks = implimentations;
-};
-export const reset = () => {
-  asyncHooks = undefined;
-};

package/dist/js/modern/farrow-pipeline/hook.js

@@ -1,42 +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 { asyncHooks } from "./asyncHooksInterface";
-export const createHooks = defaultHooks => {
-  let currentHooks = {};
-  const hooks = {};
-
-  for (const key in defaultHooks) {
-    // eslint-disable-next-line @typescript-eslint/no-loop-func
-    const f = (...args) => {
-      var _asyncHooks$get;
-
-      const hooks = currentHooks === defaultHooks ? (_asyncHooks$get = asyncHooks === null || asyncHooks === void 0 ? void 0 : asyncHooks.get()) !== null && _asyncHooks$get !== void 0 ? _asyncHooks$get : defaultHooks : currentHooks;
-      let handler = hooks[key];
-
-      if (typeof handler !== 'function') {
-        handler = defaultHooks[key];
-      }
-
-      return handler(...args);
-    };
-
-    hooks[key] = f;
-  }
-
-  const run = (f, implementations) => {
-    try {
-      currentHooks = implementations || defaultHooks;
-      asyncHooks === null || asyncHooks === void 0 ? void 0 : asyncHooks.set(currentHooks);
-      return f();
-    } finally {
-      currentHooks = defaultHooks;
-    }
-  };
-
-  return {
-    run,
-    hooks
-  };
-};

package/dist/js/node/farrow-pipeline/asyncHooks.node.js

@@ -1,100 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.enable = exports.disable = void 0;
-
-var _async_hooks = _interopRequireDefault(require("async_hooks"));
-
-var asyncHooksInterface = _interopRequireWildcard(require("./asyncHooksInterface"));
-
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * modified from https://github.com/farrow-js/farrow/tree/master/packages/farrow-pipeline
- * license at https://github.com/farrow-js/farrow/blob/master/LICENSE
- */
-const createAsyncHooks = () => {
-  const store = new Map(); // eslint-disable-next-line node/no-unsupported-features/node-builtins
-
-  const hooks = _async_hooks.default.createHook({
-    init: (asyncId, _, triggerAsyncId) => {
-      if (store.has(triggerAsyncId)) {
-        const value = store.get(triggerAsyncId);
-
-        if (value) {
-          store.set(asyncId, value);
-        }
-      }
-    },
-    destroy: asyncId => {
-      if (store.has(asyncId)) {
-        store.delete(asyncId);
-      }
-    }
-  });
-
-  const set = value => {
-    store.set(_async_hooks.default.executionAsyncId(), value);
-  };
-
-  const get = () => {
-    return store.get(_async_hooks.default.executionAsyncId());
-  };
-
-  const clear = () => {
-    store.clear();
-  };
-
-  const enable = () => {
-    hooks.enable();
-  };
-
-  const disable = () => {
-    hooks.disable();
-    store.clear();
-  };
-
-  const entries = () => {
-    return store.entries();
-  };
-
-  return {
-    enable,
-    disable,
-    set,
-    get,
-    clear,
-    entries
-  };
-};
-
-let enabled = false;
-
-const enable = () => {
-  if (enabled) {
-    return;
-  }
-
-  enabled = true;
-  const hooks = createAsyncHooks();
-  asyncHooksInterface.impl(hooks);
-  hooks.enable();
-};
-
-exports.enable = enable;
-
-const disable = () => {
-  var _asyncHooksInterface$;
-
-  enabled = false;
-  (_asyncHooksInterface$ = asyncHooksInterface.asyncHooks) === null || _asyncHooksInterface$ === void 0 ? void 0 : _asyncHooksInterface$.disable();
-  asyncHooksInterface.reset();
-};
-
-exports.disable = disable;