@modern-js/plugin 1.21.2-beta.1 → 1.21.2-beta.2

package/dist/js/modern/workflow/sync.js

@@ -0,0 +1,34 @@
+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 WORKFLOW_SYMBOL = Symbol.for('MODERN_WORKFLOW');
+export 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 = _objectSpread(_objectSpread({}, pipeline), {}, {
+    use,
+    run,
+    [WORKFLOW_SYMBOL]: true
+  });
+
+  return workflow;
+};
+export const isWorkflow = input => Boolean(input === null || input === void 0 ? void 0 : input[WORKFLOW_SYMBOL]);
+
+const mapWorkerToMiddleware = worker => (input, next) => [worker(input), ...next(input)];

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

@@ -0,0 +1,47 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createContext = void 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
+ */
+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,
+      get,
+      set
+    };
+    return Context;
+  };
+
+  return create(value);
+};
+
+exports.createContext = createContext;

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

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createCounter = void 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
+ */
+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
+  };
+};
+
+exports.createCounter = createCounter;

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

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _pipeline = require("./pipeline");
+
+Object.keys(_pipeline).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _pipeline[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _pipeline[key];
+    }
+  });
+});

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

@@ -0,0 +1,94 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createAsyncPipeline = void 0;
+Object.defineProperty(exports, "createContext", {
+  enumerable: true,
+  get: function () {
+    return _context.createContext;
+  }
+});
+exports.isPipeline = exports.createPipeline = void 0;
+
+var _context = require("./context");
+
+var _counter = require("./counter");
+
+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; }
+
+const isPipeline = input => Boolean(input === null || input === void 0 ? void 0 : input[PipelineSymbol]);
+
+exports.isPipeline = isPipeline;
+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, _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 || 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;
+};
+
+exports.createPipeline = createPipeline;
+
+const createAsyncPipeline = () => {
+  const pipeline = createPipeline();
+  return _objectSpread({}, pipeline);
+};
+
+exports.createAsyncPipeline = createAsyncPipeline;

package/dist/js/node/index.js

@@ -0,0 +1,57 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _farrowPipeline = require("./farrow-pipeline");
+
+Object.keys(_farrowPipeline).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _farrowPipeline[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _farrowPipeline[key];
+    }
+  });
+});
+
+var _waterfall = require("./waterfall");
+
+Object.keys(_waterfall).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _waterfall[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _waterfall[key];
+    }
+  });
+});
+
+var _workflow = require("./workflow");
+
+Object.keys(_workflow).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _workflow[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _workflow[key];
+    }
+  });
+});
+
+var _manager = require("./manager");
+
+Object.keys(_manager).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _manager[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _manager[key];
+    }
+  });
+});

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

@@ -0,0 +1,124 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createAsyncManager = void 0;
+
+var _sync = require("./sync");
+
+var _shared = require("./shared");
+
+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; }
+
+const ASYNC_PLUGIN_SYMBOL = 'ASYNC_PLUGIN_SYMBOL';
+
+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 => (0, _shared.isObject)(input) && (0, _shared.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 (!(0, _shared.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
+        else if (typeof plugin === 'function') {
+          const options = plugin();
+          addPlugin(createPlugin(options.setup, options));
+        } // plain plugin object
+        else if ((0, _shared.isObject)(plugin)) {
+          addPlugin(createPlugin(plugin.setup, plugin));
+        } // unknown plugin
+        else {
+          console.warn(`Unknown plugin: ${JSON.stringify(plugin)}`);
+        }
+      }
+
+      return manager;
+    };
+
+    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({}, _sync.DEFAULT_OPTIONS), {}, {
+        name: `No.${index++} plugin`
+      }, options), {}, {
+        ASYNC_PLUGIN_SYMBOL,
+        setup
+      });
+    };
+
+    const clear = () => {
+      plugins = [];
+    };
+
+    const init = async () => {
+      const sortedPlugins = (0, _shared.sortPlugins)(plugins);
+
+      const mergedPluginAPI = _objectSpread(_objectSpread({}, pluginAPI), overrideAPI);
+
+      (0, _shared.checkPlugins)(sortedPlugins);
+      const hooksList = await Promise.all(sortedPlugins.map(plugin => plugin.setup(mergedPluginAPI)));
+      runners = (0, _sync.generateRunner)(hooksList, currentHooks);
+      return runners;
+    };
+
+    const run = cb => cb();
+
+    const manager = {
+      createPlugin,
+      isPlugin,
+      usePlugin,
+      init,
+      run,
+      clear,
+      clone,
+      registerHook,
+      useRunner
+    };
+    return manager;
+  };
+
+  return clone();
+};
+
+exports.createAsyncManager = createAsyncManager;

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

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _sync = require("./sync");
+
+Object.keys(_sync).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _sync[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _sync[key];
+    }
+  });
+});
+
+var _async = require("./async");
+
+Object.keys(_async).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _async[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _async[key];
+    }
+  });
+});
+
+var _types = require("./types");
+
+Object.keys(_types).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _types[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _types[key];
+    }
+  });
+});

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

@@ -0,0 +1,64 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isObject = exports.includePlugin = exports.hasOwnProperty = exports.checkPlugins = void 0;
+exports.sortPlugins = sortPlugins;
+
+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}`);
+        }
+      });
+    });
+    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.`);
+      }
+    });
+  });
+};
+
+exports.checkPlugins = checkPlugins;
+
+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 includePlugin = (plugins, input) => plugins.some(plugin => plugin.name === input.name);
+
+exports.includePlugin = includePlugin;
+
+const isObject = obj => obj !== null && typeof obj === 'object';
+
+exports.isObject = isObject;
+
+const hasOwnProperty = (obj, prop) => obj.hasOwnProperty(prop);
+
+exports.hasOwnProperty = hasOwnProperty;