@modern-js/plugin 2.11.0 → 2.13.0

package/dist/esm-node/farrow-pipeline/context.js

@@ -1,28 +1,19 @@
 const createContext = (value) => {
-  let currentValue;
-  const create = (value2) => {
-    currentValue = value2;
-    const use = () => ({
+  let currentValue = value;
+  return {
+    use: () => ({
       get value() {
         return currentValue;
       },
       set value(v) {
         currentValue = v;
       }
-    });
-    const get = () => currentValue;
-    const set = (v) => {
+    }),
+    get: () => currentValue,
+    set: (v) => {
       currentValue = v;
-    };
-    const Context = {
-      create,
-      use,
-      get,
-      set
-    };
-    return Context;
+    }
   };
-  return create(value);
 };
 export {
   createContext

package/dist/esm-node/farrow-pipeline/counter.js

@@ -3,9 +3,8 @@ const createCounter = (callback) => {
     const next = (nextInput = input) => dispatch(index + 1, nextInput);
     return callback(index, input, next);
   };
-  const start = (input) => dispatch(0, input);
   return {
-    start,
+    start: (input) => dispatch(0, input),
     dispatch
   };
 };

package/dist/esm-node/farrow-pipeline/index.js

@@ -1 +1,60 @@
-export * from "./pipeline";
+import { createContext } from "./context";
+import { createCounter } from "./counter";
+const isPipeline = (input) => Boolean(input == null ? 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`);
+};
+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 ? 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,
+    run,
+    middleware
+  };
+  return pipeline;
+};
+const createAsyncPipeline = () => {
+  const pipeline = createPipeline();
+  return { ...pipeline };
+};
+export {
+  createAsyncPipeline,
+  createContext,
+  createPipeline,
+  isPipeline
+};

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

@@ -31,7 +31,7 @@ const createAsyncManager = (hooks, api) => {
       }
     };
     const usePlugin = (...input) => {
-      for (const plugin of input) {
+      input.forEach((plugin) => {
         if (isPlugin(plugin)) {
           addPlugin(plugin);
         } else if (typeof plugin === "function") {
@@ -39,10 +39,10 @@ const createAsyncManager = (hooks, api) => {
           addPlugin(createPlugin(options.setup, options));
         } else if (isObject(plugin)) {
           addPlugin(createPlugin(plugin.setup, plugin));
-        } else {
+        } else if (process.env.NODE_ENV !== "production") {
           console.warn(`Unknown plugin: ${JSON.stringify(plugin)}`);
         }
-      }
+      });
       return manager;
     };
     const createPlugin = (setup = () => {
@@ -67,18 +67,19 @@ const createAsyncManager = (hooks, api) => {
     const clear = () => {
       plugins = [];
     };
-    const init = async () => {
+    const init = () => {
       const sortedPlugins = sortPlugins(plugins);
       const mergedPluginAPI = {
         ...pluginAPI,
         ...overrideAPI
       };
       checkPlugins(sortedPlugins);
-      const hooksList = await Promise.all(
+      return Promise.all(
         sortedPlugins.map((plugin) => plugin.setup(mergedPluginAPI))
-      );
-      runners = generateRunner(hooksList, currentHooks);
-      return runners;
+      ).then((hooksList) => {
+        runners = generateRunner(hooksList, currentHooks);
+        return runners;
+      });
     };
     const run = (cb) => cb();
     const manager = {

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

@@ -1,25 +1,26 @@
 import { dagSort } from "../utils/pluginDagSort";
 const checkPlugins = (plugins) => {
-  plugins.forEach((origin) => {
-    origin.rivals.forEach((rival) => {
-      plugins.forEach((plugin) => {
-        if (rival === plugin.name) {
-          throw new Error(`${origin.name} has rival ${plugin.name}`);
+  if (process.env.NODE_ENV !== "production") {
+    plugins.forEach((origin) => {
+      origin.rivals.forEach((rival) => {
+        plugins.forEach((plugin) => {
+          if (rival === plugin.name) {
+            throw new Error(`${origin.name} has rival ${plugin.name}`);
+          }
+        });
+      });
+      origin.required.forEach((required) => {
+        if (!plugins.some((plugin) => plugin.name === required)) {
+          throw new Error(
+            `The plugin: ${required} is required when plugin: ${origin.name} is exist.`
+          );
         }
       });
     });
-    origin.required.forEach((required) => {
-      if (!plugins.some((plugin) => plugin.name === required)) {
-        throw new Error(
-          `The plugin: ${required} is required when plugin: ${origin.name} is exist.`
-        );
-      }
-    });
-  });
+  }
 };
 function sortPlugins(input) {
-  const plugins = input.slice();
-  return dagSort(plugins);
+  return dagSort(input.slice());
 }
 const includePlugin = (plugins, input) => plugins.some((plugin) => plugin.name === input.name);
 const isObject = (obj) => obj !== null && typeof obj === "object";

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

@@ -62,7 +62,7 @@ const createManager = (hooks, api) => {
           addPlugin(createPlugin(options.setup, options));
         } else if (isObject(plugin)) {
           addPlugin(createPlugin(plugin.setup, plugin));
-        } else {
+        } else if (process.env.NODE_ENV !== "production") {
           console.warn(`Unknown plugin: ${JSON.stringify(plugin)}`);
         }
       });
@@ -124,17 +124,12 @@ const generateRunner = (hooksList, hooksMap) => {
   const cloneShape = cloneHooksMap(hooksMap);
   if (hooksMap) {
     for (const key in cloneShape) {
-      for (const hooks of hooksList) {
-        if (!hooks) {
-          continue;
-        }
-        if (hooks[key]) {
+      hooksList.forEach((hooks) => {
+        if (hooks == null ? void 0 : hooks[key]) {
           cloneShape[key].use(hooks[key]);
         }
-      }
-      runner[key] = (input, options) => cloneShape[key].run(input, {
-        ...options
       });
+      runner[key] = (input, options) => cloneShape[key].run(input, { ...options });
     }
   }
   return runner;

package/dist/esm-node/waterfall/async.js

@@ -5,7 +5,8 @@ const ASYNC_WATERFALL_SYMBOL = Symbol.for("MODERN_ASYNC_WATERFALL");
 const getAsyncBrook = (input) => {
   if (typeof input === "function") {
     return input;
-  } else if (input && typeof input.middleware === "function") {
+  }
+  if (input && typeof input.middleware === "function") {
     return input.middleware;
   }
   throw new Error(`${input} is not a AsyncBrook or { brook: AsyncBrook }`);
@@ -32,7 +33,7 @@ const createAsyncWaterfall = () => {
   return waterfall;
 };
 const isAsyncWaterfall = (input) => Boolean(input == null ? void 0 : input[ASYNC_WATERFALL_SYMBOL]);
-const mapAsyncBrookToAsyncMiddleware = (brook) => async (input, next) => next(await brook(input));
+const mapAsyncBrookToAsyncMiddleware = (brook) => (input, next) => Promise.resolve(brook(input)).then((result) => next(result));
 export {
   createAsyncWaterfall,
   getAsyncBrook,

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

@@ -9,13 +9,12 @@ const createAsyncWorkflow = () => {
     pipeline.use(...input.map(mapAsyncWorkerToAsyncMiddleware));
     return workflow;
   };
-  const run = async (input) => {
+  const run = (input) => {
     const result = pipeline.run(input, { onLast: () => [] });
     if (isPromise(result)) {
       return result.then((result2) => result2.filter(Boolean));
-    } else {
-      return result.filter(Boolean);
     }
+    return result.filter(Boolean);
   };
   const workflow = {
     ...pipeline,
@@ -25,9 +24,11 @@ const createAsyncWorkflow = () => {
   };
   return workflow;
 };
-const mapAsyncWorkerToAsyncMiddleware = (worker) => async (input, next) => [await worker(input), ...await next(input)];
+const mapAsyncWorkerToAsyncMiddleware = (worker) => (input, next) => Promise.resolve(worker(input)).then(
+  (result) => Promise.resolve(next(input)).then((nextResult) => [result, ...nextResult])
+);
 function isPromise(obj) {
-  return Boolean(obj) && (typeof obj === "object" || typeof obj === "function") && typeof obj.then === "function";
+  return obj && typeof obj.then === "function";
 }
 export {
   createAsyncWorkflow,

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

@@ -7,7 +7,7 @@ const createParallelWorkflow = () => {
     pipeline.use(...input.map(mapParallelWorkerToAsyncMiddleware));
     return workflow;
   };
-  const run = async (input) => Promise.all(pipeline.run(input, { onLast: () => [] })).then(
+  const run = (input) => Promise.all(pipeline.run(input, { onLast: () => [] })).then(
     (result) => result.filter(Boolean)
   );
   const workflow = {

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

@@ -3,7 +3,6 @@
  * license at https://github.com/farrow-js/farrow/blob/master/LICENSE
  */
 export type Context<T = any> = {
-  create: (value: T) => Context<T>;
   use: () => {
     value: T;
   };

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

@@ -2,4 +2,28 @@
  * modified from https://github.com/farrow-js/farrow/tree/master/packages/farrow-pipeline
  * license at https://github.com/farrow-js/farrow/blob/master/LICENSE
  */
-export * from './pipeline';
+import { createContext, Context } from './context';
+import { Next } from './counter';
+export type { Next };
+export { createContext };
+export type { Context };
+export type Middleware<I = unknown, O = unknown> = (input: I, next: Next<I, O>) => O;
+export type Middlewares<I = unknown, O = unknown> = Middleware<I, O>[];
+export declare const isPipeline: (input: any) => input is Pipeline<unknown, unknown>;
+declare const PipelineSymbol: unique symbol;
+export type RunPipelineOptions<I = unknown, O = unknown> = {
+  onLast?: (input: I) => O;
+};
+export type MiddlewareInput<I = unknown, O = unknown> = Middleware<I, O> | {
+  middleware: Middleware<I, O>;
+};
+export type Pipeline<I = unknown, O = unknown> = {
+  [PipelineSymbol]: true;
+  use: (...inputs: MiddlewareInput<I, O>[]) => Pipeline<I, O>;
+  run: (input: I, options?: RunPipelineOptions<I, O>) => O;
+  middleware: Middleware<I, O>;
+};
+export declare const createPipeline: <I, O>() => Pipeline<I, O>;
+export type MaybeAsync<T> = T | Promise<T>;
+export type AsyncPipeline<I = unknown, O = unknown> = Pipeline<I, MaybeAsync<O>>;
+export declare const createAsyncPipeline: <I, O>() => AsyncPipeline<I, O>;

package/package.json

@@ -11,7 +11,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "2.11.0",
+  "version": "2.13.0",
   "jsnext:source": "./src/index.ts",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.js",
@@ -35,8 +35,8 @@
     "@types/node": "^14",
     "typescript": "^4",
     "jest": "^29",
-    "@scripts/build": "2.11.0",
-    "@scripts/jest-config": "2.11.0"
+    "@scripts/jest-config": "2.13.0",
+    "@scripts/build": "2.13.0"
   },
   "sideEffects": false,
   "publishConfig": {

package/dist/cjs/farrow-pipeline/pipeline.js

@@ -1,86 +0,0 @@
-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 pipeline_exports = {};
-__export(pipeline_exports, {
-  createAsyncPipeline: () => createAsyncPipeline,
-  createContext: () => import_context.createContext,
-  createPipeline: () => createPipeline,
-  isPipeline: () => isPipeline
-});
-module.exports = __toCommonJS(pipeline_exports);
-var import_context = require("./context");
-var import_counter = require("./counter");
-const isPipeline = (input) => Boolean(input == null ? 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`);
-};
-const createPipeline = () => {
-  const middlewares = [];
-  const use = (...inputs) => {
-    middlewares.push(...inputs.map(getMiddleware));
-    return pipeline;
-  };
-  const createCurrentCounter = (onLast) => {
-    return (0, import_counter.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 ? 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,
-    run,
-    middleware
-  };
-  return pipeline;
-};
-const createAsyncPipeline = () => {
-  const pipeline = createPipeline();
-  return { ...pipeline };
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  createAsyncPipeline,
-  createContext,
-  createPipeline,
-  isPipeline
-});

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

@@ -1,31 +0,0 @@
-var createContext = function(value) {
-    var currentValue;
-    var create = function(value2) {
-        currentValue = value2;
-        var use = function() {
-            return {
-                get value () {
-                    return currentValue;
-                },
-                set value (v){
-                    currentValue = v;
-                }
-            };
-        };
-        var get = function() {
-            return currentValue;
-        };
-        var set = function(v1) {
-            currentValue = v1;
-        };
-        var Context = {
-            create: create,
-            use: use,
-            get: get,
-            set: set
-        };
-        return Context;
-    };
-    return create(value);
-};
-export { createContext };

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

@@ -1,17 +0,0 @@
-var createCounter = function(callback) {
-    var dispatch = function(index, input) {
-        var next = function() {
-            var nextInput = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : input;
-            return dispatch(index + 1, nextInput);
-        };
-        return callback(index, input, next);
-    };
-    var start = function(input) {
-        return dispatch(0, input);
-    };
-    return {
-        start: start,
-        dispatch: dispatch
-    };
-};
-export { createCounter };

package/dist/esm/farrow-pipeline/index.js

@@ -1 +0,0 @@
-export * from "./pipeline";

package/dist/esm/farrow-pipeline/pipeline.js

@@ -1,112 +0,0 @@
-function _arrayLikeToArray(arr, len) {
-    if (len == null || len > arr.length) len = arr.length;
-    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
-    return arr2;
-}
-function _arrayWithoutHoles(arr) {
-    if (Array.isArray(arr)) return _arrayLikeToArray(arr);
-}
-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;
-}
-function _iterableToArray(iter) {
-    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
-}
-function _nonIterableSpread() {
-    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-}
-function _objectSpread(target) {
-    for(var i = 1; i < arguments.length; i++){
-        var source = arguments[i] != null ? arguments[i] : {};
-        var ownKeys = Object.keys(source);
-        if (typeof Object.getOwnPropertySymbols === "function") {
-            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
-                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
-            }));
-        }
-        ownKeys.forEach(function(key) {
-            _defineProperty(target, key, source[key]);
-        });
-    }
-    return target;
-}
-function _toConsumableArray(arr) {
-    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
-}
-function _unsupportedIterableToArray(o, minLen) {
-    if (!o) return;
-    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
-    var n = Object.prototype.toString.call(o).slice(8, -1);
-    if (n === "Object" && o.constructor) n = o.constructor.name;
-    if (n === "Map" || n === "Set") return Array.from(n);
-    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
-}
-import { createContext } from "./context";
-import { createCounter } from "./counter";
-var isPipeline = function(input) {
-    return Boolean(input === null || input === void 0 ? void 0 : input[PipelineSymbol]);
-};
-var PipelineSymbol = Symbol.for("MODERN_PIPELINE");
-var getMiddleware = function(input) {
-    if (typeof input === "function") {
-        return input;
-    } else if (input && typeof input.middleware === "function") {
-        return input.middleware;
-    }
-    throw new Error("".concat(input, " is not a Middleware"));
-};
-var createPipeline = function() {
-    var middlewares = [];
-    var use = function() {
-        for(var _len = arguments.length, inputs = new Array(_len), _key = 0; _key < _len; _key++){
-            inputs[_key] = arguments[_key];
-        }
-        var _middlewares;
-        (_middlewares = middlewares).push.apply(_middlewares, _toConsumableArray(inputs.map(getMiddleware)));
-        return pipeline;
-    };
-    var createCurrentCounter = function(onLast) {
-        return createCounter(function(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);
-        });
-    };
-    var currentCounter = createCurrentCounter();
-    var getCounter = function(options) {
-        if (!options) {
-            return currentCounter;
-        }
-        return createCurrentCounter(options === null || options === void 0 ? void 0 : options.onLast);
-    };
-    var run = function(input, options) {
-        return getCounter(options).start(input);
-    };
-    var middleware = function(input, next) {
-        return run(input, {
-            onLast: next
-        });
-    };
-    var _obj;
-    var pipeline = (_obj = {}, _defineProperty(_obj, PipelineSymbol, true), _defineProperty(_obj, "use", use), _defineProperty(_obj, "run", run), _defineProperty(_obj, "middleware", middleware), _obj);
-    return pipeline;
-};
-var createAsyncPipeline = function() {
-    var pipeline = createPipeline();
-    return _objectSpread({}, pipeline);
-};
-export { createAsyncPipeline, createContext, createPipeline, isPipeline };