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

package/dist/esm-node/locale/zh.mjs

@@ -0,0 +1,46 @@
+import "node:module";
+const ZH_LOCALE = {
+    command: {
+        shared: {
+            analyze: '分析构建产物体积，查看各个模块打包后的大小',
+            config: '指定配置文件路径，可以为相对路径或绝对路径',
+            skipBuild: '跳过构建阶段',
+            noNeedInstall: '无需安装依赖'
+        },
+        dev: {
+            describe: '启动开发服务器',
+            entry: '指定入口，编译特定的页面',
+            apiOnly: '仅启动 API 接口服务',
+            webOnly: '仅启动 Web 服务',
+            selectEntry: '请选择需要构建的入口',
+            requireEntry: '请至少选择一个入口'
+        },
+        build: {
+            describe: '构建生产环境产物',
+            watch: '开启 watch 模式, 监听文件变更并重新构建'
+        },
+        serve: {
+            describe: '启动生产环境服务'
+        },
+        deploy: {
+            describe: '部署应用'
+        },
+        new: {
+            describe: 'Web App 项目中执行生成器',
+            debug: '开启 Debug 模式，打印调试日志信息',
+            config: '生成器运行默认配置(JSON 字符串)',
+            distTag: '生成器使用特殊的 npm Tag 版本',
+            registry: '生成器运行过程中定制 npm Registry',
+            lang: '设置 new 命令执行语言(zh 或者 en)'
+        },
+        inspect: {
+            env: '查看指定环境下的配置',
+            output: '指定在 dist 目录下输出的路径',
+            verbose: '在结果中展示函数的完整内容'
+        },
+        info: {
+            describe: '展示项目信息'
+        }
+    }
+};
+export { ZH_LOCALE };

package/dist/esm-node/plugins/analyze/constants.mjs

@@ -0,0 +1,9 @@
+import "node:module";
+const ENTRY_FILE_NAME = 'entry';
+const HTML_PARTIALS_FOLDER = 'html';
+const HTML_PARTIALS_EXTENSIONS = [
+    '.htm',
+    '.html',
+    '.ejs'
+];
+export { ENTRY_FILE_NAME, HTML_PARTIALS_EXTENSIONS, HTML_PARTIALS_FOLDER };

package/dist/esm-node/plugins/analyze/getBundleEntry.mjs

@@ -0,0 +1,54 @@
+import "node:module";
+import { JS_EXTENSIONS, MAIN_ENTRY_NAME, ensureAbsolutePath, findExists, fs } from "@modern-js/utils";
+import path from "path";
+import { getFileSystemEntry, hasEntry, hasServerEntry } from "./getFileSystemEntry.mjs";
+import { isSubDirOrEqual } from "./utils.mjs";
+const ensureExtensions = (file)=>{
+    if (!path.extname(file)) return findExists(JS_EXTENSIONS.map((ext)=>`${file}${ext}`)) || file;
+    return file;
+};
+const isDirectory = (file)=>!path.extname(file);
+const ifAlreadyExists = (entrypoints, checked)=>entrypoints.some((entrypoint)=>{
+        if (ensureExtensions(entrypoint.entry) === ensureExtensions(checked.entry)) {
+            checked.entryName = entrypoint.entryName;
+            return true;
+        }
+        if (isSubDirOrEqual(entrypoint.entry, checked.entry) || isSubDirOrEqual(checked.entry, entrypoint.entry)) throw new Error(`Entry configuration conflicts\n Your configuration: ${checked.entry}.\n Default entrypoint: ${entrypoint.entry}\n Please reset source.entries or set source.disableDefaultEntries to disable the default entry rules.`);
+        return false;
+    });
+const getBundleEntry = async (hooks, appContext, config)=>{
+    const { appDirectory, packageName } = appContext;
+    const { disableDefaultEntries, entries, entriesDir, mainEntryName } = config.source;
+    const defaults = disableDefaultEntries ? [] : await getFileSystemEntry(hooks, appContext, config);
+    if (entries) Object.keys(entries).forEach((name)=>{
+        const value = entries[name];
+        const entryName = 'string' == typeof value ? value : value.entry;
+        const entryFile = ensureAbsolutePath(appDirectory, entryName);
+        const entryDir = path.dirname(entryFile);
+        const customEntryFile = hasEntry(entryDir);
+        const serverEntryFile = hasServerEntry(entryDir);
+        const isAutoMount = 'string' == typeof value ? true : !value.disableMount;
+        const entrypoint = {
+            entryName: name,
+            isMainEntry: false,
+            entry: 'string' == typeof value ? entryFile : value.customEntry ? customEntryFile || entryFile : entryFile,
+            absoluteEntryDir: isDirectory(entryFile) ? entryFile : path.dirname(entryFile),
+            isAutoMount,
+            fileSystemRoutes: fs.statSync(entryFile).isDirectory() ? {} : void 0,
+            isCustomSourceEntry: true,
+            customEntry: 'string' == typeof value ? false : value.customEntry,
+            customServerEntry: 'string' == typeof value ? false : value.customEntry ? serverEntryFile : false
+        };
+        if (!ifAlreadyExists(defaults, entrypoint)) defaults.push(entrypoint);
+    });
+    if (!disableDefaultEntries) {
+        const entriesDirAbs = ensureAbsolutePath(appDirectory, entriesDir || '');
+        const found = defaults.find(({ entryName, entry, nestedRoutesEntry = '' })=>entryName === packageName || path.dirname(entry) === entriesDirAbs || path.dirname(nestedRoutesEntry) === entriesDirAbs);
+        if (found) {
+            found.entryName = mainEntryName || MAIN_ENTRY_NAME;
+            found.isMainEntry = true;
+        }
+    }
+    return defaults;
+};
+export { getBundleEntry };

package/dist/esm-node/plugins/analyze/getFileSystemEntry.mjs

@@ -0,0 +1,67 @@
+import "node:module";
+import { JS_EXTENSIONS, ensureAbsolutePath, findExists } from "@modern-js/utils";
+import fs from "fs";
+import path from "path";
+import { ENTRY_FILE_NAME } from "./constants.mjs";
+const hasEntry = (dir)=>findExists(JS_EXTENSIONS.map((ext)=>path.resolve(dir, `${ENTRY_FILE_NAME}${ext}`)));
+const hasServerEntry = (dir)=>findExists(JS_EXTENSIONS.map((ext)=>path.resolve(dir, `${ENTRY_FILE_NAME}.server${ext}`)));
+const isBundleEntry = async (hooks, dir)=>{
+    const { entry } = await hooks.checkEntryPoint.call({
+        path: dir,
+        entry: false
+    });
+    if (entry) return entry;
+    const customEntry = hasEntry(dir);
+    if (customEntry) return customEntry;
+    return false;
+};
+const scanDir = async (hooks, dirs)=>{
+    const entries = await Promise.all(dirs.map(async (dir)=>{
+        const entryName = path.basename(dir);
+        const customEntryFile = hasEntry(dir);
+        const customServerEntry = hasServerEntry(dir);
+        const entryFile = (await hooks.checkEntryPoint.call({
+            path: dir,
+            entry: false
+        })).entry;
+        if (entryFile) return {
+            entryName,
+            isMainEntry: false,
+            entry: customEntryFile || entryFile,
+            customServerEntry,
+            absoluteEntryDir: path.resolve(dir),
+            isAutoMount: true,
+            customEntry: Boolean(customEntryFile)
+        };
+        if (customEntryFile) return {
+            entryName,
+            isMainEntry: false,
+            entry: customEntryFile,
+            customServerEntry,
+            absoluteEntryDir: path.resolve(dir),
+            isAutoMount: false,
+            customEntry: Boolean(customEntryFile)
+        };
+        return false;
+    })).then((entries)=>entries.filter(Boolean));
+    if (0 === entries.length) throw Error('There is no valid entry point in the current project!');
+    return entries;
+};
+const getFileSystemEntry = async (hooks, appContext, config)=>{
+    const { appDirectory } = appContext;
+    const { source: { entriesDir } } = config;
+    const src = ensureAbsolutePath(appDirectory, entriesDir || '');
+    if (fs.existsSync(src)) if (fs.statSync(src).isDirectory()) {
+        if (await isBundleEntry(hooks, src)) return scanDir(hooks, [
+            src
+        ]);
+        const dirs = [];
+        await Promise.all(fs.readdirSync(src).map(async (filename)=>{
+            const file = path.join(src, filename);
+            if (fs.statSync(file).isDirectory() && await isBundleEntry(hooks, file)) dirs.push(file);
+        }));
+        return scanDir(hooks, dirs);
+    } else throw Error("source.entriesDir accept a directory.");
+    throw Error(`src dir ${entriesDir} not found.`);
+};
+export { getFileSystemEntry, hasEntry, hasServerEntry };

package/dist/esm-node/plugins/analyze/getHtmlTemplate.mjs

@@ -0,0 +1,98 @@
+import "node:module";
+import { findExists, fs } from "@modern-js/utils";
+import path from "path";
+import { HTML_PARTIALS_EXTENSIONS, HTML_PARTIALS_FOLDER } from "./constants.mjs";
+import * as __rspack_external__templates_mjs_4da4c6c8 from "./templates.mjs";
+const findPartials = (dir, entryName, position)=>{
+    if (fs.existsSync(dir)) {
+        const base = findExists(HTML_PARTIALS_EXTENSIONS.map((ext)=>path.resolve(dir, `${position}${ext}`)));
+        const file = entryName ? findExists(HTML_PARTIALS_EXTENSIONS.map((ext)=>path.resolve(dir, entryName, `${position}${ext}`))) || base : base;
+        return file ? {
+            file,
+            content: fs.readFileSync(file, 'utf8')
+        } : null;
+    }
+    return null;
+};
+const getModifyHtmlPartials = (partials)=>{
+    const append = (type, ...script)=>{
+        script.forEach((item)=>{
+            partials[type].push(item);
+        });
+    };
+    const prepend = (type, ...script)=>{
+        script.forEach((item)=>{
+            partials[type].unshift(item);
+        });
+    };
+    return {
+        top: {
+            append: (...script)=>append("top", ...script),
+            prepend: (...script)=>prepend("top", ...script),
+            current: partials.top
+        },
+        head: {
+            append: (...script)=>append("head", ...script),
+            prepend: (...script)=>prepend("head", ...script),
+            current: partials.head
+        },
+        body: {
+            append: (...script)=>append("body", ...script),
+            prepend: (...script)=>prepend("body", ...script),
+            current: partials.body
+        }
+    };
+};
+const resolveConfiguredTemplate = (template, entryName, appDirectory)=>{
+    const filepath = 'function' == typeof template ? template({
+        entryName
+    }) : template;
+    if ('string' != typeof filepath || 0 === filepath.length) return null;
+    return path.isAbsolute(filepath) ? filepath.replace(/\\/g, '/') : path.resolve(appDirectory, filepath).replace(/\\/g, '/');
+};
+const getHtmlTemplate = async (entrypoints, hooks, { appContext, config })=>{
+    const { appDirectory, internalDirectory } = appContext;
+    const { source: { configDir } } = config;
+    const htmlDir = path.resolve(appDirectory, configDir || '', HTML_PARTIALS_FOLDER);
+    const htmlTemplates = {};
+    const partialsByEntrypoint = {};
+    for (const entrypoint of entrypoints){
+        const { entryName, isMainEntry } = entrypoint;
+        const name = 1 === entrypoints.length && isMainEntry ? '' : entryName;
+        const configuredTemplate = resolveConfiguredTemplate(config.html.template, entryName, appDirectory);
+        if (configuredTemplate) {
+            htmlTemplates[entryName] = configuredTemplate;
+            continue;
+        }
+        const customIndexTemplate = findPartials(htmlDir, name, "index");
+        if (customIndexTemplate) htmlTemplates[entryName] = customIndexTemplate.file.replace(/\\/g, '/');
+        else {
+            const getPartialInitValue = (position)=>{
+                const partial = findPartials(htmlDir, name, position);
+                return partial ? [
+                    partial.content
+                ] : [];
+            };
+            const partials = {
+                top: getPartialInitValue("top"),
+                head: getPartialInitValue("head"),
+                body: getPartialInitValue("body")
+            };
+            await hooks.modifyHtmlPartials.call({
+                entrypoint,
+                partials: getModifyHtmlPartials(partials)
+            });
+            const templatePath = path.resolve(internalDirectory, entryName, 'index.html');
+            fs.outputFileSync(templatePath, __rspack_external__templates_mjs_4da4c6c8.html(partials), 'utf8');
+            htmlTemplates[entryName] = templatePath.replace(/\\/g, '/');
+            partialsByEntrypoint[entryName] = partials;
+            const bottomTemplate = findPartials(htmlDir, name, "bottom");
+            if (bottomTemplate) htmlTemplates[`__${entryName}-bottom__`] = bottomTemplate.content;
+        }
+    }
+    return {
+        partialsByEntrypoint,
+        htmlTemplates
+    };
+};
+export { getHtmlTemplate, getModifyHtmlPartials };

package/dist/esm-node/plugins/analyze/getServerRoutes.mjs

@@ -0,0 +1,131 @@
+import "node:module";
+import { ROUTE_SPEC_FILE, SERVER_BUNDLE_DIRECTORY, SERVER_WORKER_BUNDLE_DIRECTORY, fs, getEntryOptions, isPlainObject, removeLeadingSlash, removeTailSlash, urlJoin } from "@modern-js/utils";
+import path from "path";
+import { isMainEntry } from "../../utils/routes.mjs";
+import { walkDirectory } from "./utils.mjs";
+const applyBaseUrl = (baseUrl, routes)=>{
+    if (baseUrl) if (Array.isArray(baseUrl)) return baseUrl.reduce((previous, current)=>[
+            ...previous,
+            ...applyBaseUrl(current, routes)
+        ], []);
+    else return routes.map((route)=>{
+        const urlPath = urlJoin(baseUrl, route.urlPath);
+        return {
+            ...route,
+            urlPath: '/' === urlPath ? urlPath : removeTailSlash(urlPath)
+        };
+    });
+    return routes;
+};
+const applyRouteOptions = (original, routeOptions)=>{
+    const { route, disableSpa } = routeOptions;
+    original.isSPA = !disableSpa;
+    original.isSPA || (original.entryPath = path.dirname(original.entryPath));
+    let routes;
+    if (route) if (Array.isArray(route)) routes = route.map((url)=>{
+        if (!isPlainObject(url)) return {
+            ...original,
+            urlPath: url
+        };
+        {
+            const { path: urlPath, ...other } = url;
+            return {
+                ...original,
+                ...other,
+                urlPath
+            };
+        }
+    });
+    else if (isPlainObject(route)) {
+        const { path: urlPath, ...other } = route;
+        routes = [
+            {
+                ...original,
+                ...other,
+                urlPath
+            }
+        ];
+    } else routes = [
+        {
+            ...original,
+            urlPath: route
+        }
+    ];
+    else routes = [
+        original
+    ];
+    return routes;
+};
+const collectHtmlRoutes = (entrypoints, appContext, config)=>{
+    const { source: { mainEntryName }, html: { outputStructure }, output: { distPath: { html: htmlPath } = {} }, server: { baseUrl, routes, ssr, ssrByEntries, rsc }, deploy } = config;
+    const { packageName } = appContext;
+    const workerSSR = deploy?.worker?.ssr;
+    let htmlRoutes = entrypoints.reduce((previous, { entryName })=>{
+        const isMain = isMainEntry(entryName, mainEntryName);
+        const entryOptions = getEntryOptions(entryName, isMain, ssr, ssrByEntries, packageName);
+        const isSSR = Boolean(entryOptions);
+        const isWorker = Boolean(workerSSR);
+        const isStream = 'object' == typeof entryOptions && 'stream' === entryOptions.mode;
+        const { resHeaders } = routes?.[entryName] || {};
+        const isRSC = !!rsc;
+        let route = {
+            urlPath: `/${isMain ? '' : entryName}`,
+            entryName,
+            entryPath: removeLeadingSlash(path.posix.normalize(`${htmlPath}/${entryName}${'flat' === outputStructure ? '.html' : '/index.html'}`)),
+            isSPA: true,
+            isStream: isStream || isRSC,
+            isSSR,
+            isRSC,
+            responseHeaders: resHeaders,
+            worker: isWorker ? `${SERVER_WORKER_BUNDLE_DIRECTORY}/${entryName}.js` : void 0,
+            bundle: isSSR || isRSC ? `${SERVER_BUNDLE_DIRECTORY}/${entryName}.js` : void 0
+        };
+        if (routes?.hasOwnProperty(entryName)) {
+            const routeOptions = isPlainObject(routes[entryName]) ? routes[entryName] : {
+                route: routes[entryName]
+            };
+            route = applyRouteOptions(route, routeOptions);
+        }
+        return Array.isArray(route) ? [
+            ...previous,
+            ...route
+        ] : [
+            ...previous,
+            route
+        ];
+    }, []);
+    htmlRoutes = applyBaseUrl(baseUrl, htmlRoutes);
+    return htmlRoutes;
+};
+const collectStaticRoutes = (appContext, config)=>{
+    const { appDirectory } = appContext;
+    const { source: { configDir }, server: { publicRoutes = {} } } = config;
+    const publicFolder = path.resolve(appDirectory, configDir || '', 'public');
+    const ignoreFiles = [
+        '.gitkeep'
+    ];
+    return fs.existsSync(publicFolder) ? walkDirectory(publicFolder).filter((filePath)=>!ignoreFiles.includes(path.basename(filePath))).map((filePath)=>{
+        const urlPath = `${urlJoin(toPosix(filePath).slice(toPosix(publicFolder).length))}`;
+        return {
+            urlPath: publicRoutes[removeLeadingSlash(urlPath)] || urlPath,
+            isSPA: true,
+            isSSR: false,
+            entryPath: toPosix(path.relative(path.resolve(appDirectory, configDir || ''), filePath))
+        };
+    }) : [];
+};
+const getServerRoutes = (entrypoints, { appContext, config })=>[
+        ...collectHtmlRoutes(entrypoints, appContext, config),
+        ...collectStaticRoutes(appContext, config)
+    ];
+const toPosix = (pathStr)=>pathStr.split(path.sep).join(path.posix.sep);
+const getProdServerRoutes = (distDirectory)=>{
+    const routeJSON = path.join(distDirectory, ROUTE_SPEC_FILE);
+    try {
+        const { routes } = fs.readJSONSync(routeJSON);
+        return routes;
+    } catch (e) {
+        throw new Error(`Failed to read routes from ${routeJSON}, please check if the file exists.`);
+    }
+};
+export { getProdServerRoutes, getServerRoutes };

package/dist/esm-node/plugins/analyze/index.mjs

@@ -0,0 +1,204 @@
+import "node:module";
+import { isPromise } from "node:util/types";
+import { createDebugger, fs, getArgv, getMeta, isApiOnly, isDevCommand, minimist } from "@modern-js/utils";
+import { createBuilderGenerator } from "../../builder/index.mjs";
+import { initialNormalizedConfig } from "../../config/index.mjs";
+import { emitResolvedConfig } from "../../utils/config.mjs";
+import { getSelectedEntries } from "../../utils/getSelectedEntries.mjs";
+import { printInstructions } from "../../utils/printInstructions.mjs";
+import { generateRoutes } from "../../utils/routes.mjs";
+import { checkIsBuildCommands, checkIsServeCommand } from "./utils.mjs";
+import * as __rspack_external_path from "path";
+const debug = createDebugger('plugin-analyze');
+const analyze = ()=>({
+        name: '@modern-js/plugin-analyze',
+        post: [
+            '@modern-js/runtime'
+        ],
+        setup: (api)=>{
+            let pagesDir = [];
+            let nestedRouteEntries = [];
+            const routesConfigFiles = [];
+            api.onPrepare(async ()=>{
+                let appContext = api.getAppContext();
+                const resolvedConfig = api.getNormalizedConfig();
+                const hooks = api.getHooks();
+                try {
+                    if (checkIsBuildCommands()) fs.emptydirSync(appContext.internalDirectory);
+                } catch  {}
+                const apiOnly = await isApiOnly(appContext.appDirectory, resolvedConfig.source?.entriesDir, appContext.apiDirectory);
+                const [{ getProdServerRoutes }] = await Promise.all([
+                    import("./getServerRoutes.mjs")
+                ]);
+                if (apiOnly) {
+                    const routes = [];
+                    if (checkIsServeCommand()) routes.push(...getProdServerRoutes(appContext.distDirectory));
+                    else {
+                        const { routes: modifiedRoutes } = await hooks.modifyServerRoutes.call({
+                            routes: []
+                        });
+                        routes.push(...modifiedRoutes);
+                    }
+                    debug("server routes: %o", routes);
+                    api.updateAppContext({
+                        apiOnly,
+                        serverRoutes: routes
+                    });
+                    return;
+                }
+                const [{ getBundleEntry }, { getServerRoutes }, { getHtmlTemplate }] = await Promise.all([
+                    import("./getBundleEntry.mjs"),
+                    import("./getServerRoutes.mjs"),
+                    import("./getHtmlTemplate.mjs")
+                ]);
+                const { entrypoints } = await hooks.modifyEntrypoints.call({
+                    entrypoints: await getBundleEntry(hooks, appContext, resolvedConfig)
+                });
+                debug("entrypoints: %o", entrypoints);
+                const routes = [];
+                if (checkIsServeCommand()) routes.push(...getProdServerRoutes(appContext.distDirectory));
+                else {
+                    const initialRoutes = getServerRoutes(entrypoints, {
+                        appContext,
+                        config: resolvedConfig
+                    });
+                    const { routes: modifiedRoutes } = await hooks.modifyServerRoutes.call({
+                        routes: initialRoutes
+                    });
+                    routes.push(...modifiedRoutes);
+                }
+                debug("server routes: %o", routes);
+                appContext = {
+                    ...api.getAppContext(),
+                    entrypoints,
+                    serverRoutes: routes
+                };
+                api.updateAppContext(appContext);
+                nestedRouteEntries = entrypoints.map((point)=>point.nestedRoutesEntry).filter(Boolean);
+                pagesDir = entrypoints.map((point)=>point.entry).filter((entry)=>entry && !__rspack_external_path.extname(entry)).concat(nestedRouteEntries);
+                const meta = getMeta(api.getAppContext().metaName);
+                const possibleNames = [
+                    `${meta}.routes.ts`,
+                    `${meta}.routes.mts`,
+                    `${meta}.routes.tsx`,
+                    `${meta}.routes.js`,
+                    `${meta}.routes.mjs`,
+                    `${meta}.routes.jsx`
+                ];
+                await Promise.all(entrypoints.map(async (entrypoint)=>{
+                    const { absoluteEntryDir } = entrypoint;
+                    if (!absoluteEntryDir) return;
+                    for (const filename of possibleNames){
+                        const filePath = __rspack_external_path.resolve(absoluteEntryDir, filename);
+                        if (await fs.pathExists(filePath)) {
+                            const stats = await fs.stat(filePath);
+                            if (stats.isFile()) routesConfigFiles.push(filePath);
+                        }
+                    }
+                }));
+                const { partialsByEntrypoint, htmlTemplates } = await getHtmlTemplate(entrypoints, hooks, {
+                    appContext,
+                    config: resolvedConfig
+                });
+                debug("html templates: %o", htmlTemplates);
+                api.updateAppContext({
+                    partialsByEntrypoint
+                });
+                let checkedEntries = entrypoints.map((point)=>point.entryName);
+                if (isDevCommand()) {
+                    const { entry } = minimist(getArgv());
+                    checkedEntries = await getSelectedEntries('string' == typeof entry ? entry.split(',') : entry, entrypoints);
+                }
+                appContext = {
+                    ...api.getAppContext(),
+                    entrypoints,
+                    checkedEntries,
+                    apiOnly,
+                    serverRoutes: routes,
+                    htmlTemplates
+                };
+                api.updateAppContext(appContext);
+                if (checkIsBuildCommands()) {
+                    await hooks.generateEntryCode.call({
+                        entrypoints
+                    });
+                    const normalizedConfig = api.getNormalizedConfig();
+                    const createBuilderForModern = await createBuilderGenerator();
+                    const builder = await createBuilderForModern({
+                        normalizedConfig: normalizedConfig,
+                        appContext: appContext
+                    });
+                    builder.onBeforeBuild(async ({ bundlerConfigs, isFirstCompile, environments, isWatch })=>{
+                        if (!isFirstCompile) return;
+                        await generateRoutes(appContext);
+                        await hooks.onBeforeBuild.call({
+                            isFirstCompile,
+                            isWatch,
+                            environments,
+                            bundlerConfigs
+                        });
+                    });
+                    builder.onAfterBuild(async ({ stats, environments, isFirstCompile, isWatch })=>{
+                        await hooks.onAfterBuild.call({
+                            stats,
+                            environments,
+                            isFirstCompile,
+                            isWatch
+                        });
+                        await emitResolvedConfig(appContext.appDirectory, normalizedConfig);
+                    });
+                    builder.onDevCompileDone(async ({ isFirstCompile, stats, environments })=>{
+                        hooks.onDevCompileDone.call({
+                            isFirstCompile,
+                            stats,
+                            environments
+                        });
+                        if (isFirstCompile) printInstructions(hooks, appContext, normalizedConfig);
+                    });
+                    builder.onBeforeCreateCompiler(async ({ bundlerConfigs, environments })=>{
+                        await hooks.onBeforeCreateCompiler.call({
+                            environments,
+                            bundlerConfigs
+                        });
+                    });
+                    builder.onAfterCreateCompiler(async ({ compiler, environments })=>{
+                        await hooks.onAfterCreateCompiler.call({
+                            environments,
+                            compiler
+                        });
+                    });
+                    builder.onAfterStartDevServer(async ({ port })=>{
+                        await hooks.onAfterDev.call({
+                            port
+                        });
+                    });
+                    const getFlattenedPlugins = async (pluginOptions)=>{
+                        let plugins = pluginOptions;
+                        do plugins = (await Promise.all(plugins)).flat(1 / 0);
+                        while (plugins.some((value)=>isPromise(value)));
+                        return plugins;
+                    };
+                    if (resolvedConfig.builderPlugins) {
+                        const plugins = await getFlattenedPlugins(resolvedConfig.builderPlugins);
+                        builder.addPlugins(plugins);
+                    }
+                    api.updateAppContext({
+                        builder
+                    });
+                }
+            });
+            api.addWatchFiles(()=>({
+                    files: [
+                        ...pagesDir,
+                        ...routesConfigFiles
+                    ],
+                    isPrivate: true
+                }));
+            api.modifyResolvedConfig((resolved)=>{
+                const appContext = api.getAppContext();
+                const config = initialNormalizedConfig(resolved, appContext);
+                return config;
+            });
+        }
+    });
+export default analyze;

package/dist/esm-node/plugins/analyze/isDefaultExportFunction.mjs

@@ -0,0 +1,42 @@
+import "node:module";
+import { parse } from "@babel/parser";
+import traverse from "@babel/traverse";
+import fs from "fs";
+import * as __rspack_external__babel_types_69e65b52 from "@babel/types";
+const isFunction = (node)=>__rspack_external__babel_types_69e65b52.isFunctionDeclaration(node) || __rspack_external__babel_types_69e65b52.isFunctionExpression(node) || __rspack_external__babel_types_69e65b52.isArrowFunctionExpression(node);
+const isDefaultExportFunction = (file)=>{
+    if (!file || !fs.existsSync(file)) return false;
+    const ast = parse(fs.readFileSync(file, 'utf8'), {
+        sourceType: 'unambiguous',
+        plugins: [
+            'jsx',
+            "typescript",
+            'classProperties',
+            'dynamicImport',
+            'exportDefaultFrom',
+            'exportNamespaceFrom',
+            'decorators-legacy',
+            'functionBind',
+            'classPrivateMethods',
+            [
+                'pipelineOperator',
+                {
+                    proposal: 'minimal'
+                }
+            ],
+            'optionalChaining',
+            'optionalCatchBinding',
+            'objectRestSpread',
+            'numericSeparator'
+        ]
+    });
+    let isExportFunction = false;
+    traverse(ast, {
+        ExportDefaultDeclaration: (path)=>{
+            const { declaration } = path.node;
+            if (isFunction(declaration)) isExportFunction = true;
+        }
+    });
+    return isExportFunction;
+};
+export { isDefaultExportFunction };

package/dist/esm-node/plugins/analyze/templates.mjs

@@ -0,0 +1,23 @@
+import "node:module";
+const html = (partials)=>`
+<!DOCTYPE html>
+<html>
+<head>
+
+  ${partials.top.join('\n')}
+
+  ${partials.head.join('\n')}
+
+</head>
+
+<body>
+  <div id="<%= mountId %>"><!--<?- html ?>--></div>
+  ${partials.body.join('\n')}
+  <!--<?- chunksMap.js ?>-->
+  <!--<?- SSRDataScript ?>-->
+  <!--<?- bottomTemplate ?>-->
+</body>
+
+</html>
+`;
+export { html };