@modern-js/plugin-v2 0.0.0-next-20241113090110

package/dist/esm/index.js

@@ -0,0 +1,1499 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/manager.ts
+import { _ as _type_of } from "@swc/helpers/_/_type_of";
+import { createDebugger, isFunction, logger } from "@modern-js/utils";
+var debug = createDebugger("plugin-v2");
+function validatePlugin(plugin) {
+  var type = typeof plugin === "undefined" ? "undefined" : _type_of(plugin);
+  if (type !== "object" || plugin === null) {
+    throw new Error("Expect CLI Plugin instance to be an object, but got ".concat(type, "."));
+  }
+  if (isFunction(plugin.setup)) {
+    return;
+  }
+  throw new Error("Expect CLI Plugin plugin.setup to be a function, but got ".concat(type, "."));
+}
+function createPluginManager() {
+  var plugins = /* @__PURE__ */ new Map();
+  var dependencies = /* @__PURE__ */ new Map();
+  var addDependency = function(plugin, dependency, type) {
+    if (!dependencies.has(dependency)) {
+      dependencies.set(dependency, {
+        pre: /* @__PURE__ */ new Map(),
+        post: /* @__PURE__ */ new Map()
+      });
+    }
+    if (type === "pre") {
+      dependencies.get(plugin).pre.set(dependency, {
+        name: dependency,
+        isUse: false
+      });
+    } else if (type === "post") {
+      dependencies.get(plugin).post.set(dependency, {
+        name: dependency
+      });
+    } else if (type === "use") {
+      if (!dependencies.get(plugin).post.has(dependency)) {
+        dependencies.get(plugin).pre.set(dependency, {
+          name: dependency,
+          isUse: true
+        });
+      }
+    }
+  };
+  var addPlugin = function(newPlugin) {
+    if (!newPlugin) {
+      return;
+    }
+    validatePlugin(newPlugin);
+    var name = newPlugin.name, _newPlugin_usePlugins = newPlugin.usePlugins, usePlugins = _newPlugin_usePlugins === void 0 ? [] : _newPlugin_usePlugins, _newPlugin_pre = newPlugin.pre, pre = _newPlugin_pre === void 0 ? [] : _newPlugin_pre, _newPlugin_post = newPlugin.post, post = _newPlugin_post === void 0 ? [] : _newPlugin_post;
+    if (plugins.has(name)) {
+      logger.warn("Plugin ".concat(name, " already exists."));
+      return;
+    }
+    plugins.set(name, newPlugin);
+    dependencies.set(name, {
+      pre: /* @__PURE__ */ new Map(),
+      post: /* @__PURE__ */ new Map()
+    });
+    pre.forEach(function(dep) {
+      addDependency(name, dep, "pre");
+    });
+    post.forEach(function(dep) {
+      addDependency(name, dep, "post");
+    });
+    usePlugins.forEach(function(plugin) {
+      if (!plugins.has(plugin.name)) {
+        addPlugin(plugin);
+      }
+      addDependency(name, plugin.name, "use");
+    });
+  };
+  var addPlugins = function(newPlugins) {
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+    try {
+      for (var _iterator = newPlugins[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+        var newPlugin = _step.value;
+        addPlugin(newPlugin);
+      }
+    } catch (err) {
+      _didIteratorError = true;
+      _iteratorError = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion && _iterator.return != null) {
+          _iterator.return();
+        }
+      } finally {
+        if (_didIteratorError) {
+          throw _iteratorError;
+        }
+      }
+    }
+  };
+  var getPlugins = function() {
+    var visited = /* @__PURE__ */ new Set();
+    var temp = /* @__PURE__ */ new Set();
+    var result = [];
+    var visit = function(name) {
+      if (temp.has(name)) {
+        throw new Error("Circular dependency detected: ".concat(name));
+      }
+      if (!visited.has(name)) {
+        temp.add(name);
+        var pre = dependencies.get(name).pre;
+        Array.from(pre.values()).filter(function(dep) {
+          return !dep.isUse;
+        }).forEach(function(dep) {
+          return visit(dep.name);
+        });
+        Array.from(pre.values()).filter(function(dep) {
+          return dep.isUse;
+        }).forEach(function(dep) {
+          return visit(dep.name);
+        });
+        temp.delete(name);
+        visited.add(name);
+        result.push(plugins.get(name));
+      }
+    };
+    plugins.forEach(function(_, name) {
+      var post = dependencies.get(name).post;
+      post.forEach(function(dep) {
+        if (!dependencies.get(dep.name).pre.has(name)) {
+          dependencies.get(dep.name).pre.set(name, {
+            name,
+            isUse: false
+          });
+        }
+      });
+    });
+    plugins.forEach(function(_, name) {
+      visit(name);
+    });
+    result = result.filter(function(result2) {
+      return result2;
+    });
+    debug("CLI Plugins:", result.map(function(p) {
+      return p.name;
+    }));
+    return result;
+  };
+  return {
+    getPlugins,
+    addPlugins
+  };
+}
+
+// src/hooks.ts
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+function createAsyncHook() {
+  var callbacks = [];
+  var tap = function(cb) {
+    callbacks.push(cb);
+  };
+  var call = function() {
+    var _ref = _async_to_generator(function() {
+      var _len, params, _key, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, callback, result, err;
+      var _arguments = arguments;
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            for (_len = _arguments.length, params = new Array(_len), _key = 0; _key < _len; _key++) {
+              params[_key] = _arguments[_key];
+            }
+            _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+            _state.label = 1;
+          case 1:
+            _state.trys.push([
+              1,
+              6,
+              7,
+              8
+            ]);
+            _iterator = callbacks[Symbol.iterator]();
+            _state.label = 2;
+          case 2:
+            if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done))
+              return [
+                3,
+                5
+              ];
+            callback = _step.value;
+            return [
+              4,
+              callback.apply(void 0, _to_consumable_array(params))
+            ];
+          case 3:
+            result = _state.sent();
+            if (result !== void 0) {
+              params[0] = result;
+            }
+            _state.label = 4;
+          case 4:
+            _iteratorNormalCompletion = true;
+            return [
+              3,
+              2
+            ];
+          case 5:
+            return [
+              3,
+              8
+            ];
+          case 6:
+            err = _state.sent();
+            _didIteratorError = true;
+            _iteratorError = err;
+            return [
+              3,
+              8
+            ];
+          case 7:
+            try {
+              if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+              }
+            } finally {
+              if (_didIteratorError) {
+                throw _iteratorError;
+              }
+            }
+            return [
+              7
+            ];
+          case 8:
+            return [
+              2,
+              params[0] || []
+            ];
+        }
+      });
+    });
+    return function call2() {
+      return _ref.apply(this, arguments);
+    };
+  }();
+  return {
+    tap,
+    call
+  };
+}
+function createCollectAsyncHook() {
+  var callbacks = [];
+  var tap = function(cb) {
+    callbacks.push(cb);
+  };
+  var call = function() {
+    var _ref = _async_to_generator(function() {
+      var _len, params, _key, results, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, callback, result, err;
+      var _arguments = arguments;
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            for (_len = _arguments.length, params = new Array(_len), _key = 0; _key < _len; _key++) {
+              params[_key] = _arguments[_key];
+            }
+            results = [];
+            _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+            _state.label = 1;
+          case 1:
+            _state.trys.push([
+              1,
+              6,
+              7,
+              8
+            ]);
+            _iterator = callbacks[Symbol.iterator]();
+            _state.label = 2;
+          case 2:
+            if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done))
+              return [
+                3,
+                5
+              ];
+            callback = _step.value;
+            return [
+              4,
+              callback.apply(void 0, _to_consumable_array(params))
+            ];
+          case 3:
+            result = _state.sent();
+            if (result !== void 0) {
+              params[0] = result;
+              results.push(result);
+            }
+            _state.label = 4;
+          case 4:
+            _iteratorNormalCompletion = true;
+            return [
+              3,
+              2
+            ];
+          case 5:
+            return [
+              3,
+              8
+            ];
+          case 6:
+            err = _state.sent();
+            _didIteratorError = true;
+            _iteratorError = err;
+            return [
+              3,
+              8
+            ];
+          case 7:
+            try {
+              if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+              }
+            } finally {
+              if (_didIteratorError) {
+                throw _iteratorError;
+              }
+            }
+            return [
+              7
+            ];
+          case 8:
+            return [
+              2,
+              results
+            ];
+        }
+      });
+    });
+    return function call2() {
+      return _ref.apply(this, arguments);
+    };
+  }();
+  return {
+    tap,
+    call
+  };
+}
+
+// src/cli/api.ts
+import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
+import { _ as _object_without_properties } from "@swc/helpers/_/_object_without_properties";
+import { merge } from "@modern-js/utils/lodash";
+function initPluginAPI(param) {
+  var context = param.context;
+  var hooks = context.hooks, extendsHooks = context.extendsHooks, plugins = context.plugins;
+  function getAppContext() {
+    if (context) {
+      var hooks2 = context.hooks, config = context.config, normalizedConfig = context.normalizedConfig, pluginAPI = context.pluginAPI, appContext = _object_without_properties(context, [
+        "hooks",
+        "config",
+        "normalizedConfig",
+        "pluginAPI"
+      ]);
+      return appContext;
+    }
+    throw new Error("Cannot access context");
+  }
+  function getConfig() {
+    if (context.config) {
+      return context.config;
+    }
+    throw new Error("Cannot access config");
+  }
+  function getNormalizedConfig() {
+    if (context.normalizedConfig) {
+      return context.normalizedConfig;
+    }
+    throw new Error("Cannot access normalized config");
+  }
+  function getHooks() {
+    return _object_spread({}, context.hooks, context.extendsHooks);
+  }
+  var extendsPluginApi = {};
+  function updateRegistryApi() {
+    plugins.forEach(function(plugin) {
+      var registryApi = plugin.registryApi;
+      if (registryApi) {
+        var apis = registryApi(context, updateAppContext);
+        Object.keys(apis).forEach(function(apiName) {
+          extendsPluginApi[apiName] = apis[apiName];
+        });
+      }
+    });
+  }
+  updateRegistryApi();
+  Object.keys(extendsHooks).forEach(function(hookName) {
+    extendsPluginApi[hookName] = extendsHooks[hookName].tap;
+  });
+  function updateAppContext(updateContext) {
+    context = merge(context, updateContext);
+    updateRegistryApi();
+  }
+  return _object_spread({
+    getAppContext,
+    getConfig,
+    getNormalizedConfig,
+    getHooks,
+    updateAppContext,
+    config: hooks.config.tap,
+    modifyConfig: hooks.modifyConfig.tap,
+    modifyResolvedConfig: hooks.modifyResolvedConfig.tap,
+    modifyRsbuildConfig: hooks.modifyRsbuildConfig.tap,
+    modifyBundlerChain: hooks.modifyBundlerChain.tap,
+    modifyRspackConfig: hooks.modifyRspackConfig.tap,
+    modifyWebpackChain: hooks.modifyWebpackChain.tap,
+    modifyWebpackConfig: hooks.modifyWebpackConfig.tap,
+    modifyHtmlPartials: hooks.modifyHtmlPartials.tap,
+    addCommand: hooks.addCommand.tap,
+    onPrepare: hooks.onPrepare.tap,
+    onWatchFiles: hooks.addWatchFiles.tap,
+    onFileChanged: hooks.onFileChanged.tap,
+    onBeforeRestart: hooks.onBeforeRestart.tap,
+    onBeforeCreateCompiler: hooks.onBeforeCreateCompiler.tap,
+    onAfterCreateCompiler: hooks.onAfterCreateCompiler.tap,
+    onBeforeBuild: hooks.onBeforeBuild.tap,
+    onAfterBuild: hooks.onAfterBuild.tap,
+    onBeforeDev: hooks.onBeforeDev.tap,
+    onAfterDev: hooks.onAfterDev.tap,
+    onBeforeDeploy: hooks.onBeforeDeploy.tap,
+    onAfterDeploy: hooks.onAfterDeploy.tap,
+    onBeforeExit: hooks.onBeforeExit.tap
+  }, extendsPluginApi);
+}
+
+// src/cli/context.ts
+import { _ as _async_to_generator2 } from "@swc/helpers/_/_async_to_generator";
+import { _ as _object_spread2 } from "@swc/helpers/_/_object_spread";
+import { _ as _object_spread_props } from "@swc/helpers/_/_object_spread_props";
+import { _ as _ts_generator2 } from "@swc/helpers/_/_ts_generator";
+import path from "path";
+
+// src/cli/hooks.ts
+function initHooks() {
+  return {
+    /**
+    * add config for this cli plugin
+    */
+    config: createCollectAsyncHook(),
+    /**
+    * @private
+    * modify config for this cli plugin
+    */
+    modifyConfig: createAsyncHook(),
+    /**
+    * modify final config
+    */
+    modifyResolvedConfig: createAsyncHook(),
+    modifyRsbuildConfig: createAsyncHook(),
+    modifyBundlerChain: createAsyncHook(),
+    modifyRspackConfig: createAsyncHook(),
+    modifyWebpackChain: createAsyncHook(),
+    modifyWebpackConfig: createAsyncHook(),
+    modifyHtmlPartials: createAsyncHook(),
+    addCommand: createAsyncHook(),
+    addWatchFiles: createCollectAsyncHook(),
+    onPrepare: createAsyncHook(),
+    onFileChanged: createAsyncHook(),
+    onBeforeRestart: createAsyncHook(),
+    onBeforeCreateCompiler: createAsyncHook(),
+    onAfterCreateCompiler: createAsyncHook(),
+    onBeforeBuild: createAsyncHook(),
+    onAfterBuild: createAsyncHook(),
+    onBeforeDev: createAsyncHook(),
+    onAfterDev: createAsyncHook(),
+    onBeforeDeploy: createAsyncHook(),
+    onAfterDeploy: createAsyncHook(),
+    onBeforeExit: createAsyncHook()
+  };
+}
+
+// src/cli/context.ts
+function initAppContext(params) {
+  var appDirectory = params.appDirectory, _params_srcDir = params.srcDir, srcDir = _params_srcDir === void 0 ? "src" : _params_srcDir, _params_distDir = params.distDir, distDir = _params_distDir === void 0 ? "dist" : _params_distDir;
+  return {
+    packageName: params.packageName,
+    configFile: params.configFile,
+    command: params.command,
+    isProd: process.env.NODE_ENV === "production",
+    appDirectory,
+    srcDirectory: path.resolve(appDirectory, srcDir),
+    distDirectory: path.resolve(appDirectory, distDir),
+    nodeModulesDirectory: path.resolve(appDirectory, "node_modules"),
+    plugins: params.plugins
+  };
+}
+function createContext(_) {
+  return _createContext.apply(this, arguments);
+}
+function _createContext() {
+  _createContext = _async_to_generator2(function(param) {
+    var appContext, config, normalizedConfig, plugins, extendsHooks;
+    return _ts_generator2(this, function(_state) {
+      appContext = param.appContext, config = param.config, normalizedConfig = param.normalizedConfig;
+      plugins = appContext.plugins;
+      extendsHooks = {};
+      plugins.forEach(function(plugin) {
+        var _plugin_registryHooks = plugin.registryHooks, registryHooks = _plugin_registryHooks === void 0 ? {} : _plugin_registryHooks;
+        Object.keys(registryHooks).forEach(function(hookName) {
+          extendsHooks[hookName] = registryHooks[hookName];
+        });
+      });
+      return [
+        2,
+        _object_spread_props(_object_spread2({}, appContext), {
+          hooks: _object_spread2({}, initHooks(), extendsHooks),
+          extendsHooks,
+          config,
+          normalizedConfig
+        })
+      ];
+    });
+  });
+  return _createContext.apply(this, arguments);
+}
+
+// src/cli/run/create.ts
+import { _ as _async_to_generator8 } from "@swc/helpers/_/_async_to_generator";
+import { _ as _instanceof2 } from "@swc/helpers/_/_instanceof";
+import { _ as _to_consumable_array5 } from "@swc/helpers/_/_to_consumable_array";
+import { _ as _ts_generator8 } from "@swc/helpers/_/_ts_generator";
+import { logger as logger4 } from "@modern-js/utils";
+import { program as program2 } from "@modern-js/utils/commander";
+
+// src/cli/run/config/createLoadedConfig.ts
+import { _ as _async_to_generator4 } from "@swc/helpers/_/_async_to_generator";
+import { _ as _object_spread3 } from "@swc/helpers/_/_object_spread";
+import { _ as _ts_generator4 } from "@swc/helpers/_/_ts_generator";
+import { fs as fs2, CONFIG_FILE_EXTENSIONS, chalk, getCommand, getNodeEnv, isDevCommand, isPlainObject, logger as logger2 } from "@modern-js/utils";
+import { mergeWith as mergeWith2 } from "@modern-js/utils/lodash";
+
+// src/cli/run/utils/mergeConfig.ts
+import { _ as _to_consumable_array2 } from "@swc/helpers/_/_to_consumable_array";
+import { _ as _type_of2 } from "@swc/helpers/_/_type_of";
+import { ensureArray, isOverriddenConfigKey } from "@modern-js/utils";
+import { isFunction as isFunction2, mergeWith } from "@modern-js/utils/lodash";
+var mergeConfig = function(configs) {
+  return mergeWith.apply(void 0, [
+    {}
+  ].concat(_to_consumable_array2(configs), [
+    function(target, source, key) {
+      if (key === "designSystem" || key === "tailwindcss" && (typeof source === "undefined" ? "undefined" : _type_of2(source)) === "object") {
+        return mergeWith({}, target !== null && target !== void 0 ? target : {}, source !== null && source !== void 0 ? source : {});
+      }
+      if (isOverriddenConfigKey(key)) {
+        return source !== null && source !== void 0 ? source : target;
+      }
+      if (Array.isArray(target) || Array.isArray(source)) {
+        if (target === void 0) {
+          return source;
+        }
+        if (source === void 0) {
+          return target;
+        }
+        return _to_consumable_array2(ensureArray(target)).concat(_to_consumable_array2(ensureArray(source)));
+      }
+      if (isFunction2(target) || isFunction2(source)) {
+        if (source === void 0) {
+          return target;
+        }
+        if (target === void 0) {
+          return source;
+        }
+        return [
+          target,
+          source
+        ];
+      }
+      return void 0;
+    }
+  ]));
+};
+
+// src/cli/run/config/loadConfig.ts
+import { _ as _async_to_generator3 } from "@swc/helpers/_/_async_to_generator";
+import { _ as _instanceof } from "@swc/helpers/_/_instanceof";
+import { _ as _ts_generator3 } from "@swc/helpers/_/_ts_generator";
+import path2 from "path";
+import { bundleRequire, defaultGetOutputFile } from "@modern-js/node-bundle-require";
+import { fs, CONFIG_CACHE_DIR, globby } from "@modern-js/utils";
+var getPackageConfig = function(appDirectory, packageJsonConfig) {
+  var json = JSON.parse(fs.readFileSync(path2.resolve(appDirectory, "./package.json"), "utf8"));
+  return json[packageJsonConfig];
+};
+var getConfigFilePath = function(appDirectory, configFilePath) {
+  if (path2.isAbsolute(configFilePath)) {
+    return configFilePath;
+  }
+  return path2.resolve(appDirectory, configFilePath);
+};
+var clearFilesOverTime = function() {
+  var _ref = _async_to_generator3(function(targetDir, overtime) {
+    var files, currentTime, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, file, err;
+    return _ts_generator3(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          _state.trys.push([
+            0,
+            2,
+            ,
+            3
+          ]);
+          return [
+            4,
+            globby("".concat(targetDir, "/**/*"), {
+              stats: true,
+              absolute: true
+            })
+          ];
+        case 1:
+          files = _state.sent();
+          currentTime = Date.now();
+          if (files.length > 0) {
+            _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+            try {
+              for (_iterator = files[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+                file = _step.value;
+                if (currentTime - file.stats.birthtimeMs >= overtime * 1e3) {
+                  fs.unlinkSync(file.path);
+                }
+              }
+            } catch (err2) {
+              _didIteratorError = true;
+              _iteratorError = err2;
+            } finally {
+              try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                  _iterator.return();
+                }
+              } finally {
+                if (_didIteratorError) {
+                  throw _iteratorError;
+                }
+              }
+            }
+          }
+          return [
+            3,
+            3
+          ];
+        case 2:
+          err = _state.sent();
+          return [
+            3,
+            3
+          ];
+        case 3:
+          return [
+            2
+          ];
+      }
+    });
+  });
+  return function clearFilesOverTime2(targetDir, overtime) {
+    return _ref.apply(this, arguments);
+  };
+}();
+var bundleRequireWithCatch = function() {
+  var _ref = _async_to_generator3(function(configFile, param) {
+    var appDirectory, mod, e;
+    return _ts_generator3(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          appDirectory = param.appDirectory;
+          _state.label = 1;
+        case 1:
+          _state.trys.push([
+            1,
+            3,
+            ,
+            4
+          ]);
+          return [
+            4,
+            bundleRequire(configFile, {
+              autoClear: false,
+              getOutputFile: function() {
+                var _ref2 = _async_to_generator3(function(filePath) {
+                  var defaultOutputFileName, _, outputPath, timeLimit;
+                  return _ts_generator3(this, function(_state2) {
+                    switch (_state2.label) {
+                      case 0:
+                        _ = path2.basename;
+                        return [
+                          4,
+                          defaultGetOutputFile(filePath)
+                        ];
+                      case 1:
+                        defaultOutputFileName = _.apply(path2, [
+                          _state2.sent()
+                        ]);
+                        outputPath = path2.join(appDirectory, CONFIG_CACHE_DIR);
+                        timeLimit = 10 * 60;
+                        return [
+                          4,
+                          clearFilesOverTime(outputPath, timeLimit)
+                        ];
+                      case 2:
+                        _state2.sent();
+                        return [
+                          2,
+                          path2.join(outputPath, defaultOutputFileName)
+                        ];
+                    }
+                  });
+                });
+                return function(filePath) {
+                  return _ref2.apply(this, arguments);
+                };
+              }()
+            })
+          ];
+        case 2:
+          mod = _state.sent();
+          return [
+            2,
+            mod
+          ];
+        case 3:
+          e = _state.sent();
+          if (_instanceof(e, Error)) {
+            e.message = "Get Error while loading config file: ".concat(configFile, ", please check it and retry.\n").concat(e.message || "");
+          }
+          throw e;
+        case 4:
+          return [
+            2
+          ];
+      }
+    });
+  });
+  return function bundleRequireWithCatch2(configFile, _) {
+    return _ref.apply(this, arguments);
+  };
+}();
+var loadConfig = function() {
+  var _ref = _async_to_generator3(function(appDirectory, configFile, packageJsonConfig, loadedConfig) {
+    var pkgConfig, packageName, config, mod;
+    return _ts_generator3(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          if (packageJsonConfig) {
+            pkgConfig = getPackageConfig(appDirectory, packageJsonConfig);
+          }
+          packageName = __require(path2.resolve(appDirectory, "./package.json")).name;
+          if (!loadedConfig)
+            return [
+              3,
+              1
+            ];
+          config = loadedConfig;
+          return [
+            3,
+            3
+          ];
+        case 1:
+          if (!configFile)
+            return [
+              3,
+              3
+            ];
+          delete __require.cache[configFile];
+          return [
+            4,
+            bundleRequireWithCatch(configFile, {
+              appDirectory
+            })
+          ];
+        case 2:
+          mod = _state.sent();
+          config = mod.default || mod;
+          _state.label = 3;
+        case 3:
+          return [
+            2,
+            {
+              packageName,
+              configFile,
+              config,
+              pkgConfig
+            }
+          ];
+      }
+    });
+  });
+  return function loadConfig2(appDirectory, configFile, packageJsonConfig, loadedConfig) {
+    return _ref.apply(this, arguments);
+  };
+}();
+
+// src/cli/run/config/createLoadedConfig.ts
+function getConfigObject(config) {
+  return _getConfigObject.apply(this, arguments);
+}
+function _getConfigObject() {
+  _getConfigObject = /**
+  * A modern config can export a function or an object
+  * If it's a function, it will be called and return a config object
+  */
+  _async_to_generator4(function(config) {
+    return _ts_generator4(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          if (!(typeof config === "function"))
+            return [
+              3,
+              2
+            ];
+          return [
+            4,
+            config({
+              env: getNodeEnv(),
+              command: getCommand()
+            })
+          ];
+        case 1:
+          return [
+            2,
+            _state.sent() || {}
+          ];
+        case 2:
+          return [
+            2,
+            config || {}
+          ];
+      }
+    });
+  });
+  return _getConfigObject.apply(this, arguments);
+}
+function loadLocalConfig(appDirectory, configFile) {
+  return _loadLocalConfig.apply(this, arguments);
+}
+function _loadLocalConfig() {
+  _loadLocalConfig = _async_to_generator4(function(appDirectory, configFile) {
+    var localConfigFile, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, ext, replacedPath, loaded;
+    return _ts_generator4(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          localConfigFile = false;
+          if (typeof configFile === "string") {
+            _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+            try {
+              for (_iterator = CONFIG_FILE_EXTENSIONS[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+                ext = _step.value;
+                if (configFile.endsWith(ext)) {
+                  replacedPath = configFile.replace(ext, ".local".concat(ext));
+                  if (fs2.existsSync(replacedPath)) {
+                    localConfigFile = replacedPath;
+                  }
+                }
+              }
+            } catch (err) {
+              _didIteratorError = true;
+              _iteratorError = err;
+            } finally {
+              try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                  _iterator.return();
+                }
+              } finally {
+                if (_didIteratorError) {
+                  throw _iteratorError;
+                }
+              }
+            }
+          }
+          if (!localConfigFile)
+            return [
+              3,
+              2
+            ];
+          return [
+            4,
+            loadConfig(appDirectory, localConfigFile)
+          ];
+        case 1:
+          loaded = _state.sent();
+          return [
+            2,
+            getConfigObject(loaded.config)
+          ];
+        case 2:
+          return [
+            2,
+            null
+          ];
+      }
+    });
+  });
+  return _loadLocalConfig.apply(this, arguments);
+}
+function assignPkgConfig(userConfig, pkgConfig) {
+  return mergeWith2({}, userConfig, pkgConfig, function(objValue, srcValue) {
+    if (objValue === void 0 && isPlainObject(srcValue)) {
+      return _object_spread3({}, srcValue);
+    }
+    return void 0;
+  });
+}
+function createLoadedConfig(appDirectory, configFilePath, packageJsonConfig, loadedConfig) {
+  return _createLoadedConfig.apply(this, arguments);
+}
+function _createLoadedConfig() {
+  _createLoadedConfig = _async_to_generator4(function(appDirectory, configFilePath, packageJsonConfig, loadedConfig) {
+    var configFile, loaded, config, mergedConfig, localConfig;
+    return _ts_generator4(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          configFile = getConfigFilePath(appDirectory, configFilePath);
+          return [
+            4,
+            loadConfig(appDirectory, configFile, packageJsonConfig, loadedConfig)
+          ];
+        case 1:
+          loaded = _state.sent();
+          if (!loaded.config && !loaded.pkgConfig) {
+            logger2.warn("Can not find any config file in the current project, please check if you have a correct config file.");
+            logger2.warn("Current project path: ".concat(chalk.yellow(appDirectory)));
+          }
+          return [
+            4,
+            getConfigObject(loaded.config)
+          ];
+        case 2:
+          config = _state.sent();
+          mergedConfig = config;
+          if (loaded.pkgConfig) {
+            mergedConfig = assignPkgConfig(config, loaded === null || loaded === void 0 ? void 0 : loaded.pkgConfig);
+          }
+          if (!isDevCommand())
+            return [
+              3,
+              4
+            ];
+          return [
+            4,
+            loadLocalConfig(appDirectory, configFile)
+          ];
+        case 3:
+          localConfig = _state.sent();
+          if (localConfig) {
+            mergedConfig = mergeConfig([
+              mergedConfig,
+              localConfig
+            ]);
+          }
+          _state.label = 4;
+        case 4:
+          return [
+            2,
+            {
+              packageName: loaded.packageName,
+              config: mergedConfig,
+              configFile: loaded.configFile,
+              pkgConfig: loaded.pkgConfig,
+              jsConfig: loaded.config
+            }
+          ];
+      }
+    });
+  });
+  return _createLoadedConfig.apply(this, arguments);
+}
+
+// src/cli/run/config/createResolvedConfig.ts
+import { _ as _async_to_generator5 } from "@swc/helpers/_/_async_to_generator";
+import { _ as _to_consumable_array3 } from "@swc/helpers/_/_to_consumable_array";
+import { _ as _ts_generator5 } from "@swc/helpers/_/_ts_generator";
+import { createDebugger as createDebugger2 } from "@modern-js/utils";
+var debug2 = createDebugger2("resolve-config");
+var createResolveConfig = function() {
+  var _ref = _async_to_generator5(function(loaded, configs) {
+    var userConfig, resolved;
+    return _ts_generator5(this, function(_state) {
+      userConfig = loaded.config;
+      resolved = mergeConfig([
+        {}
+      ].concat(_to_consumable_array3(configs), [
+        userConfig
+      ]));
+      debug2("resolved %o", resolved);
+      return [
+        2,
+        resolved
+      ];
+    });
+  });
+  return function createResolveConfig2(loaded, configs) {
+    return _ref.apply(this, arguments);
+  };
+}();
+
+// src/cli/run/utils/checkIsDuplicationPlugin.ts
+import { logger as logger3 } from "@modern-js/utils";
+function checkIsDuplicationPlugin(plugins) {
+  var autoLoadPlugin = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
+  var set = /* @__PURE__ */ new Set();
+  var duplicationPlugins = [];
+  plugins.filter(function(plugin) {
+    return typeof plugin === "string";
+  }).forEach(function(plugin) {
+    if (set.has(plugin)) {
+      duplicationPlugins.push(plugin);
+    } else {
+      set.add(plugin);
+    }
+  });
+  if (duplicationPlugins.length > 0) {
+    logger3.warn("Duplicate registration plugins: ".concat(duplicationPlugins.join(","), "."));
+    if (autoLoadPlugin) {
+      logger3.warn("This is probably because you enabled `autoLoadPlugin` configuration and also registered these plugins manually");
+    }
+  }
+}
+
+// src/cli/run/utils/commander.ts
+import { program } from "@modern-js/utils";
+var setProgramVersion = function() {
+  var version = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : "unknown";
+  var name = process.argv[1];
+  program.name(name).usage("<command> [options]").version(version);
+};
+function initCommandsMap() {
+  if (!program.hasOwnProperty("commandsMap")) {
+    Object.defineProperty(program, "commandsMap", {
+      get: function get() {
+        var map = /* @__PURE__ */ new Map();
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+        try {
+          for (var _iterator = program.commands[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+            var command = _step.value;
+            map.set(command._name, command);
+          }
+        } catch (err) {
+          _didIteratorError = true;
+          _iteratorError = err;
+        } finally {
+          try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+              _iterator.return();
+            }
+          } finally {
+            if (_didIteratorError) {
+              throw _iteratorError;
+            }
+          }
+        }
+        return map;
+      },
+      configurable: false
+    });
+  }
+}
+
+// src/cli/run/utils/createFileWatcher.ts
+import { _ as _async_to_generator6 } from "@swc/helpers/_/_async_to_generator";
+import { _ as _to_consumable_array4 } from "@swc/helpers/_/_to_consumable_array";
+import { _ as _ts_generator6 } from "@swc/helpers/_/_ts_generator";
+import crypto from "crypto";
+import * as fs3 from "fs";
+import * as path3 from "path";
+import { chokidar, createDebugger as createDebugger3, isDevCommand as isDevCommand2 } from "@modern-js/utils";
+var debug3 = createDebugger3("watch-files");
+var hashMap = /* @__PURE__ */ new Map();
+var md5 = function(data) {
+  return crypto.createHash("md5").update(data).digest("hex");
+};
+var createFileWatcher = function() {
+  var _ref = _async_to_generator6(function(appContext) {
+    var appDirectory, extraFiles, watched, privateWatched, isPrivate, watcher;
+    return _ts_generator6(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          if (!isDevCommand2())
+            return [
+              3,
+              2
+            ];
+          appDirectory = appContext.appDirectory;
+          return [
+            4,
+            appContext.hooks.addWatchFiles.call()
+          ];
+        case 1:
+          extraFiles = _state.sent();
+          watched = extraFiles.filter(function(extra) {
+            return Array.isArray(extra);
+          }).flat();
+          privateWatched = extraFiles.filter(function(extra) {
+            return !Array.isArray(extra) && extra.isPrivate;
+          }).map(function(extra) {
+            return extra.files;
+          }).flat();
+          isPrivate = function(filename) {
+            return privateWatched.some(function(ff) {
+              return path3.resolve(appDirectory, filename).startsWith(ff);
+            });
+          };
+          debug3("watched: %o", watched);
+          watcher = chokidar.watch(_to_consumable_array4(watched).concat(_to_consumable_array4(privateWatched)), {
+            cwd: appDirectory,
+            ignoreInitial: true,
+            ignorePermissionErrors: true,
+            ignored: [
+              "**/__test__/**",
+              "**/*.test.(js|jsx|ts|tsx)",
+              "**/*.spec.(js|jsx|ts|tsx)",
+              "**/*.stories.(js|jsx|ts|tsx)"
+            ]
+          });
+          watcher.on("change", function(changed) {
+            var lastHash = hashMap.get(changed);
+            var currentHash = md5(fs3.readFileSync(path3.join(appDirectory, changed), "utf8"));
+            if (currentHash !== lastHash) {
+              debug3("file change: %s", changed);
+              hashMap.set(changed, currentHash);
+              appContext.hooks.onFileChanged.call({
+                filename: changed,
+                eventType: "change",
+                isPrivate: isPrivate(changed)
+              });
+            }
+          });
+          watcher.on("add", function(changed) {
+            debug3("add file: %s", changed);
+            var currentHash = md5(fs3.readFileSync(path3.join(appDirectory, changed), "utf8"));
+            hashMap.set(changed, currentHash);
+            appContext.hooks.onFileChanged.call({
+              filename: changed,
+              eventType: "add",
+              isPrivate: isPrivate(changed)
+            });
+          });
+          watcher.on("unlink", function(changed) {
+            debug3("remove file: %s", changed);
+            if (hashMap.has(changed)) {
+              hashMap.delete(changed);
+            }
+            appContext.hooks.onFileChanged.call({
+              filename: changed,
+              eventType: "unlink",
+              isPrivate: isPrivate(changed)
+            });
+          });
+          watcher.on("error", function(err) {
+            throw err;
+          });
+          return [
+            2,
+            watcher
+          ];
+        case 2:
+          return [
+            2
+          ];
+      }
+    });
+  });
+  return function createFileWatcher2(appContext) {
+    return _ref.apply(this, arguments);
+  };
+}();
+
+// src/cli/run/utils/initAppDir.ts
+import { _ as _async_to_generator7 } from "@swc/helpers/_/_async_to_generator";
+import { _ as _ts_generator7 } from "@swc/helpers/_/_ts_generator";
+import path4 from "path";
+import { pkgUp } from "@modern-js/utils";
+var initAppDir = function() {
+  var _ref = _async_to_generator7(function(currentDir) {
+    var cwd, pkg;
+    return _ts_generator7(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          cwd = currentDir || process.cwd();
+          return [
+            4,
+            pkgUp({
+              cwd
+            })
+          ];
+        case 1:
+          pkg = _state.sent();
+          if (!pkg) {
+            throw new Error("no package.json found in current work dir: ".concat(cwd));
+          }
+          return [
+            2,
+            path4.dirname(pkg)
+          ];
+      }
+    });
+  });
+  return function initAppDir2(currentDir) {
+    return _ref.apply(this, arguments);
+  };
+}();
+
+// src/cli/run/utils/loadEnv.ts
+import fs4 from "fs";
+import path5 from "path";
+import { dotenv, dotenvExpand } from "@modern-js/utils";
+var loadEnv = function(appDirectory) {
+  var mode = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : process.env.NODE_ENV;
+  [
+    ".env.".concat(mode, ".local"),
+    ".env.local",
+    ".env.".concat(mode),
+    ".env"
+  ].map(function(name) {
+    return path5.resolve(appDirectory, name);
+  }).filter(function(filePath) {
+    return fs4.existsSync(filePath) && !fs4.statSync(filePath).isDirectory();
+  }).forEach(function(filePath) {
+    var envConfig = dotenv.config({
+      path: filePath
+    });
+    dotenvExpand(envConfig);
+  });
+};
+
+// src/cli/run/create.ts
+var createCli = function() {
+  var init = function init2(options) {
+    return _init.apply(this, arguments);
+  };
+  var run = function run2(options) {
+    return _run.apply(this, arguments);
+  };
+  var pluginManager = createPluginManager();
+  function _init() {
+    _init = _async_to_generator8(function(options) {
+      var _options_metaName, metaName, configFile, command, version, packageJsonConfig, loadedConfig, internalPlugins, handleSetupResult, appDirectory, loaded, allPlugins, plugins, context, pluginAPI, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, plugin, setupResult, err, extraConfigs, normalizedConfig, resolved;
+      return _ts_generator8(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            _options_metaName = options.metaName, metaName = _options_metaName === void 0 ? "MODERN" : _options_metaName, configFile = options.configFile, command = options.command, version = options.version, packageJsonConfig = options.packageJsonConfig, loadedConfig = options.loadedConfig, internalPlugins = options.internalPlugins, handleSetupResult = options.handleSetupResult;
+            return [
+              4,
+              initAppDir(options === null || options === void 0 ? void 0 : options.cwd)
+            ];
+          case 1:
+            appDirectory = _state.sent();
+            initCommandsMap();
+            setProgramVersion(version);
+            loadEnv(appDirectory, process.env["".concat(metaName.toUpperCase(), "_ENV")]);
+            return [
+              4,
+              createLoadedConfig(appDirectory, configFile, packageJsonConfig, loadedConfig)
+            ];
+          case 2:
+            loaded = _state.sent();
+            allPlugins = _to_consumable_array5(internalPlugins || []).concat(_to_consumable_array5(loaded.config.plugins || []));
+            checkIsDuplicationPlugin(allPlugins.map(function(plugin2) {
+              return plugin2.name;
+            }), loaded.config.autoLoadPlugins);
+            pluginManager.addPlugins(allPlugins);
+            return [
+              4,
+              pluginManager.getPlugins()
+            ];
+          case 3:
+            plugins = _state.sent();
+            return [
+              4,
+              createContext({
+                appContext: initAppContext({
+                  packageName: loaded.packageName,
+                  configFile: loaded.configFile,
+                  command,
+                  appDirectory,
+                  plugins
+                }),
+                config: loaded.config,
+                normalizedConfig: {}
+              })
+            ];
+          case 4:
+            context = _state.sent();
+            pluginAPI = initPluginAPI({
+              context,
+              pluginManager
+            });
+            context.pluginAPI = pluginAPI;
+            _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+            _state.label = 5;
+          case 5:
+            _state.trys.push([
+              5,
+              11,
+              12,
+              13
+            ]);
+            _iterator = plugins[Symbol.iterator]();
+            _state.label = 6;
+          case 6:
+            if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done))
+              return [
+                3,
+                10
+              ];
+            plugin = _step.value;
+            return [
+              4,
+              plugin.setup(pluginAPI)
+            ];
+          case 7:
+            setupResult = _state.sent();
+            if (!handleSetupResult)
+              return [
+                3,
+                9
+              ];
+            return [
+              4,
+              handleSetupResult(setupResult, pluginAPI)
+            ];
+          case 8:
+            _state.sent();
+            _state.label = 9;
+          case 9:
+            _iteratorNormalCompletion = true;
+            return [
+              3,
+              6
+            ];
+          case 10:
+            return [
+              3,
+              13
+            ];
+          case 11:
+            err = _state.sent();
+            _didIteratorError = true;
+            _iteratorError = err;
+            return [
+              3,
+              13
+            ];
+          case 12:
+            try {
+              if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+              }
+            } finally {
+              if (_didIteratorError) {
+                throw _iteratorError;
+              }
+            }
+            return [
+              7
+            ];
+          case 13:
+            [
+              "SIGINT",
+              "SIGTERM",
+              "unhandledRejection",
+              "uncaughtException"
+            ].forEach(function(event) {
+              process.on(event, function() {
+                var _ref = _async_to_generator8(function(err2) {
+                  var hasError;
+                  return _ts_generator8(this, function(_state2) {
+                    switch (_state2.label) {
+                      case 0:
+                        return [
+                          4,
+                          context.hooks.onBeforeExit.call()
+                        ];
+                      case 1:
+                        _state2.sent();
+                        hasError = false;
+                        if (_instanceof2(err2, Error)) {
+                          logger4.error(err2.stack);
+                          hasError = true;
+                        } else if (err2 && (event === "unhandledRejection" || event === "uncaughtException")) {
+                          console.trace("Unknown Error", err2);
+                          hasError = true;
+                        }
+                        process.nextTick(function() {
+                          process.exit(hasError ? 1 : 0);
+                        });
+                        return [
+                          2
+                        ];
+                    }
+                  });
+                });
+                return function(err2) {
+                  return _ref.apply(this, arguments);
+                };
+              }());
+            });
+            return [
+              4,
+              context.hooks.config.call()
+            ];
+          case 14:
+            extraConfigs = _state.sent();
+            return [
+              4,
+              createResolveConfig(loaded, extraConfigs)
+            ];
+          case 15:
+            normalizedConfig = _state.sent();
+            return [
+              4,
+              context.hooks.modifyResolvedConfig.call(normalizedConfig)
+            ];
+          case 16:
+            resolved = _state.sent();
+            context.normalizedConfig = resolved[0] || normalizedConfig;
+            return [
+              4,
+              pluginAPI.updateAppContext(context)
+            ];
+          case 17:
+            _state.sent();
+            return [
+              4,
+              context.hooks.onPrepare.call()
+            ];
+          case 18:
+            _state.sent();
+            return [
+              2,
+              {
+                appContext: context
+              }
+            ];
+        }
+      });
+    });
+    return _init.apply(this, arguments);
+  }
+  function _run() {
+    _run = _async_to_generator8(function(options) {
+      var _program_commands, appContext;
+      return _ts_generator8(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            return [
+              4,
+              init(options)
+            ];
+          case 1:
+            appContext = _state.sent().appContext;
+            return [
+              4,
+              appContext.hooks.addCommand.call({
+                program: program2
+              })
+            ];
+          case 2:
+            _state.sent();
+            return [
+              4,
+              createFileWatcher(appContext)
+            ];
+          case 3:
+            _state.sent();
+            program2.parse(process.argv);
+            if (!((_program_commands = program2.commands) === null || _program_commands === void 0 ? void 0 : _program_commands.length)) {
+              logger4.warn("No command found, please make sure you have registered plugins correctly.");
+            }
+            return [
+              2
+            ];
+        }
+      });
+    });
+    return _run.apply(this, arguments);
+  }
+  return {
+    init,
+    run
+  };
+};
+
+// src/cli/run/index.ts
+var cli = createCli();
+export {
+  cli,
+  createAsyncHook,
+  createCollectAsyncHook,
+  createLoadedConfig,
+  createPluginManager,
+  initAppContext,
+  initAppDir,
+  initHooks,
+  initPluginAPI
+};