@modern-js/app-tools 3.0.0-beta.0 → 3.0.0

package/dist/cjs/builder/shared/bundlerPlugins/RouterPlugin.js

@@ -0,0 +1,191 @@
+"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__, {
+    RouterPlugin: ()=>RouterPlugin
+});
+const external_crypto_namespaceObject = require("crypto");
+const utils_namespaceObject = require("@modern-js/utils");
+const lodash_namespaceObject = require("@modern-js/utils/lodash");
+const constants_namespaceObject = require("@modern-js/utils/universal/constants");
+const PLUGIN_NAME = 'ModernjsRoutePlugin';
+const generateContentHash = (content)=>(0, external_crypto_namespaceObject.createHash)('md5').update(content).digest('hex').slice(0, 8);
+class RouterPlugin {
+    isTargetNodeOrWebWorker(target) {
+        if ('node' === target || Array.isArray(target) && target.includes('node')) return true;
+        if ('webworker' === target || Array.isArray(target) && target.includes('webworker')) return true;
+        return false;
+    }
+    getEntryChunks(compilation, chunks) {
+        const entrypointsArray = Array.from(compilation.entrypoints.entries());
+        const entryChunkIds = entrypointsArray.map((entrypoint)=>entrypoint[0]);
+        const entryChunks = [
+            ...chunks
+        ].filter((chunk)=>chunk.names?.some((name)=>entryChunkIds.includes(name)));
+        return entryChunks;
+    }
+    getEntryChunkFiles(entryChunks) {
+        return entryChunks.map((chunk)=>[
+                ...chunk.files || []
+            ].find((fname)=>fname.includes('.js')));
+    }
+    apply(compiler) {
+        const { target } = compiler.options;
+        if (this.isTargetNodeOrWebWorker(target)) return;
+        const { rspack } = compiler;
+        const { Compilation, sources } = rspack;
+        const { RawSource } = sources;
+        const normalizePath = (path)=>{
+            if (!path.endsWith('/')) return `${path}/`;
+            return path;
+        };
+        const chunksToHtmlName = new Map();
+        const ROUTE_MANIFEST_HOLDER = "route-manifest";
+        const placeholder = `<!--<?- ${ROUTE_MANIFEST_HOLDER} ?>-->`;
+        compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation)=>{
+            this.HtmlBundlerPlugin.getCompilationHooks(compilation).beforeEmit.tapAsync('RouterManifestPlugin', (data, callback)=>{
+                const { outputName } = data;
+                const { chunks } = data.plugin.options;
+                chunksToHtmlName.set(chunks, outputName);
+                data.html = data.html.replace("<\/script>", `</script>${placeholder}`);
+                callback(null, data);
+            });
+            compilation.hooks.processAssets.tapPromise({
+                name: PLUGIN_NAME,
+                stage: Compilation.PROCESS_ASSETS_STAGE_REPORT
+            }, async ()=>{
+                const stats = compilation.getStats().toJson({
+                    all: false,
+                    publicPath: true,
+                    assets: true,
+                    chunkGroups: true,
+                    chunks: true,
+                    ids: true
+                });
+                const { publicPath, chunks = [], namedChunkGroups } = stats;
+                const routeAssets = {};
+                if (!namedChunkGroups) return;
+                const prevManifestAsset = compilation.getAsset(utils_namespaceObject.ROUTE_MANIFEST_FILE);
+                const prevManifestStr = prevManifestAsset ? prevManifestAsset.source.source().toString() : JSON.stringify({
+                    routeAssets: {}
+                });
+                const prevManifest = JSON.parse(prevManifestStr);
+                const asyncEntryNames = [];
+                for (const [name, chunkGroup] of Object.entries(namedChunkGroups)){
+                    if (name.startsWith('async-')) asyncEntryNames.push(name);
+                    const assets = chunkGroup.assets.map((asset)=>{
+                        const filename = asset.name;
+                        return publicPath ? normalizePath(publicPath) + filename : filename;
+                    });
+                    const referenceCssAssets = assets.filter((asset)=>/\.css$/.test(asset));
+                    routeAssets[name] = {
+                        chunkIds: chunkGroup.chunks,
+                        assets,
+                        referenceCssAssets
+                    };
+                    if (prevManifest.routeAssets[name]) (0, lodash_namespaceObject.mergeWith)(routeAssets[name], prevManifest.routeAssets[name], (obj, source)=>{
+                        if (Array.isArray(obj)) return obj.concat(source);
+                        return Object.assign(source, obj);
+                    });
+                }
+                if (asyncEntryNames.length > 0) for (const asyncEntryName of asyncEntryNames){
+                    const syncEntryName = asyncEntryName.replace('async-', '');
+                    const syncEntry = routeAssets[syncEntryName];
+                    const asyncEntry = routeAssets[asyncEntryName];
+                    (0, lodash_namespaceObject.merge)(syncEntry, asyncEntry);
+                }
+                const manifest = {
+                    routeAssets
+                };
+                const entryNames = Array.from(compilation.entrypoints.keys());
+                let entryChunks = [];
+                entryChunks = this.getEntryChunks(compilation, chunks);
+                const entryChunkFiles = this.getEntryChunkFiles(entryChunks);
+                const entryChunkFileIds = entryChunks.map((chunk)=>chunk.id);
+                for(let i = 0; i < entryChunkFiles.length; i++){
+                    const entryName = entryNames[i];
+                    const file = entryChunkFiles[i];
+                    const chunkNames = entryChunks[i].names;
+                    const chunkId = entryChunkFileIds[i];
+                    const asset = compilation.assets[file];
+                    if (!asset || !chunkId) continue;
+                    let relatedAssets = {};
+                    if (entryChunkFiles.length > 1) Object.keys(routeAssets).forEach((routeId)=>{
+                        const segments = routeId.split('_');
+                        const chunkName = segments[0];
+                        if (chunkNames?.includes(chunkName)) relatedAssets[routeId] = routeAssets[routeId];
+                    });
+                    else relatedAssets = routeAssets;
+                    const manifest = {
+                        routeAssets: relatedAssets
+                    };
+                    const injectedContent = `
+            ;(function(){
+              window.${constants_namespaceObject.ROUTE_MANIFEST} = ${JSON.stringify(manifest, (k, v)=>{
+                        if (('assets' === k || 'referenceCssAssets' === k) && Array.isArray(v)) return v.map((item)=>item.replace(publicPath, ''));
+                        return v;
+                    })};
+            })();
+          `;
+                    let htmlName;
+                    for (const [chunks, name] of chunksToHtmlName.entries())if (Array.isArray(chunkNames) && Array.isArray(chunks) && chunkNames.every((value, index)=>value === chunks[index])) {
+                        htmlName = name;
+                        break;
+                    }
+                    const oldHtml = compilation.assets[htmlName];
+                    const { enableInlineRouteManifests, disableFilenameHash, staticJsDir, scriptLoading, nonce } = this;
+                    const nonceAttr = nonce ? `nonce="${nonce}"` : '';
+                    if (oldHtml) if (enableInlineRouteManifests) compilation.updateAsset(htmlName, new RawSource(oldHtml.source().toString().replace(placeholder, `<script ${nonceAttr}>${injectedContent}</script>`)), void 0);
+                    else {
+                        const scriptPath = `${staticJsDir}/${ROUTE_MANIFEST_HOLDER}-${entryName}${disableFilenameHash ? '.js' : `.${generateContentHash(injectedContent)}.js`}`;
+                        const scriptUrl = `${publicPath}${scriptPath}`;
+                        const scriptLoadingAttr = 'defer' === scriptLoading ? scriptLoading : 'module' === scriptLoading ? 'type="module"' : '';
+                        const script = `<script ${scriptLoadingAttr} ${nonceAttr} src="${scriptUrl}"></script>`;
+                        compilation.updateAsset(htmlName, new RawSource(oldHtml.source().toString().replace(placeholder, script)), void 0);
+                        compilation.emitAsset(scriptPath, new RawSource(injectedContent));
+                    }
+                }
+                if (prevManifestAsset) compilation.updateAsset(utils_namespaceObject.ROUTE_MANIFEST_FILE, new RawSource(JSON.stringify(manifest, null, 2)), void 0);
+                else compilation.emitAsset(utils_namespaceObject.ROUTE_MANIFEST_FILE, new RawSource(JSON.stringify(manifest, null, 2)));
+            });
+        });
+    }
+    constructor({ staticJsDir = 'static/js', HtmlBundlerPlugin, enableInlineRouteManifests, disableFilenameHash = false, scriptLoading = 'defer', nonce }){
+        this.name = 'RouterPlugin';
+        this.HtmlBundlerPlugin = HtmlBundlerPlugin;
+        this.enableInlineRouteManifests = enableInlineRouteManifests;
+        this.staticJsDir = staticJsDir;
+        this.disableFilenameHash = disableFilenameHash;
+        this.scriptLoading = scriptLoading;
+        this.nonce = nonce;
+    }
+}
+exports.RouterPlugin = __webpack_exports__.RouterPlugin;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "RouterPlugin"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/builder/shared/bundlerPlugins/index.js

@@ -0,0 +1,72 @@
+"use strict";
+var __webpack_modules__ = {
+    "./HtmlAsyncChunkPlugin" (module) {
+        module.exports = require("./HtmlAsyncChunkPlugin.js");
+    },
+    "./HtmlBottomTemplate" (module) {
+        module.exports = require("./HtmlBottomTemplate.js");
+    },
+    "./RouterPlugin" (module) {
+        module.exports = require("./RouterPlugin.js");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __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__);
+    var _HtmlAsyncChunkPlugin__rspack_import_0 = __webpack_require__("./HtmlAsyncChunkPlugin");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _HtmlAsyncChunkPlugin__rspack_import_0)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_HtmlAsyncChunkPlugin__rspack_import_0[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _HtmlBottomTemplate__rspack_import_1 = __webpack_require__("./HtmlBottomTemplate");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _HtmlBottomTemplate__rspack_import_1)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_HtmlBottomTemplate__rspack_import_1[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _RouterPlugin__rspack_import_2 = __webpack_require__("./RouterPlugin");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _RouterPlugin__rspack_import_2)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_RouterPlugin__rspack_import_2[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+})();
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/builder/shared/createCopyInfo.js

@@ -0,0 +1,59 @@
+"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__, {
+    createCopyInfo: ()=>createCopyInfo
+});
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const server_core_namespaceObject = require("@modern-js/server-core");
+function createCopyInfo(appContext, config) {
+    const configDir = external_path_default().resolve(appContext.appDirectory, config.source.configDir || './config');
+    const uploadDir = external_path_default().posix.join(configDir.replace(/\\/g, '/'), 'upload');
+    const publicDir = external_path_default().posix.join(configDir.replace(/\\/g, '/'), 'public');
+    const customPublicDirPaths = (0, server_core_namespaceObject.resolvePublicDirPaths)(config.server?.publicDir, appContext.appDirectory);
+    return {
+        configDir,
+        uploadDir,
+        publicDir,
+        customPublicDirs: customPublicDirPaths
+    };
+}
+exports.createCopyInfo = __webpack_exports__.createCopyInfo;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createCopyInfo"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/builder/shared/index.js

@@ -0,0 +1,72 @@
+"use strict";
+var __webpack_modules__ = {
+    "./builderPlugins" (module) {
+        module.exports = require("./builderPlugins/index.js");
+    },
+    "./createCopyInfo" (module) {
+        module.exports = require("./createCopyInfo.js");
+    },
+    "./types?fbf6" (module) {
+        module.exports = require("./types.js");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __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__);
+    var _types__rspack_import_0 = __webpack_require__("./types?fbf6");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _types__rspack_import_0)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_types__rspack_import_0[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _builderPlugins__rspack_import_1 = __webpack_require__("./builderPlugins");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _builderPlugins__rspack_import_1)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_builderPlugins__rspack_import_1[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _createCopyInfo__rspack_import_2 = __webpack_require__("./createCopyInfo");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _createCopyInfo__rspack_import_2)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_createCopyInfo__rspack_import_2[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+})();
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/builder/shared/loaders/serverModuleLoader.js

@@ -0,0 +1,39 @@
+"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__, {
+    default: ()=>__rspack_default_export
+});
+function loader() {
+    return "module.exports = {}";
+}
+const __rspack_default_export = loader;
+exports["default"] = __webpack_exports__["default"];
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "default"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/builder/shared/types.js

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__);
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/commands/build.js

@@ -0,0 +1,112 @@
+"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__, {
+    build: ()=>build
+});
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const utils_namespaceObject = require("@modern-js/utils");
+const loadPlugins_js_namespaceObject = require("../utils/loadPlugins.js");
+const register_js_namespaceObject = require("../utils/register.js");
+const routes_js_namespaceObject = require("../utils/routes.js");
+async function copyEnvFiles(appDirectory, distDirectory) {
+    try {
+        const files = await utils_namespaceObject.fs.readdir(appDirectory);
+        const envFileRegex = /^\.env(\.[a-zA-Z0-9_-]+)*$/;
+        const envFiles = files.filter((file)=>envFileRegex.test(file));
+        if (0 === envFiles.length) return void utils_namespaceObject.logger.debug('No .env files found to copy');
+        const copyPromises = envFiles.map(async (envFile)=>{
+            const sourcePath = external_node_path_default().resolve(appDirectory, envFile);
+            const targetPath = external_node_path_default().resolve(distDirectory, envFile);
+            try {
+                const stat = await utils_namespaceObject.fs.stat(sourcePath);
+                if (stat.isDirectory()) return;
+                await utils_namespaceObject.fs.copy(sourcePath, targetPath);
+            } catch (error) {
+                utils_namespaceObject.logger.warn(`Failed to copy ${envFile}:`, error);
+            }
+        });
+        await Promise.all(copyPromises);
+    } catch (error) {
+        utils_namespaceObject.logger.warn('Failed to copy .env files:', error);
+    }
+}
+const build = async (api, options)=>{
+    if (options?.analyze) process.env.BUNDLE_ANALYZE = 'true';
+    const resolvedConfig = api.getNormalizedConfig();
+    const appContext = api.getAppContext();
+    const hooks = api.getHooks();
+    const combinedAlias = [].concat(resolvedConfig?.resolve?.alias ?? []).concat(resolvedConfig?.source?.alias ?? []);
+    await (0, loadPlugins_js_namespaceObject.loadServerPlugins)(api, appContext.appDirectory, appContext.metaName);
+    if (appContext.moduleType && 'module' === appContext.moduleType) {
+        const { registerModuleHooks } = await import("../esm/register-esm.js");
+        await registerModuleHooks({
+            appDir: appContext.appDirectory,
+            distDir: appContext.distDirectory,
+            alias: {}
+        });
+    }
+    await (0, register_js_namespaceObject.setupTsRuntime)(appContext.appDirectory, appContext.distDirectory, combinedAlias);
+    const { apiOnly } = appContext;
+    if (apiOnly) {
+        await hooks.onBeforeBuild.call({
+            environments: {},
+            bundlerConfigs: void 0,
+            isFirstCompile: false,
+            isWatch: false
+        });
+        await (0, routes_js_namespaceObject.generateRoutes)(appContext);
+        await hooks.onAfterBuild.call({
+            environments: {},
+            stats: void 0,
+            isFirstCompile: false,
+            isWatch: false
+        });
+        return;
+    }
+    utils_namespaceObject.logger.info('Starting production build...');
+    if (!appContext.builder) throw new Error('Expect the Builder to have been initialized, But the appContext.builder received `undefined`');
+    await appContext.builder.onAfterBuild(async ()=>copyEnvFiles(appContext.appDirectory, appContext.distDirectory));
+    await appContext.builder.build({
+        watch: options?.watch
+    });
+};
+exports.build = __webpack_exports__.build;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "build"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/commands/deploy.js

@@ -0,0 +1,44 @@
+"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__, {
+    deploy: ()=>deploy
+});
+const loadPlugins_js_namespaceObject = require("../utils/loadPlugins.js");
+const deploy = async (api, options)=>{
+    const hooks = api.getHooks();
+    const { metaName } = api.getAppContext();
+    await (0, loadPlugins_js_namespaceObject.getServerPlugins)(api, metaName);
+    await hooks.onBeforeDeploy.call(options);
+    await hooks.deploy.call();
+    await hooks.onAfterDeploy.call(options);
+};
+exports.deploy = __webpack_exports__.deploy;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "deploy"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});