@modern-js/core 2.35.0 → 2.36.0

package/dist/bin.js

@@ -1,7 +1,4 @@
 #!/usr/bin/env node
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-const _runBin = require("./runBin");
-(0, _runBin.run)();
+var import_runBin = require("./runBin");
+(0, import_runBin.run)();

package/dist/config/createDefaultConfig.js

@@ -1,15 +1,32 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "createDefaultConfig", {
-  enumerable: true,
-  get: function() {
-    return createDefaultConfig;
+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 createDefaultConfig_exports = {};
+__export(createDefaultConfig_exports, {
+  createDefaultConfig: () => createDefaultConfig
 });
+module.exports = __toCommonJS(createDefaultConfig_exports);
 function createDefaultConfig() {
   return {
     autoLoadPlugins: false
   };
 }
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createDefaultConfig
+});

package/dist/config/createLoadedConfig.js

@@ -1,30 +1,44 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-function _export(target, all) {
+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)
-    Object.defineProperty(target, name, {
-      enumerable: true,
-      get: all[name]
-    });
-}
-_export(exports, {
-  assignPkgConfig: function() {
-    return assignPkgConfig;
-  },
-  createLoadedConfig: function() {
-    return createLoadedConfig;
+    __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 createLoadedConfig_exports = {};
+__export(createLoadedConfig_exports, {
+  assignPkgConfig: () => assignPkgConfig,
+  createLoadedConfig: () => createLoadedConfig
 });
-const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
-const _path = /* @__PURE__ */ _interop_require_default._(require("path"));
-const _lodash = require("@modern-js/utils/lodash");
-const _utils = require("@modern-js/utils");
-const _utils1 = require("../utils");
-const _loadConfig = require("./loadConfig");
-const assignPkgConfig = (userConfig = {}, pkgConfig = {}) => (0, _lodash.mergeWith)({}, userConfig, pkgConfig, (objValue, srcValue) => {
-  if (objValue === void 0 && (0, _utils.isPlainObject)(srcValue)) {
+module.exports = __toCommonJS(createLoadedConfig_exports);
+var import_path = __toESM(require("path"));
+var import_lodash = require("@modern-js/utils/lodash");
+var import_utils = require("@modern-js/utils");
+var import_utils2 = require("../utils");
+var import_loadConfig = require("./loadConfig");
+const assignPkgConfig = (userConfig = {}, pkgConfig = {}) => (0, import_lodash.mergeWith)({}, userConfig, pkgConfig, (objValue, srcValue) => {
+  if (objValue === void 0 && (0, import_utils.isPlainObject)(srcValue)) {
     return {
       ...srcValue
     };
@@ -34,8 +48,8 @@ const assignPkgConfig = (userConfig = {}, pkgConfig = {}) => (0, _lodash.mergeWi
 async function getConfigObject(config) {
   if (typeof config === "function") {
     return await config({
-      env: (0, _utils.getNodeEnv)(),
-      command: (0, _utils.getCommand)()
+      env: (0, import_utils.getNodeEnv)(),
+      command: (0, import_utils.getCommand)()
     }) || {};
   }
   return config || {};
@@ -43,40 +57,39 @@ async function getConfigObject(config) {
 async function loadLocalConfig(appDirectory, configFile) {
   let localConfigFile = false;
   if (typeof configFile === "string") {
-    for (const ext of _utils.CONFIG_FILE_EXTENSIONS) {
+    for (const ext of import_utils.CONFIG_FILE_EXTENSIONS) {
       if (configFile.endsWith(ext)) {
         const replacedPath = configFile.replace(ext, `.local${ext}`);
-        if (_utils.fs.existsSync(replacedPath)) {
+        if (import_utils.fs.existsSync(replacedPath)) {
           localConfigFile = replacedPath;
         }
       }
     }
   } else {
-    localConfigFile = (0, _utils.findExists)(_utils.CONFIG_FILE_EXTENSIONS.map((extension) => _path.default.resolve(appDirectory, `${_loadConfig.LOCAL_CONFIG_FILE_NAME}${extension}`)));
+    localConfigFile = (0, import_utils.findExists)(import_utils.CONFIG_FILE_EXTENSIONS.map((extension) => import_path.default.resolve(appDirectory, `${import_loadConfig.LOCAL_CONFIG_FILE_NAME}${extension}`)));
   }
   if (localConfigFile) {
-    const loaded = await (0, _loadConfig.loadConfig)(appDirectory, localConfigFile);
+    const loaded = await (0, import_loadConfig.loadConfig)(appDirectory, localConfigFile);
     return getConfigObject(loaded.config);
   }
   return null;
 }
 async function createLoadedConfig(appDirectory, filePath, packageJsonConfig, loadedConfig) {
-  const configFile = (0, _loadConfig.getConfigFilePath)(appDirectory, filePath);
-  const loaded = await (0, _loadConfig.loadConfig)(appDirectory, configFile, packageJsonConfig, loadedConfig);
+  const configFile = (0, import_loadConfig.getConfigFilePath)(appDirectory, filePath);
+  const loaded = await (0, import_loadConfig.loadConfig)(appDirectory, configFile, packageJsonConfig, loadedConfig);
   if (!loaded.config && !loaded.pkgConfig) {
-    _utils.logger.warn(`Can not find any config file in the current project, please check if you have a correct config file.`);
-    _utils.logger.warn(`Current project path: ${_utils.chalk.yellow(appDirectory)}`);
+    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) {
-    var _loaded;
-    mergedConfig = assignPkgConfig(config, (_loaded = loaded) === null || _loaded === void 0 ? void 0 : _loaded.pkgConfig);
+    mergedConfig = assignPkgConfig(config, loaded === null || loaded === void 0 ? void 0 : loaded.pkgConfig);
   }
-  if ((0, _utils.isDevCommand)()) {
+  if ((0, import_utils.isDevCommand)()) {
     const localConfig = await loadLocalConfig(appDirectory, configFile);
     if (localConfig) {
-      mergedConfig = (0, _utils1.mergeConfig)([
+      mergedConfig = (0, import_utils2.mergeConfig)([
         mergedConfig,
         localConfig
       ]);
@@ -90,3 +103,8 @@ async function createLoadedConfig(appDirectory, filePath, packageJsonConfig, loa
     jsConfig: config || {}
   };
 }
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  assignPkgConfig,
+  createLoadedConfig
+});

package/dist/config/createResolvedConfig.js

@@ -1,34 +1,56 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "createResolveConfig", {
-  enumerable: true,
-  get: function() {
-    return createResolveConfig;
+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 createResolvedConfig_exports = {};
+__export(createResolvedConfig_exports, {
+  createResolveConfig: () => createResolveConfig
 });
-const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
-const _utils = require("@modern-js/utils");
-const _patchSchema = require("../schema/patchSchema");
-const _repeatKeyWarning = require("../utils/repeatKeyWarning");
-const _mergeConfig = require("../utils/mergeConfig");
-const _createDefaultConfig = require("./createDefaultConfig");
-const debug = (0, _utils.createDebugger)("resolve-config");
+module.exports = __toCommonJS(createResolvedConfig_exports);
+var import_utils = require("@modern-js/utils");
+var import_patchSchema = require("../schema/patchSchema");
+var import_repeatKeyWarning = require("../utils/repeatKeyWarning");
+var import_mergeConfig = require("../utils/mergeConfig");
+var import_createDefaultConfig = require("./createDefaultConfig");
+const debug = (0, import_utils.createDebugger)("resolve-config");
 const createResolveConfig = async (loaded, configs, schemas, onSchemaError) => {
   var _validate_errors;
-  const { default: Ajv } = await Promise.resolve().then(() => /* @__PURE__ */ _interop_require_wildcard._(require("@modern-js/utils/ajv")));
-  const { default: ajvKeywords } = await Promise.resolve().then(() => /* @__PURE__ */ _interop_require_wildcard._(require("@modern-js/utils/ajv-keywords")));
-  const { default: betterAjvErrors } = await Promise.resolve().then(() => /* @__PURE__ */ _interop_require_wildcard._(require("@modern-js/utils/better-ajv-errors")));
+  const { default: Ajv } = await Promise.resolve().then(() => __toESM(require("@modern-js/utils/ajv")));
+  const { default: ajvKeywords } = await Promise.resolve().then(() => __toESM(require("@modern-js/utils/ajv-keywords")));
+  const { default: betterAjvErrors } = await Promise.resolve().then(() => __toESM(require("@modern-js/utils/better-ajv-errors")));
   const { config: userConfig, jsConfig, pkgConfig } = loaded;
   const ajv = new Ajv({
     $data: true,
     strict: false
   });
   ajvKeywords(ajv);
-  const validateSchema = (0, _patchSchema.patchSchema)(schemas);
+  const validateSchema = (0, import_patchSchema.patchSchema)(schemas);
   const validate = ajv.compile(validateSchema);
-  (0, _repeatKeyWarning.repeatKeyWarning)(validateSchema, jsConfig, pkgConfig);
+  (0, import_repeatKeyWarning.repeatKeyWarning)(validateSchema, jsConfig, pkgConfig);
   const valid = validate(userConfig);
   const formatValidateError = (config) => {
     var _validate_errors2;
@@ -41,25 +63,28 @@ const createResolveConfig = async (loaded, configs, schemas, onSchemaError) => {
   };
   if (!valid && ((_validate_errors = validate.errors) === null || _validate_errors === void 0 ? void 0 : _validate_errors.length)) {
     if (onSchemaError) {
-      var _validate;
-      await onSchemaError((_validate = validate) === null || _validate === void 0 ? void 0 : _validate.errors[0]);
+      await onSchemaError(validate === null || validate === void 0 ? void 0 : validate.errors[0]);
     }
     const errors = formatValidateError(userConfig);
-    _utils.logger.log(errors);
+    import_utils.logger.log(errors);
     throw new Error(`Validate configuration error`);
   }
   for (const config of configs) {
     if (!validate(config)) {
       const errors = formatValidateError(config);
-      _utils.logger.error(errors);
+      import_utils.logger.error(errors);
       throw new Error(`Validate configuration error.`);
     }
   }
-  const resolved = (0, _mergeConfig.mergeConfig)([
-    (0, _createDefaultConfig.createDefaultConfig)(),
+  const resolved = (0, import_mergeConfig.mergeConfig)([
+    (0, import_createDefaultConfig.createDefaultConfig)(),
     ...configs,
     userConfig
   ]);
   debug("resolved %o", resolved);
   return resolved;
 };
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createResolveConfig
+});

package/dist/config/index.js

@@ -1,8 +1,26 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var config_exports = {};
+module.exports = __toCommonJS(config_exports);
+__reExport(config_exports, require("./createLoadedConfig"), module.exports);
+__reExport(config_exports, require("./createResolvedConfig"), module.exports);
+__reExport(config_exports, require("./createDefaultConfig"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./createLoadedConfig"),
+  ...require("./createResolvedConfig"),
+  ...require("./createDefaultConfig")
 });
-const _export_star = require("@swc/helpers/_/_export_star");
-_export_star._(require("./createLoadedConfig"), exports);
-_export_star._(require("./createResolvedConfig"), exports);
-_export_star._(require("./createDefaultConfig"), exports);

package/dist/config/loadConfig.js

@@ -1,50 +1,52 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-function _export(target, all) {
+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)
-    Object.defineProperty(target, name, {
-      enumerable: true,
-      get: all[name]
-    });
-}
-_export(exports, {
-  CONFIG_FILE_NAME: function() {
-    return CONFIG_FILE_NAME;
-  },
-  LOCAL_CONFIG_FILE_NAME: function() {
-    return LOCAL_CONFIG_FILE_NAME;
-  },
-  PACKAGE_JSON_CONFIG_NAME: function() {
-    return PACKAGE_JSON_CONFIG_NAME;
-  },
-  getPackageConfig: function() {
-    return getPackageConfig;
-  },
-  getDependencies: function() {
-    return getDependencies;
-  },
-  clearFilesOverTime: function() {
-    return clearFilesOverTime;
-  },
-  getConfigFilePath: function() {
-    return getConfigFilePath;
-  },
-  loadConfig: function() {
-    return loadConfig;
+    __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, {
+  CONFIG_FILE_NAME: () => CONFIG_FILE_NAME,
+  LOCAL_CONFIG_FILE_NAME: () => LOCAL_CONFIG_FILE_NAME,
+  PACKAGE_JSON_CONFIG_NAME: () => PACKAGE_JSON_CONFIG_NAME,
+  clearFilesOverTime: () => clearFilesOverTime,
+  getConfigFilePath: () => getConfigFilePath,
+  getDependencies: () => getDependencies,
+  getPackageConfig: () => getPackageConfig,
+  loadConfig: () => loadConfig
 });
-const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
-const _path = /* @__PURE__ */ _interop_require_default._(require("path"));
-const _utils = require("@modern-js/utils");
-const _nodebundlerequire = require("@modern-js/node-bundle-require");
-const debug = (0, _utils.createDebugger)("load-config");
+module.exports = __toCommonJS(loadConfig_exports);
+var import_path = __toESM(require("path"));
+var import_utils = require("@modern-js/utils");
+var import_node_bundle_require = require("@modern-js/node-bundle-require");
+const debug = (0, import_utils.createDebugger)("load-config");
 const CONFIG_FILE_NAME = "modern.config";
 const LOCAL_CONFIG_FILE_NAME = "modern.config.local";
 const PACKAGE_JSON_CONFIG_NAME = "modernConfig";
 const getPackageConfig = (appDirectory, packageJsonConfig) => {
-  const json = JSON.parse(_utils.fs.readFileSync(_path.default.resolve(appDirectory, "./package.json"), "utf8"));
+  const json = JSON.parse(import_utils.fs.readFileSync(import_path.default.resolve(appDirectory, "./package.json"), "utf8"));
   return json[packageJsonConfig !== null && packageJsonConfig !== void 0 ? packageJsonConfig : PACKAGE_JSON_CONFIG_NAME];
 };
 const getDependencies = (filePath) => {
@@ -64,7 +66,7 @@ const getDependencies = (filePath) => {
 };
 const clearFilesOverTime = async (targetDir, overtime) => {
   try {
-    const files = await (0, _utils.globby)(`${targetDir}/**/*`, {
+    const files = await (0, import_utils.globby)(`${targetDir}/**/*`, {
       stats: true,
       absolute: true
     });
@@ -72,7 +74,7 @@ const clearFilesOverTime = async (targetDir, overtime) => {
     if (files.length > 0) {
       for (const file of files) {
         if (currentTime - file.stats.birthtimeMs >= overtime * 1e3) {
-          _utils.fs.unlinkSync(file.path);
+          import_utils.fs.unlinkSync(file.path);
         }
       }
     }
@@ -81,14 +83,14 @@ const clearFilesOverTime = async (targetDir, overtime) => {
 };
 const bundleRequireWithCatch = async (configFile, { appDirectory }) => {
   try {
-    const mod = await (0, _nodebundlerequire.bundleRequire)(configFile, {
+    const mod = await (0, import_node_bundle_require.bundleRequire)(configFile, {
       autoClear: false,
       getOutputFile: async (filePath) => {
-        const defaultOutputFileName = _path.default.basename(await (0, _nodebundlerequire.defaultGetOutputFile)(filePath));
-        const outputPath = _path.default.join(appDirectory, _utils.CONFIG_CACHE_DIR);
+        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 _path.default.join(outputPath, defaultOutputFileName);
+        return import_path.default.join(outputPath, defaultOutputFileName);
       }
     });
     return mod;
@@ -102,18 +104,18 @@ ${e.message || ""}`;
 };
 const getConfigFilePath = (appDirectory, filePath) => {
   if (filePath) {
-    if (_path.default.isAbsolute(filePath)) {
+    if (import_path.default.isAbsolute(filePath)) {
       return filePath;
     }
-    return _path.default.resolve(appDirectory, filePath);
+    return import_path.default.resolve(appDirectory, filePath);
   }
-  return (0, _utils.findExists)(_utils.CONFIG_FILE_EXTENSIONS.map((extension) => _path.default.resolve(appDirectory, `${CONFIG_FILE_NAME}${extension}`)));
+  return (0, import_utils.findExists)(import_utils.CONFIG_FILE_EXTENSIONS.map((extension) => import_path.default.resolve(appDirectory, `${CONFIG_FILE_NAME}${extension}`)));
 };
 const loadConfig = async (appDirectory, configFile, packageJsonConfig, loadedConfig) => {
   const pkgConfig = getPackageConfig(appDirectory, packageJsonConfig);
   let config;
   const dependencies = pkgConfig ? [
-    _path.default.resolve(appDirectory, "./package.json")
+    import_path.default.resolve(appDirectory, "./package.json")
   ] : [];
   if (loadedConfig) {
     config = loadedConfig;
@@ -131,3 +133,14 @@ const loadConfig = async (appDirectory, configFile, packageJsonConfig, loadedCon
     dependencies
   };
 };
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CONFIG_FILE_NAME,
+  LOCAL_CONFIG_FILE_NAME,
+  PACKAGE_JSON_CONFIG_NAME,
+  clearFilesOverTime,
+  getConfigFilePath,
+  getDependencies,
+  getPackageConfig,
+  loadConfig
+});

package/dist/context.js

@@ -1,47 +1,49 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-function _export(target, all) {
+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)
-    Object.defineProperty(target, name, {
-      enumerable: true,
-      get: all[name]
-    });
-}
-_export(exports, {
-  AppContext: function() {
-    return AppContext;
-  },
-  ConfigContext: function() {
-    return ConfigContext;
-  },
-  ResolvedConfigContext: function() {
-    return ResolvedConfigContext;
-  },
-  setAppContext: function() {
-    return setAppContext;
-  },
-  useAppContext: function() {
-    return useAppContext;
-  },
-  useConfigContext: function() {
-    return useConfigContext;
-  },
-  useResolvedConfigContext: function() {
-    return useResolvedConfigContext;
-  },
-  initAppContext: function() {
-    return initAppContext;
+    __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, {
+  AppContext: () => AppContext,
+  ConfigContext: () => ConfigContext,
+  ResolvedConfigContext: () => ResolvedConfigContext,
+  initAppContext: () => initAppContext,
+  setAppContext: () => setAppContext,
+  useAppContext: () => useAppContext,
+  useConfigContext: () => useConfigContext,
+  useResolvedConfigContext: () => useResolvedConfigContext
 });
-const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
-const _path = /* @__PURE__ */ _interop_require_default._(require("path"));
-const _utils = require("@modern-js/utils");
-const _plugin = require("@modern-js/plugin");
-const AppContext = (0, _plugin.createContext)({});
-const ConfigContext = (0, _plugin.createContext)({});
-const ResolvedConfigContext = (0, _plugin.createContext)({});
+module.exports = __toCommonJS(context_exports);
+var import_path = __toESM(require("path"));
+var import_utils = require("@modern-js/utils");
+var import_plugin = require("@modern-js/plugin");
+const AppContext = (0, import_plugin.createContext)({});
+const ConfigContext = (0, import_plugin.createContext)({});
+const ResolvedConfigContext = (0, import_plugin.createContext)({});
 const setAppContext = (value) => AppContext.set(value);
 const useAppContext = () => AppContext.use().value;
 const useConfigContext = () => ConfigContext.use().value;
@@ -54,16 +56,16 @@ const initAppContext = ({ appDirectory, plugins, configFile, options, serverConf
     configFile,
     serverConfigFile,
     serverInternalPlugins,
-    ip: _utils.address.ip(),
+    ip: import_utils.address.ip(),
     port: 0,
-    packageName: require(_path.default.resolve(appDirectory, "./package.json")).name,
-    srcDirectory: _path.default.resolve(appDirectory, srcDir),
-    apiDirectory: _path.default.resolve(appDirectory, apiDir),
-    lambdaDirectory: _path.default.resolve(appDirectory, apiDir, "lambda"),
+    packageName: require(import_path.default.resolve(appDirectory, "./package.json")).name,
+    srcDirectory: import_path.default.resolve(appDirectory, srcDir),
+    apiDirectory: import_path.default.resolve(appDirectory, apiDir),
+    lambdaDirectory: import_path.default.resolve(appDirectory, apiDir, "lambda"),
     distDirectory: distDir,
-    sharedDirectory: _path.default.resolve(appDirectory, sharedDir),
-    nodeModulesDirectory: _path.default.resolve(appDirectory, "./node_modules"),
-    internalDirectory: _path.default.resolve(appDirectory, `./node_modules/.${metaName}`),
+    sharedDirectory: import_path.default.resolve(appDirectory, sharedDir),
+    nodeModulesDirectory: import_path.default.resolve(appDirectory, "./node_modules"),
+    internalDirectory: import_path.default.resolve(appDirectory, `./node_modules/.${metaName}`),
     plugins,
     htmlTemplates: {},
     serverRoutes: [],
@@ -74,3 +76,14 @@ const initAppContext = ({ appDirectory, plugins, configFile, options, serverConf
     internalSrcAlias: `@_${metaName.replace(/-/g, "_")}_src`
   };
 };
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AppContext,
+  ConfigContext,
+  ResolvedConfigContext,
+  initAppContext,
+  setAppContext,
+  useAppContext,
+  useConfigContext,
+  useResolvedConfigContext
+});