@modern-js/plugin 1.3.2 → 1.3.5

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # @modern-js/plugin
 
+## 1.3.5
+
+### Patch Changes
+
+- 54fa1dbd6: fix(plugin): allow multiple versions to be installed
+
+## 1.3.4
+
+### Patch Changes
+
+- d5913bd96: feat: fork farrow-pipeline to remove tslib and reduce bundle size
+- d32f35134: chore: add modern/jest/eslint/ts config files to .npmignore
+
+## 1.3.3
+
+### Patch Changes
+
+- 6cffe99d: chore:
+  remove react eslint rules for `modern-js` rule set.
+  add .eslintrc for each package to speed up linting
+- 60f7d8bf: feat: add tests dir to npmignore
+
 ## 1.3.2
 
 ### Patch Changes

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

@@ -0,0 +1,74 @@
+/**
+ * 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
+  };
+};
+
+export const enable = () => {
+  const hooks = createAsyncHooks();
+  disable();
+  asyncHooksInterface.impl(hooks);
+  hooks.enable();
+};
+export const disable = () => {
+  var _asyncHooksInterface$;
+
+  (_asyncHooksInterface$ = asyncHooksInterface.asyncHooks) === null || _asyncHooksInterface$ === void 0 ? void 0 : _asyncHooksInterface$.disable();
+  asyncHooksInterface.reset();
+};

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

@@ -0,0 +1,12 @@
+/**
+ * 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/context.js

@@ -0,0 +1,99 @@
+/**
+ * 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 { createHooks } from "./hook";
+const ContextSymbol = Symbol.for('MODERN_CONTEXT');
+export const createContext = value => {
+  const id = Symbol('MODERN_CONTEXT_ID');
+
+  const create = value => {
+    const use = () => {
+      const container = useContainer();
+      return Object.seal({
+        get value() {
+          return container.read(Context);
+        },
+
+        set value(v) {
+          container.write(Context, v);
+        }
+
+      });
+    };
+
+    const get = () => {
+      const container = useContainer();
+      return container.read(Context);
+    };
+
+    const set = v => {
+      const container = useContainer();
+      container.write(Context, v);
+    };
+
+    const Context = {
+      id,
+      [ContextSymbol]: value,
+      create,
+      use,
+      get,
+      set
+    };
+    return Context;
+  };
+
+  return create(value);
+};
+
+const createContextMap = storage => {
+  const contextMap = new Map();
+  const contexts = Object.values(storage); // eslint-disable-next-line @typescript-eslint/prefer-for-of
+
+  for (let i = 0; i < contexts.length; i++) {
+    contextMap.set(contexts[i].id, contexts[i]);
+  }
+
+  return contextMap;
+};
+
+export const createContainer = (ContextStorage = {}) => {
+  const contextMap = createContextMap(ContextStorage);
+
+  const read = context => {
+    const target = contextMap.get(context.id);
+
+    if (target) {
+      return target[ContextSymbol];
+    }
+
+    return context[ContextSymbol];
+  };
+
+  const write = (context, value) => {
+    contextMap.set(context.id, context.create(value));
+  };
+
+  return Object.freeze({
+    read,
+    write
+  });
+};
+const {
+  run,
+  hooks
+} = createHooks({
+  useContainer: () => {
+    throw new Error(`Can't call useContainer out of scope, it should be placed on top of the function`);
+  }
+});
+export const runHooks = run;
+export const {
+  useContainer
+} = hooks;
+export const fromContainer = container => ({
+  useContainer: () => {
+    return container;
+  }
+});
+export const runWithContainer = (f, container) => runHooks(f, fromContainer(container));

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

@@ -0,0 +1,18 @@
+/**
+ * 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 const createCounter = callback => {
+  const dispatch = (index, input) => {
+    const next = (nextInput = input) => dispatch(index + 1, nextInput);
+
+    return callback(index, input, next);
+  };
+
+  const start = input => dispatch(0, input);
+
+  return {
+    start,
+    dispatch
+  };
+};

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

@@ -0,0 +1,42 @@
+/**
+ * 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/modern/farrow-pipeline/index.js

@@ -0,0 +1,19 @@
+/**
+ * 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/js/modern/farrow-pipeline/pipeline.js

@@ -0,0 +1,93 @@
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return 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
+ */
+import { createContext, createContainer, fromContainer, runHooks, useContainer, runWithContainer } from "./context";
+import { createCounter } from "./counter";
+export { createContext, createContainer, useContainer, runWithContainer };
+export const isPipeline = input => Boolean(input === null || input === void 0 ? void 0 : input[PipelineSymbol]);
+const PipelineSymbol = Symbol.for('MODERN_PIPELINE');
+
+const getMiddleware = input => {
+  if (typeof input === 'function') {
+    return input;
+  } else if (input && typeof input.middleware === 'function') {
+    return input.middleware;
+  }
+
+  throw new Error(`${input} is not a Middleware`);
+};
+
+export const createPipeline = options => {
+  const config = _objectSpread({}, options);
+
+  const middlewares = [];
+
+  const use = (...inputs) => {
+    middlewares.push(...inputs.map(getMiddleware));
+    return pipeline;
+  };
+
+  const createCurrentCounter = (hooks, onLast, onLastWithContext) => {
+    return createCounter((index, input, next) => {
+      if (index >= middlewares.length) {
+        if (onLast) {
+          if (onLastWithContext) {
+            return runHooks(() => onLast(input), hooks);
+          }
+
+          return onLast(input);
+        }
+
+        throw new Error(`Expect returning a value, but all middlewares just calling next()`);
+      }
+
+      return runHooks(() => middlewares[index](input, next), hooks);
+    });
+  };
+
+  const currentContainer = createContainer(config.contexts);
+  const currentHooks = fromContainer(currentContainer);
+  const currentCounter = createCurrentCounter(currentHooks);
+
+  const getCounter = options => {
+    if (!options) {
+      return currentCounter;
+    }
+
+    if (options !== null && options !== void 0 && options.container) {
+      const hooks = fromContainer(options === null || options === void 0 ? void 0 : options.container);
+      return options !== null && options !== void 0 && options.onLast ? createCurrentCounter(hooks, options.onLast, typeof options.onLastWithContext === 'boolean' ? options.onLastWithContext : true) : createCurrentCounter(hooks);
+    }
+
+    return options !== null && options !== void 0 && options.onLast ? createCurrentCounter(currentHooks, options.onLast, typeof options.onLastWithContext === 'boolean' ? options.onLastWithContext : true) : createCurrentCounter(currentHooks);
+  };
+
+  const run = (input, options) => getCounter(options).start(input);
+
+  const middleware = (input, next) => {
+    const container = useContainer();
+    return run(input, {
+      container,
+      onLast: next
+    });
+  };
+
+  const pipeline = {
+    [PipelineSymbol]: true,
+    use,
+    run,
+    middleware
+  };
+  return pipeline;
+};
+export const createAsyncPipeline = options => {
+  const pipeline = createPipeline(options);
+  return _objectSpread({}, pipeline);
+};

package/dist/js/modern/index.js

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

package/dist/js/modern/manager/async.js

@@ -4,7 +4,7 @@ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { va
 
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 
-import { runWithContainer, createContainer } from 'farrow-pipeline';
+import { runWithContainer, createContainer } from "../farrow-pipeline";
 import { isObject, generateRunner, hasOwnProperty, DEFAULT_OPTIONS } from "./sync";
 import { useRunner } from "./runner";
 const ASYNC_PLUGIN_SYMBOL = 'ASYNC_PLUGIN_SYMBOL';

package/dist/js/modern/manager/runner.js

@@ -1,4 +1,4 @@
-import { createContext } from 'farrow-pipeline';
+import { createContext } from "../farrow-pipeline";
 export const RunnerContext = createContext(null);
 export const useRunner = () => {
   const runner = RunnerContext.use().value;

package/dist/js/modern/manager/sync.js

@@ -4,7 +4,7 @@ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { va
 
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 
-import { isPipeline, createPipeline, runWithContainer, createContainer } from 'farrow-pipeline';
+import { isPipeline, createPipeline, runWithContainer, createContainer } from "../farrow-pipeline";
 import { isWaterfall, createWaterfall, isAsyncWaterfall, createAsyncWaterfall } from "../waterfall";
 import { isWorkflow, createWorkflow, isAsyncWorkflow, createAsyncWorkflow, isParallelWorkflow, createParallelWorkflow } from "../workflow";
 import { RunnerContext, useRunner } from "./runner";
@@ -173,8 +173,7 @@ export const cloneHook = hook => {
 
   if (isPipeline(hook)) {
     return createPipeline();
-  } // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-
+  }
 
   throw new Error(`Unknown hook: ${hook}`);
 };

package/dist/js/modern/waterfall/async.js

@@ -4,15 +4,14 @@ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { va
 
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 
-import { createAsyncPipeline, useContainer } from 'farrow-pipeline';
-const ASYNC_WATERFALL_SYMBOL = Symbol('ASYNC_WATERFALL_SYMBOL');
+import { createAsyncPipeline, useContainer } from "../farrow-pipeline";
+const ASYNC_WATERFALL_SYMBOL = Symbol.for('MODERN_ASYNC_WATERFALL');
 export const getAsyncBrook = input => {
   if (typeof input === 'function') {
     return input;
   } else if (input && typeof input.middleware === 'function') {
     return input.middleware;
-  } // eslint-disable-next-line @typescript-eslint/no-base-to-string,@typescript-eslint/restrict-template-expressions
-
+  }
 
   throw new Error(`${input} is not a AsyncBrook or { brook: AsyncBrook }`);
 };
@@ -24,15 +23,12 @@ export const createAsyncWaterfall = () => {
     return waterfall;
   };
 
-  const run = (input, options) => // eslint-disable-next-line @typescript-eslint/no-shadow
-  pipeline.run(input, _objectSpread(_objectSpread({}, options), {}, {
+  const run = (input, options) => pipeline.run(input, _objectSpread(_objectSpread({}, options), {}, {
     onLast: input => input
   }));
 
   const middleware = input => {
-    // eslint-disable-next-line react-hooks/rules-of-hooks
-    const container = useContainer(); // eslint-disable-next-line @typescript-eslint/no-shadow
-
+    const container = useContainer();
     return pipeline.run(input, {
       container,
       onLast: input => input

package/dist/js/modern/waterfall/sync.js

@@ -4,15 +4,14 @@ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { va
 
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 
-import { useContainer, createPipeline } from 'farrow-pipeline';
-const WATERFALL_SYMBOL = Symbol('WATERFALL_SYMBOL');
+import { useContainer, createPipeline } from "../farrow-pipeline";
+const WATERFALL_SYMBOL = Symbol.for('MODERN_WATERFALL');
 export const getBrook = input => {
   if (typeof input === 'function') {
     return input;
   } else if (input && typeof input.middleware === 'function') {
     return input.middleware;
-  } // eslint-disable-next-line @typescript-eslint/no-base-to-string,@typescript-eslint/restrict-template-expressions
-
+  }
 
   throw new Error(`${input} is not a Brook or { brook: Brook }`);
 };
@@ -24,15 +23,12 @@ export const createWaterfall = () => {
     return waterfall;
   };
 
-  const run = (input, options) => // eslint-disable-next-line @typescript-eslint/no-shadow
-  pipeline.run(input, _objectSpread(_objectSpread({}, options), {}, {
+  const run = (input, options) => pipeline.run(input, _objectSpread(_objectSpread({}, options), {}, {
     onLast: input => input
   }));
 
   const middleware = input => {
-    // eslint-disable-next-line react-hooks/rules-of-hooks
-    const container = useContainer(); // eslint-disable-next-line @typescript-eslint/no-shadow
-
+    const container = useContainer();
     return pipeline.run(input, {
       container,
       onLast: input => input

package/dist/js/modern/workflow/async.js

@@ -4,8 +4,8 @@ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { va
 
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 
-import { createAsyncPipeline } from 'farrow-pipeline';
-const ASYNC_WORKFLOW_SYMBOL = Symbol('ASYNC_WORKFLOW_SYMBOL');
+import { createAsyncPipeline } from "../farrow-pipeline";
+const ASYNC_WORKFLOW_SYMBOL = Symbol.for('MODERN_ASYNC_WORKFLOW');
 export const isAsyncWorkflow = input => Boolean(input === null || input === void 0 ? void 0 : input[ASYNC_WORKFLOW_SYMBOL]);
 export const createAsyncWorkflow = () => {
   const pipeline = createAsyncPipeline();
@@ -21,7 +21,6 @@ export const createAsyncWorkflow = () => {
     }));
 
     if (isPromise(result)) {
-      // eslint-disable-next-line @typescript-eslint/no-shadow,promise/prefer-await-to-then
       return result.then(result => result.filter(Boolean));
     } else {
       return result.filter(Boolean);
@@ -40,7 +39,5 @@ export const createAsyncWorkflow = () => {
 const mapAsyncWorkerToAsyncMiddleware = worker => async (input, next) => [await worker(input), ...(await next(input))];
 
 function isPromise(obj) {
-  /* eslint-disable promise/prefer-await-to-then */
   return Boolean(obj) && (typeof obj === 'object' || typeof obj === 'function') && typeof obj.then === 'function';
-  /* eslint-enable promise/prefer-await-to-then */
 }

package/dist/js/modern/workflow/parallel.js

@@ -4,8 +4,8 @@ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { va
 
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 
-import { createPipeline } from 'farrow-pipeline';
-const PARALLEL_WORKFLOW_SYMBOL = Symbol('PARALLEL_WORKFLOW_SYMBOL');
+import { createPipeline } from "../farrow-pipeline";
+const PARALLEL_WORKFLOW_SYMBOL = Symbol.for('MODERN_PARALLEL_WORKFLOW');
 export const isParallelWorkflow = input => Boolean(input === null || input === void 0 ? void 0 : input[PARALLEL_WORKFLOW_SYMBOL]);
 export const createParallelWorkflow = () => {
   const pipeline = createPipeline();
@@ -15,8 +15,7 @@ export const createParallelWorkflow = () => {
     return workflow;
   };
 
-  const run = async (input, options) => // eslint-disable-next-line promise/prefer-await-to-then
-  Promise.all(pipeline.run(input, _objectSpread(_objectSpread({}, options), {}, {
+  const run = async (input, options) => Promise.all(pipeline.run(input, _objectSpread(_objectSpread({}, options), {}, {
     onLast: () => []
   }))).then(result => result.filter(Boolean));
 

package/dist/js/modern/workflow/sync.js

@@ -4,8 +4,8 @@ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { va
 
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 
-import { createPipeline } from 'farrow-pipeline';
-const WORKFLOW_SYMBOL = Symbol('WORKFLOW_SYMBOL');
+import { createPipeline } from "../farrow-pipeline";
+const WORKFLOW_SYMBOL = Symbol.for('MODERN_WORKFLOW');
 export const createWorkflow = () => {
   const pipeline = createPipeline();
 

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

@@ -0,0 +1,93 @@
+"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
+  };
+};
+
+const enable = () => {
+  const hooks = createAsyncHooks();
+  disable();
+  asyncHooksInterface.impl(hooks);
+  hooks.enable();
+};
+
+exports.enable = enable;
+
+const disable = () => {
+  var _asyncHooksInterface$;
+
+  (_asyncHooksInterface$ = asyncHooksInterface.asyncHooks) === null || _asyncHooksInterface$ === void 0 ? void 0 : _asyncHooksInterface$.disable();
+  asyncHooksInterface.reset();
+};
+
+exports.disable = disable;