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

package/dist/esm-node/builder/shared/builderPlugins/adapterSSR.mjs

@@ -0,0 +1,119 @@
+import __rslib_shim_module__ from "node:module";
+const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(/*#__PURE__*/ (()=>import.meta.url)());
+import { resolve, sep } from "path";
+import { SERVICE_WORKER_ENVIRONMENT_NAME, isHtmlDisabled } from "@modern-js/builder";
+import { fs, isUseRsc, isUseSSRBundle } from "@modern-js/utils";
+import { mergeRsbuildConfig } from "@rsbuild/core";
+import { getServerCombinedModueFile } from "../../../plugins/analyze/utils.mjs";
+import { HtmlAsyncChunkPlugin, RouterPlugin } from "../bundlerPlugins/index.mjs";
+const builderPluginAdapterSSR = (options)=>({
+        name: 'builder-plugin-adapter-modern-ssr',
+        setup (api) {
+            const { normalizedConfig } = options;
+            api.modifyRsbuildConfig((config)=>mergeRsbuildConfig(config, {
+                    html: {
+                        inject: isStreamingSSR(normalizedConfig) ? 'head' : void 0
+                    },
+                    server: {
+                        compress: isStreamingSSR(normalizedConfig) || isUseRsc(normalizedConfig) ? false : void 0
+                    }
+                }));
+            api.modifyBundlerChain(async (chain, { target, isProd, HtmlPlugin: HtmlBundlerPlugin, isServer, environment })=>{
+                const builderConfig = environment.config;
+                const { normalizedConfig } = options;
+                applyRouterPlugin(chain, 'route-plugin', options, HtmlBundlerPlugin);
+                const isServiceWorker = environment.name === SERVICE_WORKER_ENVIRONMENT_NAME;
+                if ('node' === target || isServiceWorker) applyFilterEntriesBySSRConfig({
+                    isProd,
+                    chain,
+                    appNormalizedConfig: normalizedConfig
+                });
+                if (isUseSSRBundle(normalizedConfig) || isUseRsc(normalizedConfig)) {
+                    await applySSRLoaderEntry(chain, options, isServer);
+                    applySSRDataLoader(chain, options);
+                }
+                if (!isHtmlDisabled(builderConfig, target)) applyAsyncChunkHtmlPlugin({
+                    chain,
+                    modernConfig: options.normalizedConfig,
+                    HtmlBundlerPlugin
+                });
+            });
+        }
+    });
+const isStreamingSSR = (userConfig)=>{
+    const isStreaming = (ssr)=>{
+        if (!ssr) return false;
+        if ('boolean' == typeof ssr) return ssr;
+        return 'string' !== ssr.mode;
+    };
+    const { server } = userConfig;
+    if (isStreaming(server.ssr)) return true;
+    if (server?.ssrByEntries && 'object' == typeof server.ssrByEntries) {
+        for (const name of Object.keys(server.ssrByEntries))if (isStreaming(server.ssrByEntries[name])) return true;
+    }
+    return false;
+};
+function applyAsyncChunkHtmlPlugin({ chain, modernConfig, HtmlBundlerPlugin }) {
+    if (isStreamingSSR(modernConfig) || isUseRsc(modernConfig)) chain.plugin('html-async-chunk').use(HtmlAsyncChunkPlugin, [
+        HtmlBundlerPlugin
+    ]);
+}
+function applyRouterPlugin(chain, pluginName, options, HtmlBundlerPlugin) {
+    const { appContext, normalizedConfig } = options;
+    const { entrypoints } = appContext;
+    const existNestedRoutes = entrypoints.some((entrypoint)=>entrypoint.nestedRoutesEntry);
+    const workerSSR = Boolean(normalizedConfig.deploy.worker?.ssr);
+    const { enableInlineRouteManifests, disableInlineRouteManifests } = normalizedConfig.output;
+    const inlineRouteManifests = disableInlineRouteManifests ? !disableInlineRouteManifests : enableInlineRouteManifests;
+    if (existNestedRoutes || workerSSR) chain.plugin(pluginName).use(RouterPlugin, [
+        {
+            HtmlBundlerPlugin,
+            enableInlineRouteManifests: inlineRouteManifests,
+            staticJsDir: normalizedConfig.output?.distPath?.js,
+            disableFilenameHash: normalizedConfig.output?.filenameHash === false,
+            scriptLoading: normalizedConfig.html?.scriptLoading,
+            nonce: normalizedConfig.security?.nonce
+        }
+    ]);
+}
+function applyFilterEntriesBySSRConfig({ isProd, chain, appNormalizedConfig }) {
+    const { server: serverConfig, output: outputConfig } = appNormalizedConfig;
+    const entries = chain.entryPoints.entries();
+    if (isProd && (outputConfig?.ssg === true || 'function' == typeof outputConfig?.ssg)) return;
+    if (void 0 === entries) throw new Error('No entry found, one of src/routes/layout.tsx, src/App.tsx, src/index.tsx is required');
+    const entryNames = Object.keys(entries);
+    if (isProd && 1 === entryNames.length && outputConfig?.ssg) return;
+    const ssgEntries = [];
+    if (isProd && outputConfig?.ssgByEntries) {
+        const { ssgByEntries } = outputConfig;
+        entryNames.forEach((name)=>{
+            if (ssgByEntries[name]) ssgEntries.push(name);
+        });
+    }
+    const { ssr, ssrByEntries } = serverConfig || {};
+    entryNames.forEach((name)=>{
+        if (!serverConfig?.rsc && !ssgEntries.includes(name) && !name.includes('server-loaders') && (ssr && ssrByEntries?.[name] === false || !ssr && !ssrByEntries?.[name])) chain.entryPoints.delete(name);
+    });
+}
+async function applySSRLoaderEntry(chain, optinos, isServer) {
+    const { appContext } = optinos;
+    const { internalDirectory } = appContext;
+    const { entrypoints } = appContext;
+    await Promise.all(entrypoints.map(async (entrypoint)=>{
+        const { entryName } = entrypoint;
+        const serverLoadersFile = getServerCombinedModueFile(internalDirectory, entryName);
+        if (isServer) try {
+            await fs.access(serverLoadersFile, fs.constants.F_OK);
+            chain.entry(`${entryName}-server-loaders`).add(serverLoadersFile);
+        } catch (err) {}
+    }));
+}
+function applySSRDataLoader(chain, options) {
+    const { normalizedConfig, appContext } = options;
+    const { appDirectory } = appContext;
+    const { entriesDir = './src' } = normalizedConfig.source;
+    const absolutePath = resolve(appDirectory, entriesDir).split(sep).join('(\\\\|/)');
+    const reg = new RegExp(`${absolutePath}.*\\.(loader|data|data.client)\\.[t|j]sx?$`);
+    chain.module.rule('ssr-data-loader').test(reg).use('data-loader').loader(require.resolve('@modern-js/plugin-data-loader/loader')).end();
+}
+export { builderPluginAdapterSSR };

package/dist/esm-node/builder/shared/builderPlugins/builderHooks.mjs

@@ -0,0 +1,18 @@
+import "node:module";
+const builderPluginAdapterHooks = (options)=>({
+        name: 'builder-plugin-support-modern-hooks',
+        setup (api) {
+            const _internalContext = options.appContext._internalContext;
+            const hooks = _internalContext.pluginAPI?.getHooks();
+            api.modifyBundlerChain(async (chain, utils)=>{
+                await hooks?.modifyBundlerChain.call(chain, utils);
+            });
+            api.modifyRsbuildConfig(async (config, utils)=>{
+                await hooks?.modifyRsbuildConfig.call(config, utils);
+            });
+            api.modifyRspackConfig(async (config, utils)=>{
+                await hooks?.modifyRspackConfig.call(config, utils);
+            });
+        }
+    });
+export { builderPluginAdapterHooks };

package/dist/esm-node/builder/shared/builderPlugins/index.mjs

@@ -0,0 +1,5 @@
+import "node:module";
+export * from "./adapterBasic.mjs";
+export * from "./adapterHtml.mjs";
+export * from "./adapterSSR.mjs";
+export * from "./builderHooks.mjs";

package/dist/esm-node/builder/shared/bundlerPlugins/HtmlAsyncChunkPlugin.mjs

@@ -0,0 +1,38 @@
+import "node:module";
+import { RUNTIME_CHUNK_REGEX } from "@modern-js/builder";
+class HtmlAsyncChunkPlugin {
+    apply(compiler) {
+        compiler.hooks.compilation.tap(this.name, (compilation)=>{
+            const hooks = this.htmlPlugin.getCompilationHooks(compilation);
+            hooks.alterAssetTagGroups.tap(this.name, (assets)=>{
+                const headTags = [];
+                const bodyTags = [];
+                const processScriptTag = (tag)=>{
+                    const { attributes } = tag;
+                    if (attributes && true === attributes.defer) {
+                        attributes.async = true;
+                        delete attributes.defer;
+                    }
+                    const src = attributes?.src;
+                    const isRuntimeChunk = src && RUNTIME_CHUNK_REGEX.test(src);
+                    return isRuntimeChunk ? bodyTags : headTags;
+                };
+                for (const tag of [
+                    ...assets.headTags,
+                    ...assets.bodyTags
+                ])if ("script" === tag.tagName) processScriptTag(tag).push(tag);
+                else (assets.headTags.includes(tag) ? headTags : bodyTags).push(tag);
+                return {
+                    ...assets,
+                    headTags,
+                    bodyTags
+                };
+            });
+        });
+    }
+    constructor(htmlPlugin){
+        this.name = 'HtmlAsyncChunkPlugin';
+        this.htmlPlugin = htmlPlugin;
+    }
+}
+export { HtmlAsyncChunkPlugin };

package/dist/esm-node/builder/shared/bundlerPlugins/HtmlBottomTemplate.mjs

@@ -0,0 +1,23 @@
+import "node:module";
+class BottomTemplatePlugin {
+    apply(compiler) {
+        compiler.hooks.compilation.tap(this.name, (compilation)=>{
+            this.htmlPlugin.getCompilationHooks(compilation).beforeEmit.tap(this.name, (data)=>{
+                if (!data.plugin.options?.__internal__) return data;
+                if (this.bottomTemplateReg.test(data.html)) {
+                    data.html = data.html.replace(this.bottomTemplateReg, '');
+                    const { bottomTemplate } = data.plugin.options;
+                    if (bottomTemplate) data.html = data.html.replace(this.bodyRegExp, (match)=>`\n${bottomTemplate}\n${match}`);
+                }
+                return data;
+            });
+        });
+    }
+    constructor(htmlPlugin){
+        this.bottomTemplateReg = /<!--<\?-\s*bottomTemplate\s*\?>-->/;
+        this.bodyRegExp = /(<\/\s*body\s*>)/i;
+        this.htmlPlugin = htmlPlugin;
+        this.name = 'bottom-template';
+    }
+}
+export { BottomTemplatePlugin };

package/dist/esm-node/builder/shared/bundlerPlugins/RouterPlugin.mjs

@@ -0,0 +1,158 @@
+import "node:module";
+import { createHash } from "crypto";
+import { ROUTE_MANIFEST_FILE } from "@modern-js/utils";
+import { merge, mergeWith } from "@modern-js/utils/lodash";
+import { ROUTE_MANIFEST } from "@modern-js/utils/universal/constants";
+const PLUGIN_NAME = 'ModernjsRoutePlugin';
+const generateContentHash = (content)=>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(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]) 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];
+                    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.${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(ROUTE_MANIFEST_FILE, new RawSource(JSON.stringify(manifest, null, 2)), void 0);
+                else compilation.emitAsset(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;
+    }
+}
+export { RouterPlugin };

package/dist/esm-node/builder/shared/bundlerPlugins/index.mjs

@@ -0,0 +1,4 @@
+import "node:module";
+export * from "./HtmlAsyncChunkPlugin.mjs";
+export * from "./HtmlBottomTemplate.mjs";
+export * from "./RouterPlugin.mjs";

package/dist/esm-node/builder/shared/createCopyInfo.mjs

@@ -0,0 +1,16 @@
+import "node:module";
+import path from "path";
+import { resolvePublicDirPaths } from "@modern-js/server-core";
+function createCopyInfo(appContext, config) {
+    const configDir = path.resolve(appContext.appDirectory, config.source.configDir || './config');
+    const uploadDir = path.posix.join(configDir.replace(/\\/g, '/'), 'upload');
+    const publicDir = path.posix.join(configDir.replace(/\\/g, '/'), 'public');
+    const customPublicDirPaths = resolvePublicDirPaths(config.server?.publicDir, appContext.appDirectory);
+    return {
+        configDir,
+        uploadDir,
+        publicDir,
+        customPublicDirs: customPublicDirPaths
+    };
+}
+export { createCopyInfo };

package/dist/esm-node/builder/shared/index.mjs

@@ -0,0 +1,4 @@
+import "node:module";
+export * from "./types.mjs";
+export * from "./builderPlugins/index.mjs";
+export * from "./createCopyInfo.mjs";

package/dist/esm-node/builder/shared/loaders/serverModuleLoader.mjs

@@ -0,0 +1,6 @@
+import "node:module";
+function loader() {
+    return "module.exports = {}";
+}
+const serverModuleLoader = loader;
+export { serverModuleLoader as default };

package/dist/esm-node/builder/shared/types.mjs

@@ -0,0 +1 @@
+import "node:module";

package/dist/esm-node/commands/build.mjs

@@ -0,0 +1,69 @@
+import "node:module";
+import { fs, logger } from "@modern-js/utils";
+import { loadServerPlugins } from "../utils/loadPlugins.mjs";
+import { setupTsRuntime } from "../utils/register.mjs";
+import { generateRoutes } from "../utils/routes.mjs";
+import * as __rspack_external_node_path_c5b9b54f from "node:path";
+async function copyEnvFiles(appDirectory, distDirectory) {
+    try {
+        const files = await fs.readdir(appDirectory);
+        const envFileRegex = /^\.env(\.[a-zA-Z0-9_-]+)*$/;
+        const envFiles = files.filter((file)=>envFileRegex.test(file));
+        if (0 === envFiles.length) return void logger.debug('No .env files found to copy');
+        const copyPromises = envFiles.map(async (envFile)=>{
+            const sourcePath = __rspack_external_node_path_c5b9b54f["default"].resolve(appDirectory, envFile);
+            const targetPath = __rspack_external_node_path_c5b9b54f["default"].resolve(distDirectory, envFile);
+            try {
+                const stat = await fs.stat(sourcePath);
+                if (stat.isDirectory()) return;
+                await fs.copy(sourcePath, targetPath);
+            } catch (error) {
+                logger.warn(`Failed to copy ${envFile}:`, error);
+            }
+        });
+        await Promise.all(copyPromises);
+    } catch (error) {
+        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 loadServerPlugins(api, appContext.appDirectory, appContext.metaName);
+    if (appContext.moduleType && 'module' === appContext.moduleType) {
+        const { registerModuleHooks } = await import("../esm/register-esm.mjs");
+        await registerModuleHooks({
+            appDir: appContext.appDirectory,
+            distDir: appContext.distDirectory,
+            alias: {}
+        });
+    }
+    await setupTsRuntime(appContext.appDirectory, appContext.distDirectory, combinedAlias);
+    const { apiOnly } = appContext;
+    if (apiOnly) {
+        await hooks.onBeforeBuild.call({
+            environments: {},
+            bundlerConfigs: void 0,
+            isFirstCompile: false,
+            isWatch: false
+        });
+        await generateRoutes(appContext);
+        await hooks.onAfterBuild.call({
+            environments: {},
+            stats: void 0,
+            isFirstCompile: false,
+            isWatch: false
+        });
+        return;
+    }
+    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
+    });
+};
+export { build };

package/dist/esm-node/commands/deploy.mjs

@@ -0,0 +1,11 @@
+import "node:module";
+import { getServerPlugins } from "../utils/loadPlugins.mjs";
+const deploy = async (api, options)=>{
+    const hooks = api.getHooks();
+    const { metaName } = api.getAppContext();
+    await getServerPlugins(api, metaName);
+    await hooks.onBeforeDeploy.call(options);
+    await hooks.deploy.call();
+    await hooks.onAfterDeploy.call(options);
+};
+export { deploy };

package/dist/esm-node/commands/dev.mjs

@@ -0,0 +1,83 @@
+import "node:module";
+import { createDevServer } from "@modern-js/server";
+import { DEFAULT_DEV_HOST, SERVER_DIR, getMeta, logger } from "@modern-js/utils";
+import { setServer } from "../utils/createServer.mjs";
+import { loadServerPlugins } from "../utils/loadPlugins.mjs";
+import { printInstructions } from "../utils/printInstructions.mjs";
+import { setupTsRuntime } from "../utils/register.mjs";
+import { generateRoutes } from "../utils/routes.mjs";
+import * as __rspack_external_node_path_c5b9b54f from "node:path";
+import * as __rspack_external__modern_js_prod_server_057184e2 from "@modern-js/prod-server";
+const dev = async (api, options, devServerOptions)=>{
+    if (options.analyze) process.env.BUNDLE_ANALYZE = 'true';
+    const normalizedConfig = api.getNormalizedConfig();
+    const appContext = api.getAppContext();
+    const hooks = api.getHooks();
+    const combinedAlias = [].concat(normalizedConfig?.resolve?.alias ?? []).concat(normalizedConfig?.source?.alias ?? []);
+    if (appContext.moduleType && 'module' === appContext.moduleType) {
+        const { registerModuleHooks } = await import("../esm/register-esm.mjs");
+        await registerModuleHooks({
+            appDir: appContext.appDirectory,
+            distDir: appContext.distDirectory,
+            alias: {}
+        });
+    }
+    await setupTsRuntime(appContext.appDirectory, appContext.distDirectory, combinedAlias);
+    const { appDirectory, port, apiOnly, metaName, serverRoutes } = appContext;
+    const meta = getMeta(metaName);
+    const serverConfigPath = __rspack_external_node_path_c5b9b54f["default"].resolve(appDirectory, SERVER_DIR, `${meta}.server`);
+    await hooks.onBeforeDev.call();
+    if (!appContext.builder && !apiOnly) throw new Error('Expect the Builder to have been initialized, But the appContext.builder received `undefined`');
+    await generateRoutes(appContext);
+    const pluginInstances = await loadServerPlugins(api, appDirectory, metaName);
+    const serverOptions = {
+        metaName,
+        dev: {
+            https: normalizedConfig.dev.https,
+            setupMiddlewares: normalizedConfig.dev.setupMiddlewares
+        },
+        appContext: {
+            appDirectory,
+            internalDirectory: appContext.internalDirectory,
+            apiDirectory: appContext.apiDirectory,
+            lambdaDirectory: appContext.lambdaDirectory,
+            sharedDirectory: appContext.sharedDirectory,
+            bffRuntimeFramework: appContext.bffRuntimeFramework
+        },
+        serverConfigPath,
+        routes: serverRoutes,
+        pwd: appDirectory,
+        config: normalizedConfig,
+        plugins: pluginInstances,
+        ...devServerOptions
+    };
+    const host = normalizedConfig.dev?.host || DEFAULT_DEV_HOST;
+    if (apiOnly) {
+        const { server } = await createDevServer({
+            ...serverOptions,
+            runCompile: false
+        }, devServerOptions?.applyPlugins || __rspack_external__modern_js_prod_server_057184e2.applyPlugins);
+        server.listen({
+            port,
+            host
+        }, ()=>{
+            printInstructions(hooks, appContext, normalizedConfig);
+        });
+        setServer(server);
+    } else {
+        const { server, afterListen } = await createDevServer({
+            ...serverOptions,
+            builder: appContext.builder
+        }, devServerOptions?.applyPlugins || __rspack_external__modern_js_prod_server_057184e2.applyPlugins);
+        server.listen({
+            port,
+            host
+        }, async (err)=>{
+            if (err) logger.error('Occur error %s, when start dev server', err);
+            logger.debug('listen dev server done');
+            await afterListen();
+        });
+        setServer(server);
+    }
+};
+export { dev };

package/dist/esm-node/commands/index.mjs

@@ -0,0 +1,44 @@
+import "node:module";
+import { i18n, localeKeys } from "../locale/index.mjs";
+const devCommand = async (program, api)=>{
+    program.command('dev').alias('start').usage('[options]').description(i18n.t(localeKeys.command.dev.describe)).option('-c --config <config>', i18n.t(localeKeys.command.shared.config)).option('-e --entry [entry...]', i18n.t(localeKeys.command.dev.entry)).option('--analyze', i18n.t(localeKeys.command.shared.analyze)).option('--api-only', i18n.t(localeKeys.command.dev.apiOnly)).option('--web-only', i18n.t(localeKeys.command.dev.webOnly)).action(async (options)=>{
+        const { dev } = await import("./dev.mjs");
+        await dev(api, options);
+    });
+};
+const buildCommand = async (program, api)=>{
+    program.command('build').usage('[options]').description(i18n.t(localeKeys.command.build.describe)).option('-c --config <config>', i18n.t(localeKeys.command.shared.config)).option('--analyze', i18n.t(localeKeys.command.shared.analyze)).option('-w --watch', i18n.t(localeKeys.command.build.watch)).action(async (options)=>{
+        const { build } = await import("./build.mjs");
+        await build(api, options);
+    });
+};
+const serverCommand = (program, api)=>{
+    program.command('serve').usage('[options]').description(i18n.t(localeKeys.command.serve.describe)).option('--api-only', i18n.t(localeKeys.command.dev.apiOnly)).option('-c --config <config>', i18n.t(localeKeys.command.shared.config)).action(async ()=>{
+        const { serve } = await import("./serve.mjs");
+        await serve(api);
+    });
+};
+const deployCommand = (program, api)=>{
+    program.command('deploy').usage('[options]').option('-c --config <config>', i18n.t(localeKeys.command.shared.config)).option('-s --skip-build', i18n.t(localeKeys.command.shared.skipBuild)).description(i18n.t(localeKeys.command.deploy.describe)).action(async (options)=>{
+        if (!options.skipBuild) {
+            const { build } = await import("./build.mjs");
+            await build(api);
+        }
+        const { deploy } = await import("./deploy.mjs");
+        await deploy(api, options);
+        process.exit(0);
+    });
+};
+const inspectCommand = (program, api)=>{
+    program.command('inspect').description('inspect the internal configs').option("--env <env>", i18n.t(localeKeys.command.inspect.env), 'development').option('--output <output>', i18n.t(localeKeys.command.inspect.output), './').option('--verbose', i18n.t(localeKeys.command.inspect.verbose)).option('-c --config <config>', i18n.t(localeKeys.command.shared.config)).action(async (options)=>{
+        const { inspect } = await import("./inspect.mjs");
+        inspect(api, options);
+    });
+};
+const infoCommand = (program, api)=>{
+    program.command('info').usage('[options]').description(i18n.t(localeKeys.command.info.describe)).option('-c --config <config>', i18n.t(localeKeys.command.shared.config)).option('--json', 'output as JSON format for machine reading').action(async (options)=>{
+        const { info } = await import("./info.mjs");
+        await info(api, options);
+    });
+};
+export { buildCommand, deployCommand, devCommand, infoCommand, inspectCommand, serverCommand };