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

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021-present Modern.js
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,26 @@
+<p align="center">
+  <a href="https://modernjs.dev" target="blank"><img src="https://lf3-static.bytednsdoc.com/obj/eden-cn/ylaelkeh7nuhfnuhf/modernjs-cover.png" width="300" alt="Modern.js Logo" /></a>
+</p>
+
+<h1 align="center">Modern.js</h1>
+
+<p align="center">
+  A Progressive React Framework for modern web development.
+</p>
+
+## Getting Started
+
+Please follow [Quick Start](https://modernjs.dev/en/guides/get-started/quick-start) to get started with Modern.js.
+
+## Documentation
+
+- [English Documentation](https://modernjs.dev/en/)
+- [中文文档](https://modernjs.dev)
+
+## Contributing
+
+Please read the [Contributing Guide](https://github.com/web-infra-dev/modern.js/blob/main/CONTRIBUTING.md).
+
+## License
+
+Modern.js is [MIT licensed](https://github.com/web-infra-dev/modern.js/blob/main/LICENSE).

package/dist/cjs/cli/api.js

@@ -0,0 +1,107 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var api_exports = {};
+__export(api_exports, {
+  initPluginAPI: () => initPluginAPI
+});
+module.exports = __toCommonJS(api_exports);
+var import_lodash = require("@modern-js/utils/lodash");
+function initPluginAPI({ context }) {
+  const { hooks, extendsHooks, plugins } = context;
+  function getAppContext() {
+    if (context) {
+      const { hooks: hooks2, config, normalizedConfig, pluginAPI, ...appContext } = context;
+      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 {
+      ...context.hooks,
+      ...context.extendsHooks
+    };
+  }
+  const extendsPluginApi = {};
+  function updateRegistryApi() {
+    plugins.forEach((plugin) => {
+      const { registryApi } = plugin;
+      if (registryApi) {
+        const apis = registryApi(context, updateAppContext);
+        Object.keys(apis).forEach((apiName) => {
+          extendsPluginApi[apiName] = apis[apiName];
+        });
+      }
+    });
+  }
+  updateRegistryApi();
+  Object.keys(extendsHooks).forEach((hookName) => {
+    extendsPluginApi[hookName] = extendsHooks[hookName].tap;
+  });
+  function updateAppContext(updateContext) {
+    context = (0, import_lodash.merge)(context, updateContext);
+    updateRegistryApi();
+  }
+  return {
+    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
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  initPluginAPI
+});

package/dist/cjs/cli/context.js

@@ -0,0 +1,75 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var context_exports = {};
+__export(context_exports, {
+  createContext: () => createContext,
+  initAppContext: () => initAppContext
+});
+module.exports = __toCommonJS(context_exports);
+var import_path = __toESM(require("path"));
+var import_hooks = require("./hooks");
+function initAppContext(params) {
+  const { appDirectory, srcDir = "src", distDir = "dist" } = params;
+  return {
+    packageName: params.packageName,
+    configFile: params.configFile,
+    command: params.command,
+    isProd: process.env.NODE_ENV === "production",
+    appDirectory,
+    srcDirectory: import_path.default.resolve(appDirectory, srcDir),
+    distDirectory: import_path.default.resolve(appDirectory, distDir),
+    nodeModulesDirectory: import_path.default.resolve(appDirectory, "node_modules"),
+    plugins: params.plugins
+  };
+}
+async function createContext({ appContext, config, normalizedConfig }) {
+  const { plugins } = appContext;
+  const extendsHooks = {};
+  plugins.forEach((plugin) => {
+    const { registryHooks = {} } = plugin;
+    Object.keys(registryHooks).forEach((hookName) => {
+      extendsHooks[hookName] = registryHooks[hookName];
+    });
+  });
+  return {
+    ...appContext,
+    hooks: {
+      ...(0, import_hooks.initHooks)(),
+      ...extendsHooks
+    },
+    extendsHooks,
+    config,
+    normalizedConfig
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createContext,
+  initAppContext
+});

package/dist/cjs/cli/hooks.js

@@ -0,0 +1,65 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var hooks_exports = {};
+__export(hooks_exports, {
+  initHooks: () => initHooks
+});
+module.exports = __toCommonJS(hooks_exports);
+var import_hooks = require("../hooks");
+function initHooks() {
+  return {
+    /**
+    * add config for this cli plugin
+    */
+    config: (0, import_hooks.createCollectAsyncHook)(),
+    /**
+    * @private
+    * modify config for this cli plugin
+    */
+    modifyConfig: (0, import_hooks.createAsyncHook)(),
+    /**
+    * modify final config
+    */
+    modifyResolvedConfig: (0, import_hooks.createAsyncHook)(),
+    modifyRsbuildConfig: (0, import_hooks.createAsyncHook)(),
+    modifyBundlerChain: (0, import_hooks.createAsyncHook)(),
+    modifyRspackConfig: (0, import_hooks.createAsyncHook)(),
+    modifyWebpackChain: (0, import_hooks.createAsyncHook)(),
+    modifyWebpackConfig: (0, import_hooks.createAsyncHook)(),
+    modifyHtmlPartials: (0, import_hooks.createAsyncHook)(),
+    addCommand: (0, import_hooks.createAsyncHook)(),
+    addWatchFiles: (0, import_hooks.createCollectAsyncHook)(),
+    onPrepare: (0, import_hooks.createAsyncHook)(),
+    onFileChanged: (0, import_hooks.createAsyncHook)(),
+    onBeforeRestart: (0, import_hooks.createAsyncHook)(),
+    onBeforeCreateCompiler: (0, import_hooks.createAsyncHook)(),
+    onAfterCreateCompiler: (0, import_hooks.createAsyncHook)(),
+    onBeforeBuild: (0, import_hooks.createAsyncHook)(),
+    onAfterBuild: (0, import_hooks.createAsyncHook)(),
+    onBeforeDev: (0, import_hooks.createAsyncHook)(),
+    onAfterDev: (0, import_hooks.createAsyncHook)(),
+    onBeforeDeploy: (0, import_hooks.createAsyncHook)(),
+    onAfterDeploy: (0, import_hooks.createAsyncHook)(),
+    onBeforeExit: (0, import_hooks.createAsyncHook)()
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  initHooks
+});

package/dist/cjs/cli/index.js

@@ -0,0 +1,43 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var cli_exports = {};
+__export(cli_exports, {
+  cli: () => import_run.cli,
+  createLoadedConfig: () => import_createLoadedConfig.createLoadedConfig,
+  initAppContext: () => import_context.initAppContext,
+  initAppDir: () => import_initAppDir.initAppDir,
+  initHooks: () => import_hooks.initHooks,
+  initPluginAPI: () => import_api.initPluginAPI
+});
+module.exports = __toCommonJS(cli_exports);
+var import_api = require("./api");
+var import_context = require("./context");
+var import_hooks = require("./hooks");
+var import_run = require("./run");
+var import_initAppDir = require("./run/utils/initAppDir");
+var import_createLoadedConfig = require("../cli/run/config/createLoadedConfig");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cli,
+  createLoadedConfig,
+  initAppContext,
+  initAppDir,
+  initHooks,
+  initPluginAPI
+});

package/dist/cjs/cli/run/config/createLoadedConfig.js

@@ -0,0 +1,99 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var createLoadedConfig_exports = {};
+__export(createLoadedConfig_exports, {
+  assignPkgConfig: () => assignPkgConfig,
+  createLoadedConfig: () => createLoadedConfig
+});
+module.exports = __toCommonJS(createLoadedConfig_exports);
+var import_utils = require("@modern-js/utils");
+var import_lodash = require("@modern-js/utils/lodash");
+var import_mergeConfig = require("../utils/mergeConfig");
+var import_loadConfig = require("./loadConfig");
+async function getConfigObject(config) {
+  if (typeof config === "function") {
+    return await config({
+      env: (0, import_utils.getNodeEnv)(),
+      command: (0, import_utils.getCommand)()
+    }) || {};
+  }
+  return config || {};
+}
+async function loadLocalConfig(appDirectory, configFile) {
+  let localConfigFile = false;
+  if (typeof configFile === "string") {
+    for (const ext of import_utils.CONFIG_FILE_EXTENSIONS) {
+      if (configFile.endsWith(ext)) {
+        const replacedPath = configFile.replace(ext, `.local${ext}`);
+        if (import_utils.fs.existsSync(replacedPath)) {
+          localConfigFile = replacedPath;
+        }
+      }
+    }
+  }
+  if (localConfigFile) {
+    const loaded = await (0, import_loadConfig.loadConfig)(appDirectory, localConfigFile);
+    return getConfigObject(loaded.config);
+  }
+  return null;
+}
+function assignPkgConfig(userConfig, pkgConfig) {
+  return (0, import_lodash.mergeWith)({}, userConfig, pkgConfig, (objValue, srcValue) => {
+    if (objValue === void 0 && (0, import_utils.isPlainObject)(srcValue)) {
+      return {
+        ...srcValue
+      };
+    }
+    return void 0;
+  });
+}
+async function createLoadedConfig(appDirectory, configFilePath, packageJsonConfig, loadedConfig) {
+  const configFile = (0, import_loadConfig.getConfigFilePath)(appDirectory, configFilePath);
+  const loaded = await (0, import_loadConfig.loadConfig)(appDirectory, configFile, packageJsonConfig, loadedConfig);
+  if (!loaded.config && !loaded.pkgConfig) {
+    import_utils.logger.warn(`Can not find any config file in the current project, please check if you have a correct config file.`);
+    import_utils.logger.warn(`Current project path: ${import_utils.chalk.yellow(appDirectory)}`);
+  }
+  const config = await getConfigObject(loaded.config);
+  let mergedConfig = config;
+  if (loaded.pkgConfig) {
+    mergedConfig = assignPkgConfig(config, loaded === null || loaded === void 0 ? void 0 : loaded.pkgConfig);
+  }
+  if ((0, import_utils.isDevCommand)()) {
+    const localConfig = await loadLocalConfig(appDirectory, configFile);
+    if (localConfig) {
+      mergedConfig = (0, import_mergeConfig.mergeConfig)([
+        mergedConfig,
+        localConfig
+      ]);
+    }
+  }
+  return {
+    packageName: loaded.packageName,
+    config: mergedConfig,
+    configFile: loaded.configFile,
+    pkgConfig: loaded.pkgConfig,
+    jsConfig: loaded.config
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  assignPkgConfig,
+  createLoadedConfig
+});

package/dist/cjs/cli/run/config/createResolvedConfig.js

@@ -0,0 +1,40 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var createResolvedConfig_exports = {};
+__export(createResolvedConfig_exports, {
+  createResolveConfig: () => createResolveConfig
+});
+module.exports = __toCommonJS(createResolvedConfig_exports);
+var import_utils = require("@modern-js/utils");
+var import_mergeConfig = require("../utils/mergeConfig");
+const debug = (0, import_utils.createDebugger)("resolve-config");
+const createResolveConfig = async (loaded, configs) => {
+  const { config: userConfig } = loaded;
+  const resolved = (0, import_mergeConfig.mergeConfig)([
+    {},
+    ...configs,
+    userConfig
+  ]);
+  debug("resolved %o", resolved);
+  return resolved;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createResolveConfig
+});

package/dist/cjs/cli/run/config/loadConfig.js

@@ -0,0 +1,117 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var loadConfig_exports = {};
+__export(loadConfig_exports, {
+  clearFilesOverTime: () => clearFilesOverTime,
+  getConfigFilePath: () => getConfigFilePath,
+  getPackageConfig: () => getPackageConfig,
+  loadConfig: () => loadConfig
+});
+module.exports = __toCommonJS(loadConfig_exports);
+var import_path = __toESM(require("path"));
+var import_node_bundle_require = require("@modern-js/node-bundle-require");
+var import_utils = require("@modern-js/utils");
+const getPackageConfig = (appDirectory, packageJsonConfig) => {
+  const json = JSON.parse(import_utils.fs.readFileSync(import_path.default.resolve(appDirectory, "./package.json"), "utf8"));
+  return json[packageJsonConfig];
+};
+const getConfigFilePath = (appDirectory, configFilePath) => {
+  if (import_path.default.isAbsolute(configFilePath)) {
+    return configFilePath;
+  }
+  return import_path.default.resolve(appDirectory, configFilePath);
+};
+const clearFilesOverTime = async (targetDir, overtime) => {
+  try {
+    const files = await (0, import_utils.globby)(`${targetDir}/**/*`, {
+      stats: true,
+      absolute: true
+    });
+    const currentTime = Date.now();
+    if (files.length > 0) {
+      for (const file of files) {
+        if (currentTime - file.stats.birthtimeMs >= overtime * 1e3) {
+          import_utils.fs.unlinkSync(file.path);
+        }
+      }
+    }
+  } catch (err) {
+  }
+};
+const bundleRequireWithCatch = async (configFile, { appDirectory }) => {
+  try {
+    const mod = await (0, import_node_bundle_require.bundleRequire)(configFile, {
+      autoClear: false,
+      getOutputFile: async (filePath) => {
+        const defaultOutputFileName = import_path.default.basename(await (0, import_node_bundle_require.defaultGetOutputFile)(filePath));
+        const outputPath = import_path.default.join(appDirectory, import_utils.CONFIG_CACHE_DIR);
+        const timeLimit = 10 * 60;
+        await clearFilesOverTime(outputPath, timeLimit);
+        return import_path.default.join(outputPath, defaultOutputFileName);
+      }
+    });
+    return mod;
+  } catch (e) {
+    if (e instanceof Error) {
+      e.message = `Get Error while loading config file: ${configFile}, please check it and retry.
+${e.message || ""}`;
+    }
+    throw e;
+  }
+};
+const loadConfig = async (appDirectory, configFile, packageJsonConfig, loadedConfig) => {
+  let pkgConfig;
+  if (packageJsonConfig) {
+    pkgConfig = getPackageConfig(appDirectory, packageJsonConfig);
+  }
+  const packageName = require(import_path.default.resolve(appDirectory, "./package.json")).name;
+  let config;
+  if (loadedConfig) {
+    config = loadedConfig;
+  } else if (configFile) {
+    delete require.cache[configFile];
+    const mod = await bundleRequireWithCatch(configFile, {
+      appDirectory
+    });
+    config = mod.default || mod;
+  }
+  return {
+    packageName,
+    configFile,
+    config,
+    pkgConfig
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  clearFilesOverTime,
+  getConfigFilePath,
+  getPackageConfig,
+  loadConfig
+});