@modern-js/plugin 1.21.5 → 2.0.0-beta.1

package/CHANGELOG.md

@@ -1,10 +1,29 @@
 # @modern-js/plugin
 
-## 1.21.5
+## 2.0.0-beta.1
 
-## 1.21.4
+### Major Changes
 
-## 1.21.3
+- dda38c9: chore: v2
+
+### Patch Changes
+
+- b8bbe036c7: feat: change type logic
+  feat: 修改类型相关的逻辑
+- f179749: fix: the sortPlugins api not work
+
+  fix: sortPlugins 没有真实生效
+
+## 2.0.0-beta.0
+
+### Major Changes
+
+- dda38c9: chore: v2
+
+### Patch Changes
+
+- b8bbe036c: feat: change type logic
+  feat: 修改类型相关的逻辑
 
 ## 1.21.2
 

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

@@ -2,29 +2,23 @@
  * 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 createContext = value => {
   let currentValue;
-
   const create = value => {
     currentValue = value;
-
     const use = () => ({
       get value() {
         return currentValue;
       },
-
       set value(v) {
         currentValue = v;
       }
-
     });
-
     const get = () => currentValue;
-
     const set = v => {
       currentValue = v;
     };
-
     const Context = {
       create,
       use,
@@ -33,6 +27,5 @@ export const createContext = value => {
     };
     return Context;
   };
-
   return create(value);
 };

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

@@ -2,15 +2,13 @@
  * 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/pipeline.js

@@ -1,9 +1,6 @@
 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
@@ -13,55 +10,42 @@ import { createCounter } from "./counter";
 export { createContext };
 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 = () => {
   const middlewares = [];
-
   const use = (...inputs) => {
     middlewares.push(...inputs.map(getMiddleware));
     return pipeline;
   };
-
   const createCurrentCounter = onLast => {
     return createCounter((index, input, next) => {
       if (index >= middlewares.length) {
         if (onLast) {
           return onLast(input);
         }
-
         throw new Error(`Expect returning a value, but all middlewares just calling next()`);
       }
-
       return middlewares[index](input, next);
     });
   };
-
   const currentCounter = createCurrentCounter();
-
   const getCounter = options => {
     if (!options) {
       return currentCounter;
     }
-
     return createCurrentCounter(options === null || options === void 0 ? void 0 : options.onLast);
   };
-
   const run = (input, options) => getCounter(options).start(input);
-
   const middleware = (input, next) => run(input, {
     onLast: next
   });
-
   const pipeline = {
     [PipelineSymbol]: true,
     use,

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

@@ -1,74 +1,62 @@
 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; }
-
 import { generateRunner, DEFAULT_OPTIONS } from "./sync";
 import { checkPlugins, isObject, hasOwnProperty, sortPlugins, includePlugin } from "./shared";
 const ASYNC_PLUGIN_SYMBOL = 'ASYNC_PLUGIN_SYMBOL';
 export const createAsyncManager = (hooks, api) => {
   let index = 0;
   let runners;
-
   let currentHooks = _objectSpread({}, hooks);
-
   const useRunner = () => runners;
-
   const registerHook = extraHooks => {
     currentHooks = _objectSpread(_objectSpread({}, extraHooks), currentHooks);
   };
-
   const isPlugin = input => isObject(input) && hasOwnProperty(input, ASYNC_PLUGIN_SYMBOL) && input[ASYNC_PLUGIN_SYMBOL] === ASYNC_PLUGIN_SYMBOL;
-
   const pluginAPI = _objectSpread(_objectSpread({}, api), {}, {
     useHookRunners: useRunner
   });
-
   const clone = overrideAPI => {
     let plugins = [];
-
     const addPlugin = plugin => {
       if (!includePlugin(plugins, plugin)) {
         plugins.push(_objectSpread({}, plugin));
       }
     };
-
     const usePlugin = (...input) => {
       for (const plugin of input) {
         // already created by createPlugin
         if (isPlugin(plugin)) {
           addPlugin(plugin);
-        } // using function to return plugin options
+        }
+        // using function to return plugin options
         else if (typeof plugin === 'function') {
           const options = plugin();
           addPlugin(createPlugin(options.setup, options));
-        } // plain plugin object
+        }
+        // plain plugin object
         else if (isObject(plugin)) {
           addPlugin(createPlugin(plugin.setup, plugin));
-        } // unknown plugin
+        }
+        // unknown plugin
         else {
           console.warn(`Unknown plugin: ${JSON.stringify(plugin)}`);
         }
       }
-
       return manager;
     };
-
-    const createPlugin = ( // eslint-disable-next-line @typescript-eslint/no-empty-function
+    const createPlugin = (
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
     setup = () => {}, options = {}) => {
       var _options$usePlugins;
-
       if ((_options$usePlugins = options.usePlugins) !== null && _options$usePlugins !== void 0 && _options$usePlugins.length) {
         options.usePlugins.forEach(plugin => {
           usePlugin(createPlugin(plugin.setup, plugin));
         });
       }
-
       if (options.registerHook) {
         registerHook(options.registerHook);
       }
-
       return _objectSpread(_objectSpread(_objectSpread({}, DEFAULT_OPTIONS), {}, {
         name: `No.${index++} plugin`
       }, options), {}, {
@@ -76,24 +64,18 @@ export const createAsyncManager = (hooks, api) => {
         setup
       });
     };
-
     const clear = () => {
       plugins = [];
     };
-
     const init = async () => {
       const sortedPlugins = sortPlugins(plugins);
-
       const mergedPluginAPI = _objectSpread(_objectSpread({}, pluginAPI), overrideAPI);
-
       checkPlugins(sortedPlugins);
       const hooksList = await Promise.all(sortedPlugins.map(plugin => plugin.setup(mergedPluginAPI)));
       runners = generateRunner(hooksList, currentHooks);
       return runners;
     };
-
     const run = cb => cb();
-
     const manager = {
       createPlugin,
       isPlugin,
@@ -107,6 +89,5 @@ export const createAsyncManager = (hooks, api) => {
     };
     return manager;
   };
-
   return clone();
 };

package/dist/js/modern/manager/shared.js

@@ -1,3 +1,4 @@
+import { dagSort } from "../utils/pluginDagSort";
 export const checkPlugins = plugins => {
   plugins.forEach(origin => {
     origin.rivals.forEach(rival => {
@@ -15,29 +16,8 @@ export const checkPlugins = plugins => {
   });
 };
 export function sortPlugins(input) {
-  let plugins = input.slice();
-
-  for (let i = 0; i < plugins.length; i++) {
-    const plugin = plugins[i];
-
-    for (const pre of plugin.pre) {
-      for (let j = i + 1; j < plugins.length; j++) {
-        if (plugins[j].name === pre) {
-          plugins = [...plugins.slice(0, i), plugins[j], ...plugins.slice(i, j), ...plugins.slice(j + 1, plugins.length)];
-        }
-      }
-    }
-
-    for (const post of plugin.post) {
-      for (let j = 0; j < i; j++) {
-        if (plugins[j].name === post) {
-          plugins = [...plugins.slice(0, j), ...plugins.slice(j + 1, i + 1), plugins[j], ...plugins.slice(i + 1, plugins.length)];
-        }
-      }
-    }
-  }
-
-  return plugins;
+  const plugins = input.slice();
+  return dagSort(plugins);
 }
 export const includePlugin = (plugins, input) => plugins.some(plugin => plugin.name === input.name);
 export const isObject = obj => obj !== null && typeof obj === 'object';

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

@@ -1,9 +1,6 @@
 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; }
-
 import { isPipeline, createPipeline } from "../farrow-pipeline";
 import { isWaterfall, createWaterfall, isAsyncWaterfall, createAsyncWaterfall } from "../waterfall";
 import { isWorkflow, createWorkflow, isAsyncWorkflow, createAsyncWorkflow, isParallelWorkflow, createParallelWorkflow } from "../workflow";
@@ -21,64 +18,56 @@ export const DEFAULT_OPTIONS = {
 export const createManager = (hooks, api) => {
   let index = 0;
   let runners;
-
   let currentHooks = _objectSpread({}, hooks);
-
   const useRunner = () => runners;
-
   const registerHook = extraHooks => {
     currentHooks = _objectSpread(_objectSpread({}, extraHooks), currentHooks);
   };
-
   const isPlugin = input => isObject(input) && hasOwnProperty(input, SYNC_PLUGIN_SYMBOL) && input[SYNC_PLUGIN_SYMBOL] === SYNC_PLUGIN_SYMBOL;
-
   const pluginAPI = _objectSpread(_objectSpread({}, api), {}, {
     useHookRunners: useRunner
   });
-
   const clone = overrideAPI => {
     let plugins = [];
-
     const addPlugin = plugin => {
       if (!includePlugin(plugins, plugin)) {
         plugins.push(_objectSpread({}, plugin));
       }
     };
-
     const usePlugin = (...input) => {
       input.forEach(plugin => {
         // already created by createPlugin
         if (isPlugin(plugin)) {
           addPlugin(plugin);
-        } // using function to return plugin options
+        }
+        // using function to return plugin options
         else if (typeof plugin === 'function') {
           const options = plugin();
           addPlugin(createPlugin(options.setup, options));
-        } // plain plugin object
+        }
+        // plain plugin object
         else if (isObject(plugin)) {
           addPlugin(createPlugin(plugin.setup, plugin));
-        } // unknown plugin
+        }
+        // unknown plugin
         else {
           console.warn(`Unknown plugin: ${JSON.stringify(plugin)}`);
         }
       });
       return manager;
     };
-
-    const createPlugin = ( // eslint-disable-next-line @typescript-eslint/no-empty-function
+    const createPlugin = (
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
     setup = () => {}, options = {}) => {
       var _options$usePlugins;
-
       if ((_options$usePlugins = options.usePlugins) !== null && _options$usePlugins !== void 0 && _options$usePlugins.length) {
         options.usePlugins.forEach(plugin => {
           usePlugin(createPlugin(plugin.setup, plugin));
         });
       }
-
       if (options.registerHook) {
         registerHook(options.registerHook);
       }
-
       return _objectSpread(_objectSpread(_objectSpread({}, DEFAULT_OPTIONS), {}, {
         name: `No.${index++} plugin`
       }, options), {}, {
@@ -86,24 +75,18 @@ export const createManager = (hooks, api) => {
         setup
       });
     };
-
     const clear = () => {
       plugins = [];
     };
-
     const init = () => {
       const sortedPlugins = sortPlugins(plugins);
-
       const mergedPluginAPI = _objectSpread(_objectSpread({}, pluginAPI), overrideAPI);
-
       checkPlugins(sortedPlugins);
       const hooksList = sortedPlugins.map(plugin => plugin.setup(mergedPluginAPI));
       runners = generateRunner(hooksList, currentHooks);
       return runners;
     };
-
     const run = cb => cb();
-
     const manager = {
       createPlugin,
       isPlugin,
@@ -117,72 +100,58 @@ export const createManager = (hooks, api) => {
     };
     return manager;
   };
-
   return clone();
 };
 export const generateRunner = (hooksList, hooksMap) => {
   const runner = {};
   const cloneShape = cloneHooksMap(hooksMap);
-
   if (hooksMap) {
     for (const key in cloneShape) {
       for (const hooks of hooksList) {
         if (!hooks) {
           continue;
         }
-
         if (hooks[key]) {
           cloneShape[key].use(hooks[key]);
         }
-      } // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      }
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
       // @ts-expect-error
-
-
       runner[key] = (input, options) => cloneShape[key].run(input, _objectSpread({}, options));
     }
   }
-
   return runner;
 };
 export const cloneHook = hook => {
   if (isWaterfall(hook)) {
     return createWaterfall();
   }
-
   if (isAsyncWaterfall(hook)) {
     return createAsyncWaterfall();
   }
-
   if (isWorkflow(hook)) {
     return createWorkflow();
   }
-
   if (isAsyncWorkflow(hook)) {
     return createAsyncWorkflow();
   }
-
   if (isParallelWorkflow(hook)) {
     return createParallelWorkflow();
   }
-
   if (isPipeline(hook)) {
     return createPipeline();
   }
-
   throw new Error(`Unknown hook: ${hook}`);
 };
 export const cloneHooksMap = record => {
   if (!record) {
     return record;
   }
-
   const result = {};
-
   for (const key in record) {
     // eslint-disable-next-line @typescript-eslint/ban-ts-comment
     // @ts-expect-error
     result[key] = cloneHook(record[key]);
   }
-
   return result;
 };

package/dist/js/modern/utils/pluginDagSort.js

@@ -0,0 +1,48 @@
+export const dagSort = (plugins, key = 'name', preKey = 'pre', postKey = 'post') => {
+  let allLines = [];
+  function getPluginByAny(q) {
+    const target = plugins.find(item => typeof q === 'string' ? item[key] === q : item[key] === q[key]);
+    // current plugin design can't guarantee the plugins in pre/post existed
+    if (!target) {
+      throw new Error(`plugin ${q} not existed`);
+    }
+    return target;
+  }
+  plugins.forEach(item => {
+    item[preKey].forEach(p => {
+      // compatibility: do not add the plugin-name that plugins not have
+      if (plugins.find(ap => ap.name === p)) {
+        allLines.push([getPluginByAny(p)[key], getPluginByAny(item)[key]]);
+      }
+    });
+    item[postKey].forEach(pt => {
+      // compatibility: do not add the plugin-name that plugins not have
+      if (plugins.find(ap => ap.name === pt)) {
+        allLines.push([getPluginByAny(item)[key], getPluginByAny(pt)[key]]);
+      }
+    });
+  });
+
+  // search the zero input plugin
+  let zeroEndPoints = plugins.filter(item => !allLines.find(l => l[1] === item[key]));
+  const sortedPoint = [];
+  while (zeroEndPoints.length) {
+    const zep = zeroEndPoints.shift();
+    sortedPoint.push(getPluginByAny(zep));
+    allLines = allLines.filter(l => l[0] !== getPluginByAny(zep)[key]);
+    const restPoints = plugins.filter(item => !sortedPoint.find(sp => sp[key] === item[key]));
+    zeroEndPoints = restPoints.filter(
+    // eslint-disable-next-line @typescript-eslint/no-loop-func
+    item => !allLines.find(l => l[1] === item[key]));
+  }
+  // if has ring, throw error
+  if (allLines.length) {
+    const restInRingPoints = {};
+    allLines.forEach(l => {
+      restInRingPoints[l[0]] = true;
+      restInRingPoints[l[1]] = true;
+    });
+    throw new Error(`plugins dependences has loop: ${Object.keys(restInRingPoints).join(',')}`);
+  }
+  return sortedPoint;
+};

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

@@ -1,9 +1,6 @@
 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; }
-
 import { createAsyncPipeline } from "../farrow-pipeline";
 const ASYNC_WATERFALL_SYMBOL = Symbol.for('MODERN_ASYNC_WATERFALL');
 export const getAsyncBrook = input => {
@@ -12,36 +9,29 @@ export const getAsyncBrook = input => {
   } else if (input && typeof input.middleware === 'function') {
     return input.middleware;
   }
-
   throw new Error(`${input} is not a AsyncBrook or { brook: AsyncBrook }`);
 };
 export const createAsyncWaterfall = () => {
   const pipeline = createAsyncPipeline();
-
   const use = (...input) => {
     pipeline.use(...input.map(getAsyncBrook).map(mapAsyncBrookToAsyncMiddleware));
     return waterfall;
   };
-
   const run = (input, options) => pipeline.run(input, _objectSpread(_objectSpread({}, options), {}, {
     onLast: input => input
   }));
-
   const middleware = input => {
     return pipeline.run(input, {
       onLast: input => input
     });
   };
-
   const waterfall = _objectSpread(_objectSpread({}, pipeline), {}, {
     use,
     run,
     middleware,
     [ASYNC_WATERFALL_SYMBOL]: true
   });
-
   return waterfall;
 };
 export const isAsyncWaterfall = input => Boolean(input === null || input === void 0 ? void 0 : input[ASYNC_WATERFALL_SYMBOL]);
-
 const mapAsyncBrookToAsyncMiddleware = brook => async (input, next) => next(await brook(input));

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

@@ -1,9 +1,6 @@
 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; }
-
 import { createPipeline } from "../farrow-pipeline";
 const WATERFALL_SYMBOL = Symbol.for('MODERN_WATERFALL');
 export const getBrook = input => {
@@ -12,36 +9,29 @@ export const getBrook = input => {
   } else if (input && typeof input.middleware === 'function') {
     return input.middleware;
   }
-
   throw new Error(`${input} is not a Brook or { brook: Brook }`);
 };
 export const createWaterfall = () => {
   const pipeline = createPipeline();
-
   const use = (...brooks) => {
     pipeline.use(...brooks.map(getBrook).map(mapBrookToMiddleware));
     return waterfall;
   };
-
   const run = (input, options) => pipeline.run(input, _objectSpread(_objectSpread({}, options), {}, {
     onLast: input => input
   }));
-
   const middleware = input => {
     return pipeline.run(input, {
       onLast: input => input
     });
   };
-
   const waterfall = _objectSpread(_objectSpread({}, pipeline), {}, {
     use,
     run,
     middleware,
     [WATERFALL_SYMBOL]: true
   });
-
   return waterfall;
 };
 export const isWaterfall = input => Boolean(input === null || input === void 0 ? void 0 : input[WATERFALL_SYMBOL]);
-
 const mapBrookToMiddleware = brook => (input, next) => next(brook(input));

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

@@ -1,43 +1,33 @@
 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; }
-
 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();
-
   const use = (...input) => {
     pipeline.use(...input.map(mapAsyncWorkerToAsyncMiddleware));
     return workflow;
   };
-
   const run = async input => {
     const result = pipeline.run(input, {
       onLast: () => []
     });
-
     if (isPromise(result)) {
       return result.then(result => result.filter(Boolean));
     } else {
       return result.filter(Boolean);
     }
   };
-
   const workflow = _objectSpread(_objectSpread({}, pipeline), {}, {
     use,
     run,
     [ASYNC_WORKFLOW_SYMBOL]: true
   });
-
   return workflow;
 };
-
 const mapAsyncWorkerToAsyncMiddleware = worker => async (input, next) => [await worker(input), ...(await next(input))];
-
 function isPromise(obj) {
   return Boolean(obj) && (typeof obj === 'object' || typeof obj === 'function') && typeof obj.then === 'function';
 }