@modern-js/plugin 2.11.0 → 2.13.0

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # @modern-js/plugin
 
+## 2.13.0
+
+### Patch Changes
+
+- 78431f4: perf(plugin): reduce bundle size
+
+  perf(plugin): 优化包体积
+
+## 2.12.0
+
 ## 2.11.0
 
 ## 2.10.0

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

@@ -21,30 +21,21 @@ __export(context_exports, {
 });
 module.exports = __toCommonJS(context_exports);
 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);
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

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

@@ -25,9 +25,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/cjs/farrow-pipeline/index.js

@@ -2,6 +2,10 @@ 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))
@@ -10,8 +14,73 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var farrow_pipeline_exports = {};
+__export(farrow_pipeline_exports, {
+  createAsyncPipeline: () => createAsyncPipeline,
+  createContext: () => import_context.createContext,
+  createPipeline: () => createPipeline,
+  isPipeline: () => isPipeline
+});
 module.exports = __toCommonJS(farrow_pipeline_exports);
-__reExport(farrow_pipeline_exports, require("./pipeline"), module.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/cjs/manager/async.js

@@ -47,7 +47,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") {
@@ -55,10 +55,10 @@ const createAsyncManager = (hooks, api) => {
           addPlugin(createPlugin(options.setup, options));
         } else if ((0, import_shared.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 = () => {
@@ -83,18 +83,19 @@ const createAsyncManager = (hooks, api) => {
     const clear = () => {
       plugins = [];
     };
-    const init = async () => {
+    const init = () => {
       const sortedPlugins = (0, import_shared.sortPlugins)(plugins);
       const mergedPluginAPI = {
         ...pluginAPI,
         ...overrideAPI
       };
       (0, import_shared.checkPlugins)(sortedPlugins);
-      const hooksList = await Promise.all(
+      return Promise.all(
         sortedPlugins.map((plugin) => plugin.setup(mergedPluginAPI))
-      );
-      runners = (0, import_sync.generateRunner)(hooksList, currentHooks);
-      return runners;
+      ).then((hooksList) => {
+        runners = (0, import_sync.generateRunner)(hooksList, currentHooks);
+        return runners;
+      });
     };
     const run = (cb) => cb();
     const manager = {

package/dist/cjs/manager/shared.js

@@ -26,26 +26,27 @@ __export(shared_exports, {
 module.exports = __toCommonJS(shared_exports);
 var import_pluginDagSort = require("../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 (0, import_pluginDagSort.dagSort)(plugins);
+  return (0, import_pluginDagSort.dagSort)(input.slice());
 }
 const includePlugin = (plugins, input) => plugins.some((plugin) => plugin.name === input.name);
 const isObject = (obj) => obj !== null && typeof obj === "object";

package/dist/cjs/manager/sync.js

@@ -70,7 +70,7 @@ const createManager = (hooks, api) => {
           addPlugin(createPlugin(options.setup, options));
         } else if ((0, import_shared.isObject)(plugin)) {
           addPlugin(createPlugin(plugin.setup, plugin));
-        } else {
+        } else if (process.env.NODE_ENV !== "production") {
           console.warn(`Unknown plugin: ${JSON.stringify(plugin)}`);
         }
       });
@@ -132,17 +132,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/cjs/waterfall/async.js

@@ -27,7 +27,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 }`);
@@ -54,7 +55,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));
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   createAsyncWaterfall,

package/dist/cjs/workflow/async.js

@@ -30,13 +30,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,
@@ -46,9 +45,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";
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/cjs/workflow/parallel.js

@@ -30,7 +30,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 = {