@modern-js/plugin-v2 2.65.1 → 2.65.2-alpha.1

package/dist/cjs/cli/api.js

@@ -64,7 +64,7 @@ function initPluginAPI({ context, pluginManager }) {
     });
   }
   function updateAppContext(updateContext) {
-    context = (0, import_lodash.merge)(context, updateContext);
+    context = (0, import_lodash.assign)(context, updateContext);
   }
   const pluginAPI = {
     isPluginExists: pluginManager.isPluginExists,

package/dist/cjs/hooks.js

@@ -20,6 +20,7 @@ var hooks_exports = {};
 __export(hooks_exports, {
   createAsyncHook: () => createAsyncHook,
   createAsyncInterruptHook: () => createAsyncInterruptHook,
+  createAsyncPipelineHook: () => createAsyncPipelineHook,
   createCollectAsyncHook: () => createCollectAsyncHook,
   createCollectSyncHook: () => createCollectSyncHook,
   createSyncHook: () => createSyncHook
@@ -130,10 +131,38 @@ function createCollectSyncHook() {
     call
   };
 }
+function createAsyncPipelineHook() {
+  const callbacks = [];
+  const tap = (cb) => {
+    callbacks.push(cb);
+  };
+  const call = async (...params) => {
+    for (const callback of callbacks) {
+      let runNext = false;
+      const next = (info) => {
+        runNext = true;
+        if (info) {
+          params[0] = info;
+        }
+      };
+      const result = await callback(...params, next);
+      if (!runNext) {
+        params[0] = result;
+        break;
+      }
+    }
+    return params[0] || [];
+  };
+  return {
+    tap,
+    call
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   createAsyncHook,
   createAsyncInterruptHook,
+  createAsyncPipelineHook,
   createCollectAsyncHook,
   createCollectSyncHook,
   createSyncHook

package/dist/cjs/index.js

@@ -20,6 +20,7 @@ var src_exports = {};
 __export(src_exports, {
   createAsyncHook: () => import_hooks.createAsyncHook,
   createAsyncInterruptHook: () => import_hooks.createAsyncInterruptHook,
+  createAsyncPipelineHook: () => import_hooks.createAsyncPipelineHook,
   createCollectAsyncHook: () => import_hooks.createCollectAsyncHook,
   createCollectSyncHook: () => import_hooks.createCollectSyncHook,
   createPluginManager: () => import_manager.createPluginManager,
@@ -32,6 +33,7 @@ var import_hooks = require("./hooks");
 0 && (module.exports = {
   createAsyncHook,
   createAsyncInterruptHook,
+  createAsyncPipelineHook,
   createCollectAsyncHook,
   createCollectSyncHook,
   createPluginManager,

package/dist/cjs/server/api.js

@@ -0,0 +1,94 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var api_exports = {};
+__export(api_exports, {
+  debug: () => debug,
+  initPluginAPI: () => initPluginAPI
+});
+module.exports = __toCommonJS(api_exports);
+var import_utils = require("@modern-js/utils");
+var import_lodash = require("@modern-js/utils/lodash");
+const debug = (0, import_utils.createDebugger)("plugin-server-v2");
+function initPluginAPI({ context, pluginManager }) {
+  const { hooks, extendsHooks, plugins } = context;
+  function getServerContext() {
+    if (context) {
+      const { hooks: hooks2, extendsHooks: extendsHooks2, config, pluginAPI: pluginAPI2, ...serverContext } = context;
+      serverContext._internalContext = context;
+      return serverContext;
+    }
+    throw new Error("Cannot access context");
+  }
+  function getConfig() {
+    if (context.config) {
+      return context.config;
+    }
+    throw new Error("Cannot access config");
+  }
+  function getHooks() {
+    return context.hooks;
+  }
+  const extendsPluginApi = {};
+  plugins.forEach((plugin) => {
+    const { _registryApi } = plugin;
+    if (_registryApi) {
+      const apis = _registryApi(getServerContext, updateServerContext);
+      Object.keys(apis).forEach((apiName) => {
+        extendsPluginApi[apiName] = apis[apiName];
+      });
+    }
+  });
+  if (extendsHooks) {
+    Object.keys(extendsHooks).forEach((hookName) => {
+      extendsPluginApi[hookName] = extendsHooks[hookName].tap;
+    });
+  }
+  function updateServerContext(updateContext) {
+    context = (0, import_lodash.assign)(context, updateContext);
+  }
+  const pluginAPI = {
+    isPluginExists: pluginManager.isPluginExists,
+    getServerContext,
+    getConfig,
+    getHooks,
+    updateServerContext,
+    modifyConfig: hooks.modifyConfig.tap,
+    onPrepare: hooks.onPrepare.tap,
+    onReset: hooks.onReset.tap,
+    ...extendsPluginApi
+  };
+  return new Proxy(pluginAPI, {
+    get(target, prop) {
+      if (prop === "then") {
+        return void 0;
+      }
+      if (prop in target) {
+        return target[prop];
+      }
+      return () => {
+        debug(`api.${prop.toString()} not exist`);
+      };
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  debug,
+  initPluginAPI
+});

package/dist/cjs/server/context.js

@@ -0,0 +1,64 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var context_exports = {};
+__export(context_exports, {
+  createServerContext: () => createServerContext,
+  initServerContext: () => initServerContext
+});
+module.exports = __toCommonJS(context_exports);
+var import_hooks = require("./hooks");
+function initServerContext(params) {
+  const { options, plugins } = params;
+  return {
+    routes: options.routes || [],
+    appDirectory: options.appContext.appDirectory || "",
+    apiDirectory: options.appContext.apiDirectory,
+    lambdaDirectory: options.appContext.lambdaDirectory,
+    internalDirectory: options.appContext.internalDirectory || "",
+    sharedDirectory: options.appContext.sharedDirectory || "",
+    distDirectory: options.pwd,
+    metaName: options.metaName || "modern-js",
+    plugins,
+    middlewares: []
+  };
+}
+function createServerContext({ serverContext, config }) {
+  const { plugins } = serverContext;
+  const extendsHooks = {};
+  plugins.forEach((plugin) => {
+    const { registryHooks = {} } = plugin;
+    Object.keys(registryHooks).forEach((hookName) => {
+      extendsHooks[hookName] = registryHooks[hookName];
+    });
+  });
+  return {
+    ...serverContext,
+    hooks: {
+      ...(0, import_hooks.initHooks)(),
+      ...extendsHooks
+    },
+    extendsHooks,
+    config
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createServerContext,
+  initServerContext
+});

package/dist/cjs/server/hooks.js

@@ -0,0 +1,35 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var hooks_exports = {};
+__export(hooks_exports, {
+  initHooks: () => initHooks
+});
+module.exports = __toCommonJS(hooks_exports);
+var import_hooks = require("../hooks");
+function initHooks() {
+  return {
+    modifyConfig: (0, import_hooks.createAsyncHook)(),
+    onPrepare: (0, import_hooks.createAsyncHook)(),
+    onReset: (0, import_hooks.createAsyncHook)()
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  initHooks
+});

package/dist/cjs/server/index.js

@@ -0,0 +1,41 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var server_exports = {};
+__export(server_exports, {
+  createServer: () => import_run.createServer,
+  createServerContext: () => import_context.createServerContext,
+  initHooks: () => import_hooks.initHooks,
+  initPluginAPI: () => import_api.initPluginAPI,
+  initServerContext: () => import_context.initServerContext,
+  server: () => import_run.server
+});
+module.exports = __toCommonJS(server_exports);
+var import_api = require("./api");
+var import_context = require("./context");
+var import_hooks = require("./hooks");
+var import_run = require("./run");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createServer,
+  createServerContext,
+  initHooks,
+  initPluginAPI,
+  initServerContext,
+  server
+});

package/dist/cjs/server/run/create.js

@@ -0,0 +1,75 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var create_exports = {};
+__export(create_exports, {
+  createServer: () => createServer
+});
+module.exports = __toCommonJS(create_exports);
+var import_manager = require("../../manager");
+var import_api = require("../../server/api");
+var import_context = require("../../server/context");
+const createServer = () => {
+  let initOptions;
+  const pluginManager = (0, import_manager.createPluginManager)();
+  function init(options) {
+    pluginManager.clear();
+    initOptions = options;
+    const { plugins: allPlugins, options: runOptions, handleSetupResult } = initOptions;
+    pluginManager.addPlugins(allPlugins);
+    const plugins = pluginManager.getPlugins();
+    const context = (0, import_context.createServerContext)({
+      serverContext: (0, import_context.initServerContext)({
+        plugins,
+        options: runOptions
+      }),
+      config: initOptions.config
+    });
+    const pluginAPI = (0, import_api.initPluginAPI)({
+      context,
+      pluginManager
+    });
+    context.pluginAPI = pluginAPI;
+    for (const plugin of plugins) {
+      var _plugin_setup;
+      const setupResult = (_plugin_setup = plugin.setup) === null || _plugin_setup === void 0 ? void 0 : _plugin_setup.call(plugin, pluginAPI);
+      if (handleSetupResult) {
+        handleSetupResult(setupResult, pluginAPI);
+      }
+    }
+    return {
+      serverContext: context
+    };
+  }
+  async function run(options) {
+    const { serverContext } = init(options);
+    const config = await serverContext.hooks.modifyConfig.call(serverContext.config);
+    serverContext.config = config;
+    await serverContext.hooks.onPrepare.call();
+    return {
+      serverContext
+    };
+  }
+  return {
+    run
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createServer
+});

package/dist/cjs/server/run/index.js

@@ -0,0 +1,31 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var run_exports = {};
+__export(run_exports, {
+  createServer: () => import_create.createServer,
+  server: () => server
+});
+module.exports = __toCommonJS(run_exports);
+var import_create = require("./create");
+const server = (0, import_create.createServer)();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createServer,
+  server
+});

package/dist/cjs/server/run/types.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/cjs/types/server/api.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var api_exports = {};
+module.exports = __toCommonJS(api_exports);

package/dist/cjs/types/server/context.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var context_exports = {};
+module.exports = __toCommonJS(context_exports);

package/dist/cjs/types/server/hooks.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var hooks_exports = {};
+module.exports = __toCommonJS(hooks_exports);

package/dist/cjs/types/server/index.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var server_exports = {};
+module.exports = __toCommonJS(server_exports);

package/dist/cjs/types/server/plugin.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var plugin_exports = {};
+module.exports = __toCommonJS(plugin_exports);

package/dist/esm/cli/api.js

@@ -1,6 +1,6 @@
 import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
 import { _ as _object_without_properties } from "@swc/helpers/_/_object_without_properties";
-import { merge } from "@modern-js/utils/lodash";
+import { assign } from "@modern-js/utils/lodash";
 import { debug } from "./run/utils/debug";
 function initPluginAPI(param) {
   var context = param.context, pluginManager = param.pluginManager;
@@ -50,7 +50,7 @@ function initPluginAPI(param) {
     });
   }
   function updateAppContext(updateContext) {
-    context = merge(context, updateContext);
+    context = assign(context, updateContext);
   }
   var pluginAPI = _object_spread({
     isPluginExists: pluginManager.isPluginExists,

package/dist/esm/hooks.js

@@ -1,6 +1,7 @@
 import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
 import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
 import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { _ as _ts_values } from "@swc/helpers/_/_ts_values";
 function createAsyncInterruptHook() {
   var callbacks = [];
   var tap = function(cb) {
@@ -369,9 +370,137 @@ function createCollectSyncHook() {
     call
   };
 }
+function createAsyncPipelineHook() {
+  var callbacks = [];
+  var tap = function(cb) {
+    callbacks.push(cb);
+  };
+  var call = function() {
+    var _ref = _async_to_generator(function() {
+      var _len, params, _key, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _loop, _iterator, _step, _ret, err;
+      var _arguments = arguments;
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            for (_len = _arguments.length, params = new Array(_len), _key = 0; _key < _len; _key++) {
+              params[_key] = _arguments[_key];
+            }
+            _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+            _state.label = 1;
+          case 1:
+            _state.trys.push([
+              1,
+              6,
+              7,
+              8
+            ]);
+            _loop = function() {
+              var callback, runNext, next, result;
+              return _ts_generator(this, function(_state2) {
+                switch (_state2.label) {
+                  case 0:
+                    callback = _step.value;
+                    runNext = false;
+                    next = function(info) {
+                      runNext = true;
+                      if (info) {
+                        params[0] = info;
+                      }
+                    };
+                    return [
+                      4,
+                      callback.apply(void 0, _to_consumable_array(params).concat([
+                        next
+                      ]))
+                    ];
+                  case 1:
+                    result = _state2.sent();
+                    if (!runNext) {
+                      params[0] = result;
+                      return [
+                        2,
+                        "break"
+                      ];
+                    }
+                    return [
+                      2
+                    ];
+                }
+              });
+            };
+            _iterator = callbacks[Symbol.iterator]();
+            _state.label = 2;
+          case 2:
+            if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done))
+              return [
+                3,
+                5
+              ];
+            return [
+              5,
+              _ts_values(_loop())
+            ];
+          case 3:
+            _ret = _state.sent();
+            if (_ret === "break")
+              return [
+                3,
+                5
+              ];
+            _state.label = 4;
+          case 4:
+            _iteratorNormalCompletion = true;
+            return [
+              3,
+              2
+            ];
+          case 5:
+            return [
+              3,
+              8
+            ];
+          case 6:
+            err = _state.sent();
+            _didIteratorError = true;
+            _iteratorError = err;
+            return [
+              3,
+              8
+            ];
+          case 7:
+            try {
+              if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+              }
+            } finally {
+              if (_didIteratorError) {
+                throw _iteratorError;
+              }
+            }
+            return [
+              7
+            ];
+          case 8:
+            return [
+              2,
+              params[0] || []
+            ];
+        }
+      });
+    });
+    return function call2() {
+      return _ref.apply(this, arguments);
+    };
+  }();
+  return {
+    tap,
+    call
+  };
+}
 export {
   createAsyncHook,
   createAsyncInterruptHook,
+  createAsyncPipelineHook,
   createCollectAsyncHook,
   createCollectSyncHook,
   createSyncHook