@modern-js/plugin 2.56.2 → 2.57.1

package/dist/cjs/manager/sync.js

@@ -163,6 +163,12 @@ const cloneHook = (hook) => {
   if ((0, import_workflow.isParallelWorkflow)(hook)) {
     return (0, import_workflow.createParallelWorkflow)();
   }
+  if ((0, import_workflow.isAsyncInterruptWorkflow)(hook)) {
+    return (0, import_workflow.createAsyncInterruptWorkflow)();
+  }
+  if ((0, import_workflow.isSyncParallelWorkflow)(hook)) {
+    return (0, import_workflow.createSyncParallelWorkflow)();
+  }
   if ((0, import_farrow_pipeline.isPipeline)(hook)) {
     return (0, import_farrow_pipeline.createPipeline)();
   }

package/dist/cjs/workflow/index.js

@@ -16,11 +16,15 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var workflow_exports = {};
 module.exports = __toCommonJS(workflow_exports);
 __reExport(workflow_exports, require("./sync"), module.exports);
+__reExport(workflow_exports, require("./syncParallel"), module.exports);
 __reExport(workflow_exports, require("./parallel"), module.exports);
 __reExport(workflow_exports, require("./async"), module.exports);
+__reExport(workflow_exports, require("./interrupt"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ...require("./sync"),
+  ...require("./syncParallel"),
   ...require("./parallel"),
-  ...require("./async")
+  ...require("./async"),
+  ...require("./interrupt")
 });

package/dist/cjs/workflow/interrupt.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 interrupt_exports = {};
+__export(interrupt_exports, {
+  createAsyncInterruptWorkflow: () => createAsyncInterruptWorkflow,
+  isAsyncInterruptWorkflow: () => isAsyncInterruptWorkflow
+});
+module.exports = __toCommonJS(interrupt_exports);
+var import_farrow_pipeline = require("../farrow-pipeline");
+const ASYNC_INTERRUPT_WORKFLOW_SYMBOL = Symbol.for("ASYNC_INTERRUPT_WORKFLOW_SYMBOL");
+const isAsyncInterruptWorkflow = (input) => Boolean(input === null || input === void 0 ? void 0 : input[ASYNC_INTERRUPT_WORKFLOW_SYMBOL]);
+const createAsyncInterruptWorkflow = () => {
+  const pipeline = (0, import_farrow_pipeline.createAsyncPipeline)();
+  const use = (...input) => {
+    pipeline.use(...input.map(mapAsyncWorkerToInterruptMiddleware));
+    return workflow;
+  };
+  const run = async (input) => {
+    const result = await pipeline.run(input, {
+      onLast: () => []
+    });
+    return result;
+  };
+  const workflow = {
+    ...pipeline,
+    use,
+    run,
+    [ASYNC_INTERRUPT_WORKFLOW_SYMBOL]: true
+  };
+  return workflow;
+};
+const mapAsyncWorkerToInterruptMiddleware = (worker) => async (input, next) => {
+  let isInterrupted = false;
+  const interrupt = (value) => {
+    isInterrupted = true;
+    return value;
+  };
+  const result = await Promise.resolve(worker(input, interrupt));
+  if (isInterrupted) {
+    return result;
+  }
+  return Promise.resolve(next(input));
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createAsyncInterruptWorkflow,
+  isAsyncInterruptWorkflow
+});

package/dist/cjs/workflow/syncParallel.js

@@ -0,0 +1,55 @@
+"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 syncParallel_exports = {};
+__export(syncParallel_exports, {
+  createSyncParallelWorkflow: () => createSyncParallelWorkflow,
+  isSyncParallelWorkflow: () => isSyncParallelWorkflow
+});
+module.exports = __toCommonJS(syncParallel_exports);
+var import_farrow_pipeline = require("../farrow-pipeline");
+const SYNC_PARALLEL_WORKFLOW_SYMBOL = Symbol.for("SYNC_MODERN_PARALLEL_WORKFLOW");
+const isSyncParallelWorkflow = (input) => Boolean(input === null || input === void 0 ? void 0 : input[SYNC_PARALLEL_WORKFLOW_SYMBOL]);
+const createSyncParallelWorkflow = () => {
+  const pipeline = (0, import_farrow_pipeline.createPipeline)();
+  const use = (...input) => {
+    pipeline.use(...input.map(mapSyncParallelWorkerToMiddleware));
+    return workflow;
+  };
+  const run = (input) => {
+    return pipeline.run(input, {
+      onLast: () => []
+    }).filter((result) => Boolean(result));
+  };
+  const workflow = {
+    ...pipeline,
+    run,
+    use,
+    [SYNC_PARALLEL_WORKFLOW_SYMBOL]: true
+  };
+  return workflow;
+};
+const mapSyncParallelWorkerToMiddleware = (worker) => (input, next) => [
+  worker(input),
+  ...next(input)
+];
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createSyncParallelWorkflow,
+  isSyncParallelWorkflow
+});

package/dist/esm/index.js

@@ -253,11 +253,53 @@ var mapWorkerToMiddleware = function(worker) {
   };
 };
 
-// src/workflow/parallel.ts
+// src/workflow/syncParallel.ts
 import { _ as _define_property5 } from "@swc/helpers/_/_define_property";
 import { _ as _object_spread5 } from "@swc/helpers/_/_object_spread";
 import { _ as _object_spread_props4 } from "@swc/helpers/_/_object_spread_props";
 import { _ as _to_consumable_array5 } from "@swc/helpers/_/_to_consumable_array";
+var SYNC_PARALLEL_WORKFLOW_SYMBOL = Symbol.for("SYNC_MODERN_PARALLEL_WORKFLOW");
+var isSyncParallelWorkflow = function(input) {
+  return Boolean(input === null || input === void 0 ? void 0 : input[SYNC_PARALLEL_WORKFLOW_SYMBOL]);
+};
+var createSyncParallelWorkflow = function() {
+  var pipeline = createPipeline();
+  var use = function() {
+    for (var _len = arguments.length, input = new Array(_len), _key = 0; _key < _len; _key++) {
+      input[_key] = arguments[_key];
+    }
+    var _pipeline;
+    (_pipeline = pipeline).use.apply(_pipeline, _to_consumable_array5(input.map(mapSyncParallelWorkerToMiddleware)));
+    return workflow;
+  };
+  var run = function(input) {
+    return pipeline.run(input, {
+      onLast: function() {
+        return [];
+      }
+    }).filter(function(result) {
+      return Boolean(result);
+    });
+  };
+  var workflow = _object_spread_props4(_object_spread5({}, pipeline), _define_property5({
+    run,
+    use
+  }, SYNC_PARALLEL_WORKFLOW_SYMBOL, true));
+  return workflow;
+};
+var mapSyncParallelWorkerToMiddleware = function(worker) {
+  return function(input, next) {
+    return [
+      worker(input)
+    ].concat(_to_consumable_array5(next(input)));
+  };
+};
+
+// src/workflow/parallel.ts
+import { _ as _define_property6 } from "@swc/helpers/_/_define_property";
+import { _ as _object_spread6 } from "@swc/helpers/_/_object_spread";
+import { _ as _object_spread_props5 } from "@swc/helpers/_/_object_spread_props";
+import { _ as _to_consumable_array6 } from "@swc/helpers/_/_to_consumable_array";
 var PARALLEL_WORKFLOW_SYMBOL = Symbol.for("MODERN_PARALLEL_WORKFLOW");
 var isParallelWorkflow = function(input) {
   return Boolean(input === null || input === void 0 ? void 0 : input[PARALLEL_WORKFLOW_SYMBOL]);
@@ -269,7 +311,7 @@ var createParallelWorkflow = function() {
       input[_key] = arguments[_key];
     }
     var _pipeline;
-    (_pipeline = pipeline).use.apply(_pipeline, _to_consumable_array5(input.map(mapParallelWorkerToAsyncMiddleware)));
+    (_pipeline = pipeline).use.apply(_pipeline, _to_consumable_array6(input.map(mapParallelWorkerToAsyncMiddleware)));
     return workflow;
   };
   var run = function(input) {
@@ -281,7 +323,7 @@ var createParallelWorkflow = function() {
       return result.filter(Boolean);
     });
   };
-  var workflow = _object_spread_props4(_object_spread5({}, pipeline), _define_property5({
+  var workflow = _object_spread_props5(_object_spread6({}, pipeline), _define_property6({
     run,
     use
   }, PARALLEL_WORKFLOW_SYMBOL, true));
@@ -291,15 +333,15 @@ var mapParallelWorkerToAsyncMiddleware = function(worker) {
   return function(input, next) {
     return [
       worker(input)
-    ].concat(_to_consumable_array5(next(input)));
+    ].concat(_to_consumable_array6(next(input)));
   };
 };
 
 // src/workflow/async.ts
-import { _ as _define_property6 } from "@swc/helpers/_/_define_property";
-import { _ as _object_spread6 } from "@swc/helpers/_/_object_spread";
-import { _ as _object_spread_props5 } from "@swc/helpers/_/_object_spread_props";
-import { _ as _to_consumable_array6 } from "@swc/helpers/_/_to_consumable_array";
+import { _ as _define_property7 } from "@swc/helpers/_/_define_property";
+import { _ as _object_spread7 } from "@swc/helpers/_/_object_spread";
+import { _ as _object_spread_props6 } from "@swc/helpers/_/_object_spread_props";
+import { _ as _to_consumable_array7 } from "@swc/helpers/_/_to_consumable_array";
 var ASYNC_WORKFLOW_SYMBOL = Symbol.for("MODERN_ASYNC_WORKFLOW");
 var isPromise = function(obj) {
   return obj && typeof obj.then === "function";
@@ -314,7 +356,7 @@ var createAsyncWorkflow = function() {
       input[_key] = arguments[_key];
     }
     var _pipeline;
-    (_pipeline = pipeline).use.apply(_pipeline, _to_consumable_array6(input.map(mapAsyncWorkerToAsyncMiddleware)));
+    (_pipeline = pipeline).use.apply(_pipeline, _to_consumable_array7(input.map(mapAsyncWorkerToAsyncMiddleware)));
     return workflow;
   };
   var run = function(input) {
@@ -330,7 +372,7 @@ var createAsyncWorkflow = function() {
     }
     return result.filter(Boolean);
   };
-  var workflow = _object_spread_props5(_object_spread6({}, pipeline), _define_property6({
+  var workflow = _object_spread_props6(_object_spread7({}, pipeline), _define_property7({
     use,
     run
   }, ASYNC_WORKFLOW_SYMBOL, true));
@@ -342,15 +384,106 @@ var mapAsyncWorkerToAsyncMiddleware = function(worker) {
       return Promise.resolve(next(input)).then(function(nextResult) {
         return [
           result
-        ].concat(_to_consumable_array6(nextResult));
+        ].concat(_to_consumable_array7(nextResult));
       });
     });
   };
 };
 
+// src/workflow/interrupt.ts
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _define_property8 } from "@swc/helpers/_/_define_property";
+import { _ as _object_spread8 } from "@swc/helpers/_/_object_spread";
+import { _ as _object_spread_props7 } from "@swc/helpers/_/_object_spread_props";
+import { _ as _to_consumable_array8 } from "@swc/helpers/_/_to_consumable_array";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+var ASYNC_INTERRUPT_WORKFLOW_SYMBOL = Symbol.for("ASYNC_INTERRUPT_WORKFLOW_SYMBOL");
+var isAsyncInterruptWorkflow = function(input) {
+  return Boolean(input === null || input === void 0 ? void 0 : input[ASYNC_INTERRUPT_WORKFLOW_SYMBOL]);
+};
+var createAsyncInterruptWorkflow = function() {
+  var pipeline = createAsyncPipeline();
+  var use = function() {
+    for (var _len = arguments.length, input = new Array(_len), _key = 0; _key < _len; _key++) {
+      input[_key] = arguments[_key];
+    }
+    var _pipeline;
+    (_pipeline = pipeline).use.apply(_pipeline, _to_consumable_array8(input.map(mapAsyncWorkerToInterruptMiddleware)));
+    return workflow;
+  };
+  var run = function() {
+    var _ref = _async_to_generator(function(input) {
+      var result;
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            return [
+              4,
+              pipeline.run(input, {
+                onLast: function() {
+                  return [];
+                }
+              })
+            ];
+          case 1:
+            result = _state.sent();
+            return [
+              2,
+              result
+            ];
+        }
+      });
+    });
+    return function run2(input) {
+      return _ref.apply(this, arguments);
+    };
+  }();
+  var workflow = _object_spread_props7(_object_spread8({}, pipeline), _define_property8({
+    use,
+    run
+  }, ASYNC_INTERRUPT_WORKFLOW_SYMBOL, true));
+  return workflow;
+};
+var mapAsyncWorkerToInterruptMiddleware = function(worker) {
+  return function() {
+    var _ref = _async_to_generator(function(input, next) {
+      var isInterrupted, interrupt, result;
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            isInterrupted = false;
+            interrupt = function(value) {
+              isInterrupted = true;
+              return value;
+            };
+            return [
+              4,
+              Promise.resolve(worker(input, interrupt))
+            ];
+          case 1:
+            result = _state.sent();
+            if (isInterrupted) {
+              return [
+                2,
+                result
+              ];
+            }
+            return [
+              2,
+              Promise.resolve(next(input))
+            ];
+        }
+      });
+    });
+    return function(input, next) {
+      return _ref.apply(this, arguments);
+    };
+  }();
+};
+
 // src/manager/sync.ts
-import { _ as _object_spread7 } from "@swc/helpers/_/_object_spread";
-import { _ as _object_spread_props6 } from "@swc/helpers/_/_object_spread_props";
+import { _ as _object_spread9 } from "@swc/helpers/_/_object_spread";
+import { _ as _object_spread_props8 } from "@swc/helpers/_/_object_spread_props";
 
 // src/manager/shared.ts
 import { pluginDagSort } from "@modern-js/utils/universal/plugin-dag-sort";
@@ -403,24 +536,24 @@ var DEFAULT_OPTIONS = {
 var createManager = function(hooks, api) {
   var index = 0;
   var runners;
-  var currentHooks = _object_spread7({}, hooks);
+  var currentHooks = _object_spread9({}, hooks);
   var useRunner = function() {
     return runners;
   };
   var registerHook = function(extraHooks) {
-    currentHooks = _object_spread7({}, extraHooks, currentHooks);
+    currentHooks = _object_spread9({}, extraHooks, currentHooks);
   };
   var isPlugin = function(input) {
     return isObject(input) && hasOwnProperty(input, SYNC_PLUGIN_SYMBOL) && input[SYNC_PLUGIN_SYMBOL] === SYNC_PLUGIN_SYMBOL;
   };
-  var pluginAPI = _object_spread_props6(_object_spread7({}, api), {
+  var pluginAPI = _object_spread_props8(_object_spread9({}, api), {
     useHookRunners: useRunner
   });
   var clone = function(overrideAPI) {
     var plugins = [];
     var addPlugin = function(plugin) {
       if (!includePlugin(plugins, plugin)) {
-        plugins.push(_object_spread7({}, plugin));
+        plugins.push(_object_spread9({}, plugin));
       }
     };
     var usePlugin = function() {
@@ -453,7 +586,7 @@ var createManager = function(hooks, api) {
       if (options.registerHook) {
         registerHook(options.registerHook);
       }
-      return _object_spread_props6(_object_spread7(_object_spread_props6(_object_spread7({}, DEFAULT_OPTIONS), {
+      return _object_spread_props8(_object_spread9(_object_spread_props8(_object_spread9({}, DEFAULT_OPTIONS), {
         name: "No.".concat(index++, " plugin")
       }), options), {
         SYNC_PLUGIN_SYMBOL,
@@ -465,7 +598,7 @@ var createManager = function(hooks, api) {
     };
     var init = function() {
       var sortedPlugins = sortPlugins(plugins);
-      var mergedPluginAPI = _object_spread7({}, pluginAPI, overrideAPI);
+      var mergedPluginAPI = _object_spread9({}, pluginAPI, overrideAPI);
       checkPlugins(sortedPlugins);
       var hooksList = sortedPlugins.map(function(plugin) {
         return plugin.setup(mergedPluginAPI);
@@ -502,7 +635,7 @@ var generateRunner = function(hooksList, hooksMap) {
         }
       });
       runner[key2] = function(input, options) {
-        return cloneShape[key2].run(input, _object_spread7({}, options));
+        return cloneShape[key2].run(input, _object_spread9({}, options));
       };
     };
     for (var key in cloneShape)
@@ -526,6 +659,12 @@ var cloneHook = function(hook) {
   if (isParallelWorkflow(hook)) {
     return createParallelWorkflow();
   }
+  if (isAsyncInterruptWorkflow(hook)) {
+    return createAsyncInterruptWorkflow();
+  }
+  if (isSyncParallelWorkflow(hook)) {
+    return createSyncParallelWorkflow();
+  }
   if (isPipeline(hook)) {
     return createPipeline();
   }
@@ -543,32 +682,32 @@ var cloneHooksMap = function(record) {
 };
 
 // src/manager/async.ts
-import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
-import { _ as _object_spread8 } from "@swc/helpers/_/_object_spread";
-import { _ as _object_spread_props7 } from "@swc/helpers/_/_object_spread_props";
-import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { _ as _async_to_generator2 } from "@swc/helpers/_/_async_to_generator";
+import { _ as _object_spread10 } from "@swc/helpers/_/_object_spread";
+import { _ as _object_spread_props9 } from "@swc/helpers/_/_object_spread_props";
+import { _ as _ts_generator2 } from "@swc/helpers/_/_ts_generator";
 var ASYNC_PLUGIN_SYMBOL = "ASYNC_PLUGIN_SYMBOL";
 var createAsyncManager = function(hooks, api) {
   var index = 0;
   var runners;
-  var currentHooks = _object_spread8({}, hooks);
+  var currentHooks = _object_spread10({}, hooks);
   var useRunner = function() {
     return runners;
   };
   var registerHook = function(extraHooks) {
-    currentHooks = _object_spread8({}, extraHooks, currentHooks);
+    currentHooks = _object_spread10({}, extraHooks, currentHooks);
   };
   var isPlugin = function(input) {
     return isObject(input) && hasOwnProperty(input, ASYNC_PLUGIN_SYMBOL) && input[ASYNC_PLUGIN_SYMBOL] === ASYNC_PLUGIN_SYMBOL;
   };
-  var pluginAPI = _object_spread_props7(_object_spread8({}, api), {
+  var pluginAPI = _object_spread_props9(_object_spread10({}, api), {
     useHookRunners: useRunner
   });
   var clone = function(overrideAPI) {
     var plugins = [];
     var addPlugin = function(plugin) {
       if (!includePlugin(plugins, plugin)) {
-        plugins.push(_object_spread8({}, plugin));
+        plugins.push(_object_spread10({}, plugin));
       }
     };
     var usePlugin = function() {
@@ -601,7 +740,7 @@ var createAsyncManager = function(hooks, api) {
       if (options.registerHook) {
         registerHook(options.registerHook);
       }
-      return _object_spread_props7(_object_spread8(_object_spread_props7(_object_spread8({}, DEFAULT_OPTIONS), {
+      return _object_spread_props9(_object_spread10(_object_spread_props9(_object_spread10({}, DEFAULT_OPTIONS), {
         name: "No.".concat(index++, " plugin")
       }), options), {
         ASYNC_PLUGIN_SYMBOL,
@@ -612,13 +751,13 @@ var createAsyncManager = function(hooks, api) {
       plugins = [];
     };
     var init = function() {
-      var _ref = _async_to_generator(function() {
+      var _ref = _async_to_generator2(function() {
         var sortedPlugins, mergedPluginAPI, hooksList, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, plugin, _, err;
-        return _ts_generator(this, function(_state) {
+        return _ts_generator2(this, function(_state) {
           switch (_state.label) {
             case 0:
               sortedPlugins = sortPlugins(plugins);
-              mergedPluginAPI = _object_spread8({}, pluginAPI, overrideAPI);
+              mergedPluginAPI = _object_spread10({}, pluginAPI, overrideAPI);
               checkPlugins(sortedPlugins);
               hooksList = [];
               _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
@@ -716,6 +855,7 @@ export {
   DEFAULT_OPTIONS,
   cloneHook,
   cloneHooksMap,
+  createAsyncInterruptWorkflow,
   createAsyncManager,
   createAsyncPipeline,
   createAsyncWaterfall,
@@ -724,15 +864,18 @@ export {
   createManager,
   createParallelWorkflow,
   createPipeline,
+  createSyncParallelWorkflow,
   createWaterfall,
   createWorkflow,
   generateRunner,
   getAsyncBrook,
   getBrook,
+  isAsyncInterruptWorkflow,
   isAsyncWaterfall,
   isAsyncWorkflow,
   isParallelWorkflow,
   isPipeline,
+  isSyncParallelWorkflow,
   isWaterfall,
   isWorkflow
 };

package/dist/esm-node/manager/sync.js

@@ -1,6 +1,6 @@
 import { isPipeline, createPipeline } from "../farrow-pipeline";
 import { isWaterfall, createWaterfall, isAsyncWaterfall, createAsyncWaterfall } from "../waterfall";
-import { isWorkflow, createWorkflow, isAsyncWorkflow, createAsyncWorkflow, isParallelWorkflow, createParallelWorkflow } from "../workflow";
+import { isWorkflow, createWorkflow, isAsyncWorkflow, createAsyncWorkflow, isParallelWorkflow, createParallelWorkflow, isAsyncInterruptWorkflow, createAsyncInterruptWorkflow, isSyncParallelWorkflow, createSyncParallelWorkflow } from "../workflow";
 import { checkPlugins, hasOwnProperty, includePlugin, isObject, sortPlugins } from "./shared";
 const SYNC_PLUGIN_SYMBOL = "SYNC_PLUGIN_SYMBOL";
 const DEFAULT_OPTIONS = {
@@ -136,6 +136,12 @@ const cloneHook = (hook) => {
   if (isParallelWorkflow(hook)) {
     return createParallelWorkflow();
   }
+  if (isAsyncInterruptWorkflow(hook)) {
+    return createAsyncInterruptWorkflow();
+  }
+  if (isSyncParallelWorkflow(hook)) {
+    return createSyncParallelWorkflow();
+  }
   if (isPipeline(hook)) {
     return createPipeline();
   }

package/dist/esm-node/workflow/index.js

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

package/dist/esm-node/workflow/interrupt.js

@@ -0,0 +1,39 @@
+import { createAsyncPipeline } from "../farrow-pipeline";
+const ASYNC_INTERRUPT_WORKFLOW_SYMBOL = Symbol.for("ASYNC_INTERRUPT_WORKFLOW_SYMBOL");
+const isAsyncInterruptWorkflow = (input) => Boolean(input === null || input === void 0 ? void 0 : input[ASYNC_INTERRUPT_WORKFLOW_SYMBOL]);
+const createAsyncInterruptWorkflow = () => {
+  const pipeline = createAsyncPipeline();
+  const use = (...input) => {
+    pipeline.use(...input.map(mapAsyncWorkerToInterruptMiddleware));
+    return workflow;
+  };
+  const run = async (input) => {
+    const result = await pipeline.run(input, {
+      onLast: () => []
+    });
+    return result;
+  };
+  const workflow = {
+    ...pipeline,
+    use,
+    run,
+    [ASYNC_INTERRUPT_WORKFLOW_SYMBOL]: true
+  };
+  return workflow;
+};
+const mapAsyncWorkerToInterruptMiddleware = (worker) => async (input, next) => {
+  let isInterrupted = false;
+  const interrupt = (value) => {
+    isInterrupted = true;
+    return value;
+  };
+  const result = await Promise.resolve(worker(input, interrupt));
+  if (isInterrupted) {
+    return result;
+  }
+  return Promise.resolve(next(input));
+};
+export {
+  createAsyncInterruptWorkflow,
+  isAsyncInterruptWorkflow
+};

package/dist/esm-node/workflow/syncParallel.js

@@ -0,0 +1,30 @@
+import { createPipeline } from "../farrow-pipeline";
+const SYNC_PARALLEL_WORKFLOW_SYMBOL = Symbol.for("SYNC_MODERN_PARALLEL_WORKFLOW");
+const isSyncParallelWorkflow = (input) => Boolean(input === null || input === void 0 ? void 0 : input[SYNC_PARALLEL_WORKFLOW_SYMBOL]);
+const createSyncParallelWorkflow = () => {
+  const pipeline = createPipeline();
+  const use = (...input) => {
+    pipeline.use(...input.map(mapSyncParallelWorkerToMiddleware));
+    return workflow;
+  };
+  const run = (input) => {
+    return pipeline.run(input, {
+      onLast: () => []
+    }).filter((result) => Boolean(result));
+  };
+  const workflow = {
+    ...pipeline,
+    run,
+    use,
+    [SYNC_PARALLEL_WORKFLOW_SYMBOL]: true
+  };
+  return workflow;
+};
+const mapSyncParallelWorkerToMiddleware = (worker) => (input, next) => [
+  worker(input),
+  ...next(input)
+];
+export {
+  createSyncParallelWorkflow,
+  isSyncParallelWorkflow
+};

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

@@ -1,17 +1,17 @@
 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';
+import type { Worker, Workflow, AsyncWorker, AsyncWorkflow, ParallelWorkflow, AsyncInterruptWorkflow, AsyncInterruptWorker, SyncParallelWorkflow } from '../workflow';
 /** All hook types. */
-export type Hook = Waterfall<any> | AsyncWaterfall<any> | Workflow<any, any> | AsyncWorkflow<any, any> | ParallelWorkflow<any> | Pipeline<any, any> | AsyncPipeline<any, any>;
+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 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 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 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 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;

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

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

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

@@ -0,0 +1,12 @@
+import { 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/syncParallel.d.ts

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

package/package.json

@@ -15,7 +15,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "2.56.2",
+  "version": "2.57.1",
   "jsnext:source": "./src/index.ts",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.js",
@@ -33,15 +33,15 @@
   },
   "dependencies": {
     "@swc/helpers": "0.5.3",
-    "@modern-js/utils": "2.56.2"
+    "@modern-js/utils": "2.57.1"
   },
   "devDependencies": {
     "@types/jest": "^29",
     "@types/node": "^14",
     "typescript": "^5",
     "jest": "^29",
-    "@scripts/build": "2.56.2",
-    "@scripts/jest-config": "2.56.2"
+    "@scripts/build": "2.57.1",
+    "@scripts/jest-config": "2.57.1"
   },
   "sideEffects": false,
   "publishConfig": {