@modern-js/plugin 2.69.5 → 3.0.0-alpha.0

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

@@ -1,20 +0,0 @@
-const createContext = (value) => {
-  let currentValue = value;
-  return {
-    use: () => ({
-      get value() {
-        return currentValue;
-      },
-      set value(v) {
-        currentValue = v;
-      }
-    }),
-    get: () => currentValue,
-    set: (v1) => {
-      currentValue = v1;
-    }
-  };
-};
-export {
-  createContext
-};

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

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

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

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

package/dist/esm-node/index.js

@@ -1,4 +0,0 @@
-export * from "./farrow-pipeline";
-export * from "./waterfall";
-export * from "./workflow";
-export * from "./manager";

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

@@ -1,106 +0,0 @@
-import {
-  checkPlugins,
-  hasOwnProperty,
-  includePlugin,
-  isObject,
-  sortPlugins
-} from "./shared";
-import { DEFAULT_OPTIONS, generateRunner } from "./sync";
-const ASYNC_PLUGIN_SYMBOL = "ASYNC_PLUGIN_SYMBOL";
-const createAsyncManager = (hooks, api) => {
-  let index = 0;
-  let runners;
-  let currentHooks = {
-    ...hooks
-  };
-  const useRunner = () => runners;
-  const registerHook = (extraHooks) => {
-    currentHooks = {
-      ...extraHooks,
-      ...currentHooks
-    };
-  };
-  const isPlugin = (input) => isObject(input) && hasOwnProperty(input, ASYNC_PLUGIN_SYMBOL) && input[ASYNC_PLUGIN_SYMBOL] === ASYNC_PLUGIN_SYMBOL;
-  const pluginAPI = {
-    ...api,
-    useHookRunners: useRunner
-  };
-  const clone = (overrideAPI) => {
-    let plugins = [];
-    const addPlugin = (plugin) => {
-      if (!includePlugin(plugins, plugin)) {
-        plugins.push({
-          ...plugin
-        });
-      }
-    };
-    const usePlugin = (...input) => {
-      input.forEach((plugin) => {
-        if (isPlugin(plugin)) {
-          addPlugin(plugin);
-        } else if (typeof plugin === "function") {
-          const options = plugin();
-          addPlugin(createPlugin(options.setup, options));
-        } else if (isObject(plugin)) {
-          addPlugin(createPlugin(plugin.setup, plugin));
-        } else if (process.env.NODE_ENV !== "production") {
-          console.warn(`Unknown plugin: ${JSON.stringify(plugin)}`);
-        }
-      });
-      return manager;
-    };
-    const createPlugin = (setup = () => {
-    }, options = {}) => {
-      var _options_usePlugins;
-      if ((_options_usePlugins = options.usePlugins) === null || _options_usePlugins === void 0 ? void 0 : _options_usePlugins.length) {
-        options.usePlugins.forEach((plugin) => {
-          usePlugin(createPlugin(plugin.setup, plugin));
-        });
-      }
-      if (options.registerHook) {
-        registerHook(options.registerHook);
-      }
-      return {
-        ...DEFAULT_OPTIONS,
-        name: `No.${index++} plugin`,
-        ...options,
-        ASYNC_PLUGIN_SYMBOL,
-        setup
-      };
-    };
-    const clear = () => {
-      plugins = [];
-    };
-    const init = async () => {
-      const sortedPlugins = sortPlugins(plugins);
-      const mergedPluginAPI = {
-        ...pluginAPI,
-        ...overrideAPI
-      };
-      checkPlugins(sortedPlugins);
-      const hooksList = [];
-      for (const plugin of sortedPlugins) {
-        hooksList.push(await plugin.setup(mergedPluginAPI));
-      }
-      runners = generateRunner(hooksList, currentHooks);
-      return runners;
-    };
-    const run = (cb) => cb();
-    const manager = {
-      createPlugin,
-      isPlugin,
-      usePlugin,
-      init,
-      run,
-      clear,
-      clone,
-      registerHook,
-      useRunner
-    };
-    return manager;
-  };
-  return clone();
-};
-export {
-  createAsyncManager
-};

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

@@ -1,3 +0,0 @@
-export * from "./sync";
-export * from "./async";
-export * from "./types";

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

@@ -1,32 +0,0 @@
-import { pluginDagSort } from "@modern-js/utils/universal/plugin-dag-sort";
-const checkPlugins = (plugins) => {
-  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.`);
-        }
-      });
-    });
-  }
-};
-function sortPlugins(input) {
-  return pluginDagSort(input.slice());
-}
-const includePlugin = (plugins, input) => plugins.some((plugin) => plugin.name === input.name);
-const isObject = (obj) => obj !== null && typeof obj === "object";
-const hasOwnProperty = (obj, prop) => obj.hasOwnProperty(prop);
-export {
-  checkPlugins,
-  hasOwnProperty,
-  includePlugin,
-  isObject,
-  sortPlugins
-};

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

@@ -1,172 +0,0 @@
-import { createPipeline, isPipeline } from "../farrow-pipeline";
-import { createAsyncWaterfall, createWaterfall, isAsyncWaterfall, isWaterfall } from "../waterfall";
-import { createAsyncInterruptWorkflow, createAsyncWorkflow, createParallelWorkflow, createSyncParallelWorkflow, createWorkflow, isAsyncInterruptWorkflow, isAsyncWorkflow, isParallelWorkflow, isSyncParallelWorkflow, isWorkflow } from "../workflow";
-import {
-  checkPlugins,
-  hasOwnProperty,
-  includePlugin,
-  isObject,
-  sortPlugins
-} from "./shared";
-const SYNC_PLUGIN_SYMBOL = "SYNC_PLUGIN_SYMBOL";
-const DEFAULT_OPTIONS = {
-  name: "untitled",
-  pre: [],
-  post: [],
-  rivals: [],
-  required: [],
-  usePlugins: [],
-  registerHook: {}
-};
-const createManager = (hooks, api) => {
-  let index = 0;
-  let runners;
-  let currentHooks = {
-    ...hooks
-  };
-  const useRunner = () => runners;
-  const registerHook = (extraHooks) => {
-    currentHooks = {
-      ...extraHooks,
-      ...currentHooks
-    };
-  };
-  const isPlugin = (input) => isObject(input) && hasOwnProperty(input, SYNC_PLUGIN_SYMBOL) && input[SYNC_PLUGIN_SYMBOL] === SYNC_PLUGIN_SYMBOL;
-  const pluginAPI = {
-    ...api,
-    useHookRunners: useRunner
-  };
-  const clone = (overrideAPI) => {
-    let plugins = [];
-    const addPlugin = (plugin) => {
-      if (!includePlugin(plugins, plugin)) {
-        plugins.push({
-          ...plugin
-        });
-      }
-    };
-    const usePlugin = (...input) => {
-      input.forEach((plugin) => {
-        if (isPlugin(plugin)) {
-          addPlugin(plugin);
-        } else if (typeof plugin === "function") {
-          const options = plugin();
-          addPlugin(createPlugin(options.setup, options));
-        } else if (isObject(plugin)) {
-          addPlugin(createPlugin(plugin.setup, plugin));
-        } else if (process.env.NODE_ENV !== "production") {
-          console.warn(`Unknown plugin: ${JSON.stringify(plugin)}`);
-        }
-      });
-      return manager;
-    };
-    const createPlugin = (setup = () => {
-    }, options = {}) => {
-      var _options_usePlugins;
-      if ((_options_usePlugins = options.usePlugins) === null || _options_usePlugins === void 0 ? void 0 : _options_usePlugins.length) {
-        options.usePlugins.forEach((plugin) => {
-          usePlugin(createPlugin(plugin.setup, plugin));
-        });
-      }
-      if (options.registerHook) {
-        registerHook(options.registerHook);
-      }
-      return {
-        ...DEFAULT_OPTIONS,
-        name: `No.${index++} plugin`,
-        ...options,
-        SYNC_PLUGIN_SYMBOL,
-        setup
-      };
-    };
-    const clear = () => {
-      plugins = [];
-    };
-    const init = () => {
-      const sortedPlugins = sortPlugins(plugins);
-      const mergedPluginAPI = {
-        ...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,
-      usePlugin,
-      init,
-      clear,
-      run,
-      registerHook,
-      useRunner,
-      clone
-    };
-    return manager;
-  };
-  return clone();
-};
-const generateRunner = (hooksList, hooksMap) => {
-  const runner = {};
-  const cloneShape = cloneHooksMap(hooksMap);
-  if (hooksMap) {
-    for (const key in cloneShape) {
-      hooksList.forEach((hooks) => {
-        if (hooks === null || hooks === void 0 ? void 0 : hooks[key]) {
-          cloneShape[key].use(hooks[key]);
-        }
-      });
-      runner[key] = (input, options) => cloneShape[key].run(input, {
-        ...options
-      });
-    }
-  }
-  return runner;
-};
-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 (isAsyncInterruptWorkflow(hook)) {
-    return createAsyncInterruptWorkflow();
-  }
-  if (isSyncParallelWorkflow(hook)) {
-    return createSyncParallelWorkflow();
-  }
-  if (isPipeline(hook)) {
-    return createPipeline();
-  }
-  throw new Error(`Unknown hook: ${hook}`);
-};
-const cloneHooksMap = (record) => {
-  if (!record) {
-    return record;
-  }
-  const result = {};
-  for (const key in record) {
-    result[key] = cloneHook(record[key]);
-  }
-  return result;
-};
-export {
-  DEFAULT_OPTIONS,
-  cloneHook,
-  cloneHooksMap,
-  createManager,
-  generateRunner
-};

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

@@ -1,42 +0,0 @@
-import { createAsyncPipeline } from "../farrow-pipeline";
-const ASYNC_WATERFALL_SYMBOL = Symbol.for("MODERN_ASYNC_WATERFALL");
-const getAsyncBrook = (input) => {
-  if (typeof input === "function") {
-    return input;
-  }
-  if (input && typeof input.middleware === "function") {
-    return input.middleware;
-  }
-  throw new Error(`${input} is not a AsyncBrook or { brook: AsyncBrook }`);
-};
-const createAsyncWaterfall = () => {
-  const pipeline = createAsyncPipeline();
-  const use = (...input) => {
-    pipeline.use(...input.map(getAsyncBrook).map(mapAsyncBrookToAsyncMiddleware));
-    return waterfall;
-  };
-  const run = (input, options) => pipeline.run(input, {
-    ...options,
-    onLast: (input2) => input2
-  });
-  const middleware = (input) => {
-    return pipeline.run(input, {
-      onLast: (input2) => input2
-    });
-  };
-  const waterfall = {
-    ...pipeline,
-    use,
-    run,
-    middleware,
-    [ASYNC_WATERFALL_SYMBOL]: true
-  };
-  return waterfall;
-};
-const isAsyncWaterfall = (input) => Boolean(input === null || input === void 0 ? void 0 : input[ASYNC_WATERFALL_SYMBOL]);
-const mapAsyncBrookToAsyncMiddleware = (brook) => (input, next) => Promise.resolve(brook(input)).then((result) => next(result));
-export {
-  createAsyncWaterfall,
-  getAsyncBrook,
-  isAsyncWaterfall
-};

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

@@ -1,2 +0,0 @@
-export * from "./sync";
-export * from "./async";

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

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

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

@@ -1,35 +0,0 @@
-import { createAsyncPipeline } from "../farrow-pipeline";
-const ASYNC_WORKFLOW_SYMBOL = Symbol.for("MODERN_ASYNC_WORKFLOW");
-const isPromise = (obj) => obj && typeof obj.then === "function";
-const isAsyncWorkflow = (input) => Boolean(input === null || input === void 0 ? void 0 : input[ASYNC_WORKFLOW_SYMBOL]);
-const createAsyncWorkflow = () => {
-  const pipeline = createAsyncPipeline();
-  const use = (...input) => {
-    pipeline.use(...input.map(mapAsyncWorkerToAsyncMiddleware));
-    return workflow;
-  };
-  const run = (input) => {
-    const result = pipeline.run(input, {
-      onLast: () => []
-    });
-    if (isPromise(result)) {
-      return result.then((result2) => result2.filter(Boolean));
-    }
-    return result.filter(Boolean);
-  };
-  const workflow = {
-    ...pipeline,
-    use,
-    run,
-    [ASYNC_WORKFLOW_SYMBOL]: true
-  };
-  return workflow;
-};
-const mapAsyncWorkerToAsyncMiddleware = (worker) => (input, next) => Promise.resolve(worker(input)).then((result) => Promise.resolve(next(input)).then((nextResult) => [
-  result,
-  ...nextResult
-]));
-export {
-  createAsyncWorkflow,
-  isAsyncWorkflow
-};

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

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

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

@@ -1,39 +0,0 @@
-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/parallel.js

@@ -1,28 +0,0 @@
-import { createPipeline } from "../farrow-pipeline";
-const PARALLEL_WORKFLOW_SYMBOL = Symbol.for("MODERN_PARALLEL_WORKFLOW");
-const isParallelWorkflow = (input) => Boolean(input === null || input === void 0 ? void 0 : input[PARALLEL_WORKFLOW_SYMBOL]);
-const createParallelWorkflow = () => {
-  const pipeline = createPipeline();
-  const use = (...input) => {
-    pipeline.use(...input.map(mapParallelWorkerToAsyncMiddleware));
-    return workflow;
-  };
-  const run = (input) => Promise.all(pipeline.run(input, {
-    onLast: () => []
-  })).then((result) => result.filter(Boolean));
-  const workflow = {
-    ...pipeline,
-    run,
-    use,
-    [PARALLEL_WORKFLOW_SYMBOL]: true
-  };
-  return workflow;
-};
-const mapParallelWorkerToAsyncMiddleware = (worker) => (input, next) => [
-  worker(input),
-  ...next(input)
-];
-export {
-  createParallelWorkflow,
-  isParallelWorkflow
-};

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

@@ -1,31 +0,0 @@
-import { createPipeline } from "../farrow-pipeline";
-const WORKFLOW_SYMBOL = Symbol.for("MODERN_WORKFLOW");
-const createWorkflow = () => {
-  const pipeline = createPipeline();
-  const use = (...input) => {
-    pipeline.use(...input.map(mapWorkerToMiddleware));
-    return workflow;
-  };
-  const run = (input) => {
-    const result = pipeline.run(input, {
-      onLast: () => []
-    });
-    return result.filter(Boolean);
-  };
-  const workflow = {
-    ...pipeline,
-    use,
-    run,
-    [WORKFLOW_SYMBOL]: true
-  };
-  return workflow;
-};
-const isWorkflow = (input) => Boolean(input === null || input === void 0 ? void 0 : input[WORKFLOW_SYMBOL]);
-const mapWorkerToMiddleware = (worker) => (input, next) => [
-  worker(input),
-  ...next(input)
-];
-export {
-  createWorkflow,
-  isWorkflow
-};

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

@@ -1,30 +0,0 @@
-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/farrow-pipeline/context.d.ts

@@ -1,12 +0,0 @@
-/**
- * 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 type Context<T = any> = {
-    use: () => {
-        value: T;
-    };
-    get: () => T;
-    set: (value: T) => void;
-};
-export declare const createContext: <T>(value: T) => Context<T>;