@bleedingdev/modern-js-app-tools 3.2.0-ultramodern.0

package/dist/cjs/commands/runtime.js

@@ -0,0 +1,159 @@
+"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__, {
+    createRuntimeFallbackSignalPayload: ()=>createRuntimeFallbackSignalPayload,
+    resolveRuntimeEndpoint: ()=>resolveRuntimeEndpoint,
+    resolveToken: ()=>resolveToken,
+    runtimeCommand: ()=>runtimeCommand
+});
+const DEFAULT_RUNTIME_HOST = 'http://127.0.0.1:8080';
+const DEFAULT_RUNTIME_STATUS_PATH = '/_modern/runtime/status';
+const DEFAULT_RUNTIME_FALLBACK_SIGNAL_PATH = '/_modern/contract-gates/runtime-fallback';
+const DEFAULT_RUNTIME_TOKEN_HEADER = 'x-modernjs-runtime-signal-token';
+const DEFAULT_TIMEOUT_MS = 5000;
+const resolveRuntimeEndpoint = (input, defaultPath)=>{
+    const rawInput = input?.trim();
+    if (!rawInput) return `${DEFAULT_RUNTIME_HOST}${defaultPath}`;
+    if (rawInput.startsWith('http://') || rawInput.startsWith('https://')) return rawInput;
+    const normalized = rawInput.startsWith('/') ? rawInput : `/${rawInput}`;
+    return `${DEFAULT_RUNTIME_HOST}${normalized}`;
+};
+const resolveToken = ({ token, tokenEnv })=>{
+    if ('string' == typeof token && token.trim().length > 0) return token.trim();
+    if ('string' == typeof tokenEnv && tokenEnv.trim().length > 0) {
+        const value = process.env[tokenEnv.trim()];
+        if ('string' == typeof value && value.trim().length > 0) return value.trim();
+    }
+};
+const parseTimeoutMs = (value)=>{
+    if ('string' != typeof value || 0 === value.trim().length) return DEFAULT_TIMEOUT_MS;
+    const parsed = Number.parseInt(value, 10);
+    if (!Number.isFinite(parsed) || parsed <= 0) return DEFAULT_TIMEOUT_MS;
+    return parsed;
+};
+const parseMetadata = (metadata)=>{
+    if ('string' != typeof metadata || 0 === metadata.trim().length) return;
+    const parsed = JSON.parse(metadata);
+    if (!parsed || 'object' != typeof parsed || Array.isArray(parsed)) throw new Error('metadata must be a JSON object');
+    return parsed;
+};
+const fetchWithTimeout = async (url, init, timeoutMs)=>{
+    const controller = new AbortController();
+    const timeout = setTimeout(()=>{
+        controller.abort();
+    }, timeoutMs);
+    try {
+        return await fetch(url, {
+            ...init,
+            signal: controller.signal
+        });
+    } finally{
+        clearTimeout(timeout);
+    }
+};
+const parseResponseBody = async (response)=>{
+    const text = await response.text();
+    if (!text) return {};
+    try {
+        return JSON.parse(text);
+    } catch (_error) {
+        return {
+            raw: text
+        };
+    }
+};
+const printOutput = (payload, jsonOnly)=>{
+    if (jsonOnly) return void console.log(JSON.stringify(payload, null, 2));
+    console.log(JSON.stringify(payload, null, 2));
+};
+const createRuntimeFallbackSignalPayload = (options)=>{
+    const payload = {
+        appName: options.app,
+        reason: options.reason || 'runtime_fallback',
+        phase: options.phase || 'load'
+    };
+    if (options.entry) payload.entry = options.entry;
+    if (options.runtimeDigest) payload.runtimeDigest = options.runtimeDigest;
+    const metadata = parseMetadata(options.metadata);
+    if (metadata) payload.metadata = metadata;
+    return payload;
+};
+const runtimeCommand = async (program, _api)=>{
+    const runtime = program.command('runtime').description('runtime operations');
+    runtime.command('status').description('read runtime status snapshot').option('--endpoint <endpoint>', 'runtime status endpoint URL or path').option('--token <token>', 'runtime status auth token').option('--token-env <name>', 'environment variable name that stores runtime status auth token', 'MODERN_RUNTIME_SIGNAL_TOKEN').option('--header-name <name>', 'auth header name', DEFAULT_RUNTIME_TOKEN_HEADER).option('--timeout <ms>', 'request timeout in milliseconds', '5000').option('--json', 'output as JSON format for machine reading').action(async (options)=>{
+        const endpoint = resolveRuntimeEndpoint(options.endpoint, DEFAULT_RUNTIME_STATUS_PATH);
+        const timeoutMs = parseTimeoutMs(options.timeout);
+        const token = resolveToken({
+            token: options.token,
+            tokenEnv: options.tokenEnv
+        });
+        const headerName = options.headerName?.trim() || DEFAULT_RUNTIME_TOKEN_HEADER;
+        const headers = new Headers();
+        if (token) headers.set(headerName, token);
+        const response = await fetchWithTimeout(endpoint, {
+            method: 'GET',
+            headers
+        }, timeoutMs);
+        const payload = await parseResponseBody(response);
+        if (!response.ok) throw new Error(`runtime status request failed with ${response.status}: ${JSON.stringify(payload)}`);
+        printOutput(payload, options.json);
+    });
+    runtime.command('fallback-signal').description('emit runtime fallback signal for canary gate mutation').requiredOption('--app <appName>', 'remote app name').option('--endpoint <endpoint>', 'runtime fallback signal endpoint URL or path').option('--reason <reason>', 'fallback reason', 'runtime_fallback').option('--phase <phase>', 'fallback phase', 'load').option('--entry <entry>', 'remote entry URL').option('--runtime-digest <digest>', 'runtime digest value').option('--metadata <json>', 'metadata JSON object string').option('--token <token>', 'runtime signal auth token').option('--token-env <name>', 'environment variable name that stores runtime signal auth token', 'MODERN_RUNTIME_SIGNAL_TOKEN').option('--header-name <name>', 'auth header name', DEFAULT_RUNTIME_TOKEN_HEADER).option('--timeout <ms>', 'request timeout in milliseconds', '5000').option('--json', 'output as JSON format for machine reading').action(async (options)=>{
+        const endpoint = resolveRuntimeEndpoint(options.endpoint, DEFAULT_RUNTIME_FALLBACK_SIGNAL_PATH);
+        const timeoutMs = parseTimeoutMs(options.timeout);
+        const token = resolveToken({
+            token: options.token,
+            tokenEnv: options.tokenEnv
+        });
+        const headerName = options.headerName?.trim() || DEFAULT_RUNTIME_TOKEN_HEADER;
+        const payload = createRuntimeFallbackSignalPayload(options);
+        const headers = new Headers({
+            'content-type': 'application/json'
+        });
+        if (token) headers.set(headerName, token);
+        const response = await fetchWithTimeout(endpoint, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(payload)
+        }, timeoutMs);
+        const responsePayload = await parseResponseBody(response);
+        if (!response.ok) throw new Error(`runtime fallback signal request failed with ${response.status}: ${JSON.stringify(responsePayload)}`);
+        printOutput(responsePayload, options.json);
+    });
+};
+exports.createRuntimeFallbackSignalPayload = __webpack_exports__.createRuntimeFallbackSignalPayload;
+exports.resolveRuntimeEndpoint = __webpack_exports__.resolveRuntimeEndpoint;
+exports.resolveToken = __webpack_exports__.resolveToken;
+exports.runtimeCommand = __webpack_exports__.runtimeCommand;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createRuntimeFallbackSignalPayload",
+    "resolveRuntimeEndpoint",
+    "resolveToken",
+    "runtimeCommand"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/commands/serve.js

@@ -0,0 +1,92 @@
+"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__, {
+    serve: ()=>serve
+});
+const prod_server_namespaceObject = require("@modern-js/prod-server");
+const utils_namespaceObject = require("@modern-js/utils");
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const loadPlugins_js_namespaceObject = require("../utils/loadPlugins.js");
+const printInstructions_js_namespaceObject = require("../utils/printInstructions.js");
+const serve = async (api, serverOptions)=>{
+    const appContext = api.getAppContext();
+    const userConfig = api.getNormalizedConfig();
+    const hooks = api.getHooks();
+    const { distDirectory, appDirectory, internalDirectory, port, metaName, serverRoutes } = appContext;
+    const { isCrossProjectServer } = userConfig?.bff || {};
+    utils_namespaceObject.logger.info("Starting production server...");
+    const apiOnly = await (0, utils_namespaceObject.isApiOnly)(appContext.appDirectory, userConfig?.source?.entriesDir, appContext.apiDirectory);
+    let runMode;
+    if (apiOnly) runMode = 'apiOnly';
+    const meta = (0, utils_namespaceObject.getMeta)(metaName);
+    const serverConfigPath = external_path_default().resolve(distDirectory, utils_namespaceObject.SERVER_DIR, `${meta}.server`);
+    const pluginInstances = await (0, loadPlugins_js_namespaceObject.loadServerPlugins)(api, appDirectory, metaName);
+    const app = await (serverOptions?.launcher || prod_server_namespaceObject.createProdServer)({
+        metaName,
+        pwd: distDirectory,
+        config: {
+            ...userConfig,
+            dev: userConfig.dev,
+            tools: userConfig.tools,
+            output: {
+                path: userConfig.output.distPath?.root,
+                ...userConfig.output || {}
+            }
+        },
+        routes: serverRoutes,
+        plugins: pluginInstances,
+        serverConfigPath,
+        appContext: {
+            appDirectory,
+            internalDirectory,
+            sharedDirectory: (0, utils_namespaceObject.getTargetDir)(appContext.sharedDirectory, appContext.appDirectory, appContext.distDirectory),
+            apiDirectory: isCrossProjectServer ? appContext.apiDirectory : (0, utils_namespaceObject.getTargetDir)(appContext.apiDirectory, appContext.appDirectory, appContext.distDirectory),
+            lambdaDirectory: isCrossProjectServer ? appContext.lambdaDirectory : (0, utils_namespaceObject.getTargetDir)(appContext.lambdaDirectory, appContext.appDirectory, appContext.distDirectory),
+            bffRuntimeFramework: appContext.bffRuntimeFramework
+        },
+        runMode
+    });
+    app.listen(port, async ()=>{
+        await (0, printInstructions_js_namespaceObject.printInstructions)(hooks, appContext, userConfig);
+    });
+};
+exports.serve = __webpack_exports__.serve;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "serve"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/compat/hooks.js

@@ -0,0 +1,104 @@
+"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__, {
+    getHookRunners: ()=>getHookRunners,
+    handleSetupResult: ()=>handleSetupResult
+});
+const getHtmlTemplate_js_namespaceObject = require("../plugins/analyze/getHtmlTemplate.js");
+const external_utils_js_namespaceObject = require("./utils.js");
+function getHookRunners(context) {
+    const { hooks } = context;
+    return {
+        afterPrepare: async ()=>hooks.onAfterPrepare.call(),
+        deploy: async ()=>hooks.deploy.call(),
+        _internalRuntimePlugins: async (params)=>hooks._internalRuntimePlugins.call(params),
+        _internalServerPlugins: async (params)=>hooks._internalServerPlugins.call(params),
+        checkEntryPoint: async (params)=>hooks.checkEntryPoint.call(params),
+        modifyEntrypoints: async (params)=>hooks.modifyEntrypoints.call(params),
+        modifyFileSystemRoutes: async (params)=>hooks.modifyFileSystemRoutes.call(params),
+        modifyServerRoutes: async (params)=>hooks.modifyServerRoutes.call(params),
+        generateEntryCode: async (params)=>hooks.generateEntryCode.call(params),
+        beforeGenerateRoutes: async (params)=>hooks.onBeforeGenerateRoutes.call(params),
+        beforePrintInstructions: async (params)=>hooks.onBeforePrintInstructions.call(params),
+        appendEntryCode: async (params)=>{
+            const result = await hooks?.appendEntryCode.call(params);
+            return result;
+        },
+        jestConfig: async (utils)=>{
+            const result = await hooks?.jestConfig.call(utils, (utils)=>utils);
+            return result;
+        },
+        afterTest: async ()=>hooks.afterTest.call(),
+        config: async ()=>hooks.config.call(),
+        resolvedConfig: (params)=>hooks.modifyResolvedConfig.call(params),
+        htmlPartials: async (params)=>{
+            await hooks.modifyHtmlPartials.call({
+                entrypoint: params.entrypoint,
+                partials: (0, getHtmlTemplate_js_namespaceObject.getModifyHtmlPartials)(params.partials)
+            });
+            return {
+                partials: params.partials
+            };
+        },
+        commands: async (params)=>hooks.addCommand.call(params),
+        watchFiles: async ()=>hooks.addWatchFiles.call(),
+        prepare: async ()=>hooks.onPrepare.call(),
+        fileChange: async (params)=>hooks.onFileChanged.call(params),
+        beforeCreateCompiler: async (params)=>hooks.onBeforeCreateCompiler.call(params),
+        afterCreateCompiler: async (params)=>hooks.onAfterCreateCompiler.call(params),
+        beforeBuild: async (params)=>hooks.onBeforeBuild.call(params),
+        afterBuild: async (params)=>hooks.onAfterBuild.call(params),
+        beforeDev: async ()=>hooks.onBeforeDev.call(),
+        afterDev: async (params)=>hooks.onDevCompileDone.call(params),
+        beforeDeploy: async (options)=>hooks.onBeforeDeploy.call(options),
+        afterDeploy: async (options)=>hooks.onAfterDeploy.call(options),
+        beforeExit: async ()=>hooks.onBeforeExit.call(),
+        beforeRestart: async ()=>hooks.onBeforeRestart.call()
+    };
+}
+function handleSetupResult(setupResult, api) {
+    if (!setupResult) return;
+    Object.keys(setupResult).forEach((key)=>{
+        const fn = setupResult[key];
+        if ('function' == typeof fn) {
+            const newAPI = (0, external_utils_js_namespaceObject.transformHookRunner)(key);
+            if (newAPI && api[newAPI]) api[newAPI](async (...params)=>{
+                const { isMultiple, params: transformParams } = (0, external_utils_js_namespaceObject.transformHookParams)(key, params);
+                if (isMultiple) return (0, external_utils_js_namespaceObject.transformHookResult)(key, await fn(...transformParams));
+                return (0, external_utils_js_namespaceObject.transformHookResult)(key, await fn(transformParams));
+            });
+        }
+    });
+}
+exports.getHookRunners = __webpack_exports__.getHookRunners;
+exports.handleSetupResult = __webpack_exports__.handleSetupResult;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "getHookRunners",
+    "handleSetupResult"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/compat/index.js

@@ -0,0 +1,62 @@
+"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__, {
+    compatPlugin: ()=>compatPlugin
+});
+const plugin_namespaceObject = require("@modern-js/plugin");
+const external_hooks_js_namespaceObject = require("./hooks.js");
+const compatPlugin = ()=>({
+        name: '@modern-js/app-tools-compat',
+        _registryApi: (getAppContext, updateAppContext)=>{
+            const getInternalContext = ()=>getAppContext()._internalContext;
+            return {
+                useAppContext: ()=>{
+                    const { _internalContext, ...appContext } = getAppContext();
+                    return appContext;
+                },
+                setAppContext: (context)=>updateAppContext(context),
+                useConfigContext: ()=>getInternalContext().config,
+                useResolvedConfigContext: ()=>getInternalContext().normalizedConfig,
+                useHookRunners: ()=>(0, external_hooks_js_namespaceObject.getHookRunners)(getInternalContext())
+            };
+        },
+        registryHooks: {
+            jestConfig: (0, plugin_namespaceObject.createAsyncHook)(),
+            afterTest: (0, plugin_namespaceObject.createAsyncHook)()
+        },
+        setup: (api)=>{
+            api.updateAppContext({
+                toolsType: 'app-tools'
+            });
+        }
+    });
+exports.compatPlugin = __webpack_exports__.compatPlugin;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "compatPlugin"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/compat/utils.js

@@ -0,0 +1,135 @@
+"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__, {
+    transformHookParams: ()=>transformHookParams,
+    transformHookResult: ()=>transformHookResult,
+    transformHookRunner: ()=>transformHookRunner
+});
+const getHtmlTemplate_js_namespaceObject = require("../plugins/analyze/getHtmlTemplate.js");
+function transformHookRunner(hookRunnerName) {
+    switch(hookRunnerName){
+        case 'beforeConfig':
+            console.error('The `beforeConfig` hook has been deprecated. Please define your code directly in the setup function instead.');
+            return;
+        case 'prepare':
+            return 'onPrepare';
+        case 'afterPrepare':
+            return 'onAfterPrepare';
+        case 'beforeGenerateRoutes':
+            return 'onBeforeGenerateRoutes';
+        case 'beforePrintInstructions':
+            return 'onBeforePrintInstructions';
+        case 'resolvedConfig':
+            return 'modifyResolvedConfig';
+        case 'commands':
+            return 'addCommand';
+        case 'watchFiles':
+            return 'addWatchFiles';
+        case 'fileChange':
+            return 'onFileChanged';
+        case 'beforeCreateCompiler':
+            return 'onBeforeCreateCompiler';
+        case 'afterCreateCompiler':
+            return 'onAfterCreateCompiler';
+        case 'beforeBuild':
+            return 'onBeforeBuild';
+        case 'afterBuild':
+            return 'onAfterBuild';
+        case 'beforeDev':
+            return 'onBeforeDev';
+        case 'afterDev':
+            return 'onDevCompileDone';
+        case 'beforeDeploy':
+            return 'onBeforeDeploy';
+        case 'afterDeploy':
+            return 'onAfterDeploy';
+        case 'beforeExit':
+            return 'onBeforeExit';
+        case 'beforeRestart':
+            return 'onBeforeRestart';
+        case 'htmlPartials':
+            return 'modifyHtmlPartials';
+        default:
+            return hookRunnerName;
+    }
+}
+function transformHookParams(hookRunnerName, params) {
+    switch(hookRunnerName){
+        case 'resolvedConfig':
+            return {
+                isMultiple: false,
+                params: {
+                    resolved: params[0]
+                }
+            };
+        case 'htmlPartials':
+            return {
+                isMultiple: false,
+                params: {
+                    partials: {
+                        top: params[0].partials.top.current,
+                        head: params[0].partials.head.current,
+                        body: params[0].partials.body.current
+                    },
+                    entrypoint: params[0].entrypoint
+                }
+            };
+        case 'jestConfig':
+            return {
+                isMultiple: true,
+                params: params
+            };
+        default:
+            return {
+                isMultiple: false,
+                params: params[0]
+            };
+    }
+}
+function transformHookResult(hookRunnerName, result) {
+    switch(hookRunnerName){
+        case 'resolvedConfig':
+            return result.resolved;
+        case 'htmlPartials':
+            return {
+                partials: (0, getHtmlTemplate_js_namespaceObject.getModifyHtmlPartials)(result.partials),
+                entrypoint: result.entrypoint
+            };
+        default:
+            return result;
+    }
+}
+exports.transformHookParams = __webpack_exports__.transformHookParams;
+exports.transformHookResult = __webpack_exports__.transformHookResult;
+exports.transformHookRunner = __webpack_exports__.transformHookRunner;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "transformHookParams",
+    "transformHookResult",
+    "transformHookRunner"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/config/default.js

@@ -0,0 +1,125 @@
+"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__, {
+    createDefaultConfig: ()=>createDefaultConfig
+});
+const utils_namespaceObject = require("@modern-js/utils");
+const env_js_namespaceObject = require("../utils/env.js");
+function createDefaultConfig(appContext) {
+    const dev = {
+        cliShortcuts: {
+            help: false,
+            custom: (shortcuts = [])=>shortcuts.filter(({ key })=>'r' !== key && 'u' !== key && 'o' !== key)
+        }
+    };
+    const output = {
+        distPath: {
+            root: 'dist',
+            html: 'html',
+            js: 'static/js',
+            css: 'static/css',
+            server: 'bundles',
+            worker: 'worker'
+        },
+        cleanDistPath: true,
+        enableInlineRouteManifests: true,
+        disableInlineRouteManifests: false
+    };
+    const source = {
+        entries: void 0,
+        mainEntryName: utils_namespaceObject.DEFAULT_ENTRY_NAME,
+        enableAsyncEntry: false,
+        enableAsyncPreEntry: false,
+        disableDefaultEntries: false,
+        entriesDir: './src',
+        configDir: './config',
+        globalVars: (0, env_js_namespaceObject.getAutoInjectEnv)(appContext),
+        alias: {}
+    };
+    const resolve = {
+        alias: {
+            [appContext.internalDirAlias]: appContext.internalDirectory,
+            [appContext.internalSrcAlias]: appContext.srcDirectory,
+            '@': appContext.srcDirectory,
+            '@shared': appContext.sharedDirectory
+        }
+    };
+    const html = {
+        title: '',
+        mountId: 'root',
+        meta: {
+            charset: {
+                charset: 'utf-8'
+            },
+            viewport: 'width=device-width, initial-scale=1.0, shrink-to-fit=no, viewport-fit=cover, minimum-scale=1.0, maximum-scale=1.0, user-scalable=no',
+            'http-equiv': {
+                'http-equiv': 'x-ua-compatible',
+                content: 'ie=edge'
+            },
+            renderer: 'webkit',
+            layoutmode: 'standard',
+            imagemode: 'force',
+            'wap-font-scale': 'no',
+            'format-detection': 'telephone=no'
+        }
+    };
+    const server = {
+        routes: void 0,
+        publicRoutes: void 0,
+        ssr: void 0,
+        ssrByEntries: void 0,
+        baseUrl: '/',
+        port: 8080
+    };
+    return {
+        source,
+        resolve,
+        output,
+        server,
+        dev,
+        html,
+        tools: {
+            tsChecker: {
+                issue: {
+                    exclude: [
+                        {
+                            file: '**/api/lambda/**/*'
+                        }
+                    ]
+                }
+            }
+        },
+        plugins: [],
+        builderPlugins: []
+    };
+}
+exports.createDefaultConfig = __webpack_exports__.createDefaultConfig;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createDefaultConfig"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});