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

package/dist/cjs/cli/api.js

@@ -0,0 +1,119 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    initPluginAPI: ()=>initPluginAPI
+});
+const lodash_namespaceObject = require("@modern-js/utils/lodash");
+const debug_js_namespaceObject = require("./run/utils/debug.js");
+function initPluginAPI({ context, pluginManager }) {
+    const { hooks, extendsHooks, plugins } = context;
+    function getAppContext() {
+        if (context) {
+            const { hooks, extendsHooks, config, normalizedConfig, pluginAPI, ...appContext } = context;
+            appContext._internalContext = 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;
+    }
+    const extendsPluginApi = {};
+    plugins.forEach((plugin)=>{
+        const { _registryApi } = plugin;
+        if (_registryApi) {
+            const apis = _registryApi(getAppContext, updateAppContext);
+            Object.keys(apis).forEach((apiName)=>{
+                extendsPluginApi[apiName] = apis[apiName];
+            });
+        }
+    });
+    if (extendsHooks) Object.keys(extendsHooks).forEach((hookName)=>{
+        extendsPluginApi[hookName] = extendsHooks[hookName].tap;
+    });
+    function updateAppContext(updateContext) {
+        context = (0, lodash_namespaceObject.assign)(context, updateContext);
+    }
+    const pluginAPI = {
+        isPluginExists: pluginManager.isPluginExists,
+        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,
+        modifyHtmlPartials: hooks.modifyHtmlPartials.tap,
+        addCommand: hooks.addCommand.tap,
+        onPrepare: hooks.onPrepare.tap,
+        addWatchFiles: hooks.addWatchFiles.tap,
+        onFileChanged: hooks.onFileChanged.tap,
+        onBeforeRestart: hooks.onBeforeRestart.tap,
+        onBeforeCreateCompiler: hooks.onBeforeCreateCompiler.tap,
+        onDevCompileDone: hooks.onDevCompileDone.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,
+        _internalRuntimePlugins: hooks._internalRuntimePlugins.tap,
+        _internalServerPlugins: hooks._internalServerPlugins.tap,
+        modifyServerRoutes: hooks.modifyServerRoutes.tap,
+        ...extendsPluginApi
+    };
+    if ("u" < typeof Proxy) return pluginAPI;
+    return new Proxy(pluginAPI, {
+        get (target, prop) {
+            if ('then' === prop) return;
+            if (prop in target) return target[prop];
+            return ()=>{
+                (0, debug_js_namespaceObject.debug)(`api.${prop.toString()} not exist`);
+            };
+        }
+    });
+}
+exports.initPluginAPI = __webpack_exports__.initPluginAPI;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "initPluginAPI"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/cli/context.js

@@ -0,0 +1,85 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    initAppContext: ()=>initAppContext,
+    createContext: ()=>createContext
+});
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const external_hooks_js_namespaceObject = require("./hooks.js");
+function initAppContext(params) {
+    const { appDirectory, srcDir = 'src', distDir = 'dist' } = params;
+    return {
+        metaName: params.metaName,
+        packageName: params.packageName,
+        configFile: params.configFile,
+        command: params.command,
+        isProd: 'production' === process.env.NODE_ENV,
+        appDirectory: appDirectory,
+        srcDirectory: external_path_default().resolve(appDirectory, srcDir),
+        distDirectory: '',
+        nodeModulesDirectory: external_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, external_hooks_js_namespaceObject.initHooks)(),
+            ...extendsHooks
+        },
+        extendsHooks,
+        config,
+        normalizedConfig
+    };
+}
+exports.createContext = __webpack_exports__.createContext;
+exports.initAppContext = __webpack_exports__.initAppContext;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createContext",
+    "initAppContext"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/cli/hooks.js

@@ -0,0 +1,65 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    initHooks: ()=>initHooks
+});
+const external_hooks_js_namespaceObject = require("../hooks.js");
+function initHooks() {
+    return {
+        config: (0, external_hooks_js_namespaceObject.createCollectAsyncHook)(),
+        modifyConfig: (0, external_hooks_js_namespaceObject.createAsyncHook)(),
+        modifyResolvedConfig: (0, external_hooks_js_namespaceObject.createAsyncHook)(),
+        modifyRsbuildConfig: (0, external_hooks_js_namespaceObject.createAsyncHook)(),
+        modifyBundlerChain: (0, external_hooks_js_namespaceObject.createAsyncHook)(),
+        modifyRspackConfig: (0, external_hooks_js_namespaceObject.createAsyncHook)(),
+        modifyHtmlPartials: (0, external_hooks_js_namespaceObject.createAsyncHook)(),
+        addCommand: (0, external_hooks_js_namespaceObject.createAsyncHook)(),
+        addWatchFiles: (0, external_hooks_js_namespaceObject.createCollectAsyncHook)(),
+        onPrepare: (0, external_hooks_js_namespaceObject.createAsyncHook)(),
+        onFileChanged: (0, external_hooks_js_namespaceObject.createAsyncHook)(),
+        onBeforeRestart: (0, external_hooks_js_namespaceObject.createAsyncHook)(),
+        onBeforeCreateCompiler: (0, external_hooks_js_namespaceObject.createAsyncHook)(),
+        onAfterCreateCompiler: (0, external_hooks_js_namespaceObject.createAsyncHook)(),
+        onDevCompileDone: (0, external_hooks_js_namespaceObject.createAsyncHook)(),
+        onBeforeBuild: (0, external_hooks_js_namespaceObject.createAsyncHook)(),
+        onAfterBuild: (0, external_hooks_js_namespaceObject.createAsyncHook)(),
+        onBeforeDev: (0, external_hooks_js_namespaceObject.createAsyncHook)(),
+        onAfterDev: (0, external_hooks_js_namespaceObject.createAsyncHook)(),
+        onBeforeDeploy: (0, external_hooks_js_namespaceObject.createAsyncHook)(),
+        onAfterDeploy: (0, external_hooks_js_namespaceObject.createAsyncHook)(),
+        onBeforeExit: (0, external_hooks_js_namespaceObject.createAsyncHook)(),
+        _internalRuntimePlugins: (0, external_hooks_js_namespaceObject.createAsyncHook)(),
+        _internalServerPlugins: (0, external_hooks_js_namespaceObject.createAsyncHook)(),
+        modifyServerRoutes: (0, external_hooks_js_namespaceObject.createAsyncHook)()
+    };
+}
+exports.initHooks = __webpack_exports__.initHooks;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "initHooks"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/cli/index.js

@@ -0,0 +1,68 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    cli: ()=>index_js_namespaceObject.cli,
+    mergeConfig: ()=>mergeConfig_js_namespaceObject.mergeConfig,
+    createContext: ()=>external_context_js_namespaceObject.createContext,
+    createStorybookOptions: ()=>create_js_namespaceObject.createStorybookOptions,
+    createCli: ()=>index_js_namespaceObject.createCli,
+    initAppContext: ()=>external_context_js_namespaceObject.initAppContext,
+    initHooks: ()=>external_hooks_js_namespaceObject.initHooks,
+    initPluginAPI: ()=>external_api_js_namespaceObject.initPluginAPI,
+    initAppDir: ()=>index_js_namespaceObject.initAppDir,
+    createLoadedConfig: ()=>index_js_namespaceObject.createLoadedConfig
+});
+const external_api_js_namespaceObject = require("./api.js");
+const external_context_js_namespaceObject = require("./context.js");
+const external_hooks_js_namespaceObject = require("./hooks.js");
+const index_js_namespaceObject = require("./run/index.js");
+const create_js_namespaceObject = require("./run/create.js");
+const mergeConfig_js_namespaceObject = require("./run/utils/mergeConfig.js");
+exports.cli = __webpack_exports__.cli;
+exports.createCli = __webpack_exports__.createCli;
+exports.createContext = __webpack_exports__.createContext;
+exports.createLoadedConfig = __webpack_exports__.createLoadedConfig;
+exports.createStorybookOptions = __webpack_exports__.createStorybookOptions;
+exports.initAppContext = __webpack_exports__.initAppContext;
+exports.initAppDir = __webpack_exports__.initAppDir;
+exports.initHooks = __webpack_exports__.initHooks;
+exports.initPluginAPI = __webpack_exports__.initPluginAPI;
+exports.mergeConfig = __webpack_exports__.mergeConfig;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "cli",
+    "createCli",
+    "createContext",
+    "createLoadedConfig",
+    "createStorybookOptions",
+    "initAppContext",
+    "initAppDir",
+    "initHooks",
+    "initPluginAPI",
+    "mergeConfig"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,87 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createLoadedConfig: ()=>createLoadedConfig
+});
+const utils_namespaceObject = require("@modern-js/utils");
+const mergeConfig_js_namespaceObject = require("../utils/mergeConfig.js");
+const external_loadConfig_js_namespaceObject = require("./loadConfig.js");
+async function getConfigObject(config) {
+    if ('function' == typeof config) return await config({
+        env: (0, utils_namespaceObject.getNodeEnv)(),
+        command: (0, utils_namespaceObject.getCommand)()
+    }) || {};
+    return config || {};
+}
+async function loadLocalConfig(appDirectory, configFile) {
+    let localConfigFile = false;
+    if ('string' == typeof configFile) {
+        for (const ext of utils_namespaceObject.CONFIG_FILE_EXTENSIONS)if (configFile.endsWith(ext)) {
+            const replacedPath = configFile.replace(ext, `.local${ext}`);
+            if (utils_namespaceObject.fs.existsSync(replacedPath)) localConfigFile = replacedPath;
+        }
+    }
+    if (localConfigFile) {
+        const loaded = await (0, external_loadConfig_js_namespaceObject.loadConfig)(appDirectory, localConfigFile);
+        return getConfigObject(loaded.config);
+    }
+    return null;
+}
+async function createLoadedConfig(appDirectory, configFilePath, otherConfig) {
+    const configFile = (0, external_loadConfig_js_namespaceObject.getConfigFilePath)(appDirectory, configFilePath);
+    const loaded = await (0, external_loadConfig_js_namespaceObject.loadConfig)(appDirectory, configFile);
+    if (!loaded.config && !loaded.pkgConfig) {
+        utils_namespaceObject.logger.warn("Can not find any config file in the current project, please check if you have a correct config file.");
+        utils_namespaceObject.logger.warn(`Current project path: ${utils_namespaceObject.chalk.yellow(appDirectory)}`);
+    }
+    const config = await getConfigObject(loaded.config);
+    let mergedConfig = config;
+    if ((0, utils_namespaceObject.isDevCommand)()) {
+        const localConfig = await loadLocalConfig(appDirectory, configFile);
+        if (localConfig) mergedConfig = (0, mergeConfig_js_namespaceObject.mergeConfig)([
+            mergedConfig,
+            localConfig
+        ]);
+    }
+    if (otherConfig) mergedConfig = (0, mergeConfig_js_namespaceObject.mergeConfig)([
+        mergedConfig,
+        otherConfig
+    ]);
+    return {
+        packageName: loaded.packageName,
+        config: mergedConfig,
+        configFile: loaded.configFile,
+        pkgConfig: loaded.pkgConfig,
+        jsConfig: loaded.config
+    };
+}
+exports.createLoadedConfig = __webpack_exports__.createLoadedConfig;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createLoadedConfig"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,48 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createResolveConfig: ()=>createResolveConfig
+});
+const utils_namespaceObject = require("@modern-js/utils");
+const mergeConfig_js_namespaceObject = require("../utils/mergeConfig.js");
+const debug = (0, utils_namespaceObject.createDebugger)('resolve-config');
+const createResolveConfig = async (loaded, configs)=>{
+    const { config: userConfig } = loaded;
+    const resolved = (0, mergeConfig_js_namespaceObject.mergeConfig)([
+        {},
+        ...configs,
+        userConfig
+    ]);
+    debug('resolved %o', resolved);
+    return resolved;
+};
+exports.createResolveConfig = __webpack_exports__.createResolveConfig;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createResolveConfig"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,113 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    loadConfig: ()=>loadConfig,
+    getConfigFilePath: ()=>getConfigFilePath,
+    clearFilesOverTime: ()=>clearFilesOverTime,
+    loadTypeScriptFile: ()=>loadTypeScriptFile
+});
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const utils_namespaceObject = require("@modern-js/utils");
+const external_jiti_namespaceObject = require("jiti");
+var external_jiti_default = /*#__PURE__*/ __webpack_require__.n(external_jiti_namespaceObject);
+const getConfigFilePath = (appDirectory, configFilePath)=>{
+    if (external_path_default().isAbsolute(configFilePath)) return configFilePath;
+    return external_path_default().resolve(appDirectory, configFilePath);
+};
+const clearFilesOverTime = async (targetDir, overtime)=>{
+    try {
+        const files = await (0, utils_namespaceObject.globby)(`${targetDir}/**/*`, {
+            stats: true,
+            absolute: true
+        });
+        const currentTime = Date.now();
+        if (files.length > 0) {
+            for (const file of files)if (currentTime - file.stats.birthtimeMs >= 1000 * overtime) utils_namespaceObject.fs.unlinkSync(file.path);
+        }
+    } catch (err) {}
+};
+function loadConfigContent(configFile) {
+    const _require = external_jiti_default()(__filename, {
+        esmResolve: true,
+        requireCache: false,
+        interopDefault: true
+    });
+    if (!utils_namespaceObject.fs.existsSync(configFile)) throw new Error(`Configuration file does not exist: ${configFile}`);
+    try {
+        const config = _require(configFile);
+        return config.default || config;
+    } catch (e) {
+        if (e instanceof Error) e.message = `Get Error while loading config file: ${configFile}, please check it and retry.\n${e.message || ''}`;
+        throw e;
+    }
+}
+const loadTypeScriptFile = (filePath)=>{
+    const _require = external_jiti_default()(__filename, {
+        esmResolve: true,
+        requireCache: false,
+        interopDefault: true
+    });
+    if (!utils_namespaceObject.fs.existsSync(filePath)) throw new Error(`TypeScript file does not exist: ${filePath}`);
+    try {
+        return _require(filePath);
+    } catch (e) {
+        if (e instanceof Error) e.message = `Get Error while loading TypeScript file: ${filePath}, please check it and retry.\n${e.message || ''}`;
+        throw e;
+    }
+};
+const loadConfig = async (appDirectory, configFile)=>{
+    const packageName = require(external_path_default().resolve(appDirectory, './package.json')).name;
+    let config;
+    if (configFile) config = loadConfigContent(configFile);
+    return {
+        packageName,
+        configFile,
+        config
+    };
+};
+exports.clearFilesOverTime = __webpack_exports__.clearFilesOverTime;
+exports.getConfigFilePath = __webpack_exports__.getConfigFilePath;
+exports.loadConfig = __webpack_exports__.loadConfig;
+exports.loadTypeScriptFile = __webpack_exports__.loadTypeScriptFile;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "clearFilesOverTime",
+    "getConfigFilePath",
+    "loadConfig",
+    "loadTypeScriptFile"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});