@bleedingdev/modern-js-runtime 3.2.0-ultramodern.0

package/dist/esm/ssr/serverRender/renderToStream/buildTemplate.after.mjs

@@ -0,0 +1,50 @@
+import { sanitizeSSRPayload, serializeJson } from "@modern-js/runtime-utils/node";
+import { attributesToString } from "../utils";
+import { buildTemplate } from "./buildTemplate.share";
+function buildShellAfterTemplate(afterAppTemplate, options) {
+    const callbacks = [
+        injectSSRDataScript
+    ];
+    return buildTemplate(afterAppTemplate, callbacks);
+    function injectSSRDataScript(template) {
+        const ssrDataScript = buildSSRDataScript();
+        return template.replace('<!--<?- SSRDataScript ?>-->', ssrDataScript);
+        function buildSSRDataScript() {
+            const { context: { ssrContext, initialData, __i18nData__ }, renderLevel } = options;
+            const { request, enableUnsafeCtx, nonce, tracker, unsafeHeaders } = ssrContext;
+            const unsafeContext = {
+                headers: request.headers
+            };
+            const SSRData = {
+                data: {
+                    initialData,
+                    i18nData: __i18nData__
+                },
+                context: {
+                    reporter: {
+                        sessionId: tracker.sessionId
+                    },
+                    request: {
+                        params: request.params,
+                        query: request.query,
+                        pathname: request.pathname,
+                        host: request.host,
+                        url: request.url,
+                        ...enableUnsafeCtx ? unsafeContext : {}
+                    }
+                },
+                renderLevel
+            };
+            const attrsStr = attributesToString({
+                nonce
+            });
+            const sanitizedSSRData = sanitizeSSRPayload(SSRData, {
+                unsafeHeaders
+            }).payload;
+            return `
+      <script${attrsStr}>window._SSR_DATA = ${serializeJson(sanitizedSSRData)}</script>
+      `;
+        }
+    }
+}
+export { buildShellAfterTemplate };

package/dist/esm/ssr/serverRender/renderToString/entry.mjs

@@ -0,0 +1,148 @@
+import { sanitizeSSRPayload, serializeJson } from "@modern-js/runtime-utils/node";
+import { time } from "@modern-js/runtime-utils/time";
+import react from "react";
+import react_helmet from "react-helmet";
+import { serializeErrors } from "../../../router/runtime/utils.mjs";
+import prefetch from "../../prefetch";
+import helmet from "../helmet";
+import { SSRErrors, SSRTimings } from "../tracker";
+import { RenderLevel } from "../types.mjs";
+import { ROUTER_DATA_JSON_ID, SSR_DATA_JSON_ID, attributesToString } from "../utils";
+import { buildHtml, createReplaceChunkCss, createReplaceChunkJs, createReplaceHtml, createReplaceSSRDataScript } from "./buildHtml";
+import { createLoadableCollector } from "./loadable";
+import { createRender } from "./render";
+import { createStyledCollector } from "./styledComponent";
+const buildTemplateData = (context, data, renderLevel, tracker)=>{
+    const { request, enableUnsafeCtx } = context;
+    const unsafeContext = {
+        headers: request.headers
+    };
+    return {
+        data,
+        context: {
+            request: {
+                params: request.params,
+                query: request.query,
+                pathname: request.pathname,
+                host: request.host,
+                url: request.url,
+                ...enableUnsafeCtx ? unsafeContext : {}
+            },
+            reporter: {
+                sessionId: tracker.sessionId
+            }
+        },
+        renderLevel
+    };
+};
+class Entry {
+    async renderToHtml(context) {
+        const ssrContext = context.ssrContext;
+        if (ssrContext.redirection?.url) return '';
+        const prefetchData = await this.prefetch(context);
+        if (ssrContext.redirection?.url) return '';
+        if (this.result.renderLevel >= RenderLevel.SERVER_PREFETCH) this.result.html = await this.renderToString(context);
+        if (ssrContext.redirection?.url) return '';
+        const { routerContext, routerServerSnapshot } = context;
+        const routerData = routerServerSnapshot?.routerData ? {
+            loaderData: routerServerSnapshot.routerData.loaderData,
+            errors: serializeErrors(routerServerSnapshot.routerData.errors)
+        } : routerContext ? {
+            loaderData: routerContext.loaderData,
+            errors: serializeErrors(routerContext.errors)
+        } : void 0;
+        const templateData = buildTemplateData(ssrContext, prefetchData, this.result.renderLevel, this.tracker);
+        const ssrDataScripts = this.getSSRDataScript(templateData, routerData);
+        const html = buildHtml(this.template, [
+            createReplaceChunkCss(this.result.chunksMap.css),
+            createReplaceChunkJs(this.result.chunksMap.js),
+            createReplaceHtml(this.result.html || ''),
+            createReplaceSSRDataScript(ssrDataScripts),
+            ...this.htmlModifiers
+        ]);
+        const helmetData = react_helmet.renderStatic();
+        return helmetData ? helmet(html, helmetData) : html;
+    }
+    async prefetch(context) {
+        let prefetchData;
+        const end = time();
+        try {
+            prefetchData = await prefetch(this.App, context, this.pluginConfig);
+            this.result.renderLevel = RenderLevel.SERVER_PREFETCH;
+            const prefetchCost = end();
+            this.tracker.trackTiming(SSRTimings.SSR_PREFETCH, prefetchCost);
+        } catch (e) {
+            this.result.renderLevel = RenderLevel.CLIENT_RENDER;
+            this.tracker.trackError(SSRErrors.PREFETCH, e);
+        }
+        return prefetchData || {};
+    }
+    async renderToString(context) {
+        let html = '';
+        const end = time();
+        const { ssrContext } = context;
+        try {
+            const App = react.createElement(this.App, {
+                context: Object.assign(context, {
+                    ssr: true
+                })
+            });
+            html = await createRender(App).addCollector(createStyledCollector(this.result)).addCollector(createLoadableCollector({
+                stats: ssrContext.loadableStats,
+                result: this.result,
+                entryName: this.entryName,
+                config: this.pluginConfig,
+                nonce: this.nonce,
+                template: this.template,
+                routeManifest: this.routeManifest
+            })).finish();
+            const cost = end();
+            this.tracker.trackTiming(SSRTimings.SSR_RENDER_HTML, cost);
+            this.result.renderLevel = RenderLevel.SERVER_RENDER;
+        } catch (e) {
+            this.tracker.trackError(SSRErrors.RENDER_HTML, e);
+        }
+        return html;
+    }
+    getSSRDataScript(templateData, routerData) {
+        const useInlineScript = false !== this.pluginConfig.inlineScript;
+        const sanitizedTemplateData = sanitizeSSRPayload(templateData, {
+            unsafeHeaders: this.pluginConfig.unsafeHeaders
+        }).payload;
+        const ssrData = serializeJson(sanitizedTemplateData);
+        const attrsStr = attributesToString({
+            nonce: this.nonce
+        });
+        let ssrDataScripts = useInlineScript ? `<script${attrsStr}>window._SSR_DATA = ${ssrData}</script>` : `<script type="application/json" id="${SSR_DATA_JSON_ID}">${ssrData}</script>`;
+        if (routerData) {
+            const sanitizedRouterData = sanitizeSSRPayload(routerData, {
+                unsafeHeaders: this.pluginConfig.unsafeHeaders
+            }).payload;
+            const serializedRouterData = serializeJson(sanitizedRouterData);
+            ssrDataScripts += useInlineScript ? `\n<script${attrsStr}>window._ROUTER_DATA = ${serializedRouterData}</script>` : `\n<script type="application/json" id="${ROUTER_DATA_JSON_ID}">${serializedRouterData}</script>`;
+        }
+        return ssrDataScripts;
+    }
+    constructor(options){
+        const { ctx, config } = options;
+        const { entryName, template, nonce } = ctx;
+        this.template = template;
+        this.entryName = entryName;
+        this.App = options.App;
+        this.pluginConfig = config;
+        this.routeManifest = ctx.routeManifest;
+        this.tracker = ctx.tracker;
+        this.metrics = ctx.metrics;
+        this.htmlModifiers = ctx.htmlModifiers;
+        this.nonce = nonce;
+        this.result = {
+            renderLevel: RenderLevel.CLIENT_RENDER,
+            html: '',
+            chunksMap: {
+                js: '',
+                css: ''
+            }
+        };
+    }
+}
+export default Entry;

package/dist/esm/ssr/serverRender/types.mjs

@@ -0,0 +1 @@
+export { RenderLevel } from "./renderToString/type";

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

@@ -0,0 +1,2 @@
+import "node:module";
+export * from "@modern-js/runtime-utils/cache";

package/dist/esm-node/cli/alias.mjs

@@ -0,0 +1,25 @@
+import "node:module";
+import path from "path";
+import { ENTRY_POINT_REGISTER_FILE_NAME } from "./constants.mjs";
+const builderPluginAlias = ({ entrypoints, internalDirectory, metaName })=>({
+        name: 'runtime:alias',
+        setup (api) {
+            api.modifyRsbuildConfig((userConfig, { mergeRsbuildConfig })=>{
+                const entrypointsAlias = {};
+                const mainEntrypointsAlias = {};
+                entrypoints.forEach((entrypoint)=>{
+                    entrypointsAlias[`@${metaName}/runtime/registry/${entrypoint.entryName}$`] = path.join(internalDirectory, entrypoint.entryName, ENTRY_POINT_REGISTER_FILE_NAME);
+                    if (entrypoint.isMainEntry) mainEntrypointsAlias[`@${metaName}/runtime/registry`] = path.join(internalDirectory, entrypoint.entryName, ENTRY_POINT_REGISTER_FILE_NAME);
+                });
+                return mergeRsbuildConfig(userConfig, {
+                    resolve: {
+                        alias: {
+                            ...entrypointsAlias,
+                            ...mainEntrypointsAlias
+                        }
+                    }
+                });
+            });
+        }
+    });
+export { builderPluginAlias };

package/dist/esm-node/cli/code.mjs

@@ -0,0 +1,150 @@
+import "node:module";
+import { formatImportPath, fs } from "@modern-js/utils";
+import path from "path";
+import { ENTRY_BOOTSTRAP_FILE_NAME, ENTRY_POINT_FILE_NAME, ENTRY_POINT_REGISTER_FILE_NAME, ENTRY_POINT_RUNTIME_GLOBAL_CONTEXT_FILE_NAME, ENTRY_POINT_RUNTIME_REGISTER_FILE_NAME, ENTRY_SERVER_BOOTSTRAP_FILE_NAME, INDEX_FILE_NAME, SERVER_ENTRY_POINT_FILE_NAME } from "./constants.mjs";
+import { resolveSSRMode } from "./ssr/mode.mjs";
+import * as __rspack_external__template_mjs_d6ab8956 from "./template.mjs";
+import * as __rspack_external__template_server_mjs_38d6edb1 from "./template.server.mjs";
+const normalizePreEntry = (preEntry)=>{
+    if (!preEntry) return [];
+    if (Array.isArray(preEntry)) return preEntry.filter((v)=>'string' == typeof v && v.length > 0);
+    if ('string' == typeof preEntry) return preEntry ? [
+        preEntry
+    ] : [];
+    return [];
+};
+const resolvePreEntryImportPath = ({ preEntry, appDirectory, srcDirectory, internalSrcAlias })=>{
+    const absPath = path.isAbsolute(preEntry) ? preEntry : path.resolve(appDirectory, preEntry);
+    if (absPath.startsWith(srcDirectory)) return formatImportPath(absPath.replace(srcDirectory, internalSrcAlias));
+    return formatImportPath(absPath);
+};
+const generateCode = async (entrypoints, appContext, config, hooks)=>{
+    const { mountId } = config.html;
+    const { enableAsyncEntry, enableAsyncPreEntry, preEntry } = config.source;
+    const shouldInjectAsyncPreEntry = !!enableAsyncEntry && !!enableAsyncPreEntry;
+    const { appDirectory, runtimeConfigFile, internalDirectory, internalSrcAlias, metaName, srcDirectory, serverRoutes } = appContext;
+    await Promise.all(entrypoints.map(async (entrypoint)=>{
+        const { entryName, isAutoMount, entry, customEntry, customServerEntry, nestedRoutesEntry } = entrypoint;
+        const { plugins: runtimePlugins } = await hooks._internalRuntimePlugins.call({
+            entrypoint,
+            plugins: []
+        });
+        if (isAutoMount) {
+            const ssrMode = resolveSSRMode({
+                entry: entryName,
+                config,
+                nestedRoutesEntry
+            });
+            let indexCode = '';
+            indexCode = ssrMode || !config.server.rsc || customEntry ? __rspack_external__template_mjs_d6ab8956.index({
+                srcDirectory,
+                internalSrcAlias,
+                metaName,
+                entry,
+                entryName,
+                customEntry,
+                mountId,
+                enableRsc: config.server.rsc,
+                isNestedRouter: !!entrypoint.nestedRoutesEntry
+            }) : __rspack_external__template_mjs_d6ab8956.entryForCSRWithRSC({
+                metaName,
+                entryName,
+                mountId,
+                urlPath: serverRoutes.find((route)=>route.entryName === entryName)?.urlPath,
+                isNestedRouter: entrypoint.nestedRoutesEntry
+            });
+            if (shouldInjectAsyncPreEntry) {
+                const preEntries = normalizePreEntry(preEntry);
+                if (preEntries.length > 0) {
+                    const injected = preEntries.map((item)=>{
+                        const importPath = resolvePreEntryImportPath({
+                            preEntry: item,
+                            appDirectory,
+                            srcDirectory,
+                            internalSrcAlias
+                        });
+                        return `import '${importPath}';`;
+                    }).join('\n');
+                    indexCode = `${injected}\n${indexCode}`;
+                }
+            }
+            const indexFile = path.resolve(internalDirectory, `./${entryName}/${ENTRY_POINT_FILE_NAME}`);
+            await fs.outputFile(indexFile, indexCode, 'utf8');
+            if (enableAsyncEntry) {
+                const bootstrapFile = path.resolve(internalDirectory, `./${entryName}/${ENTRY_BOOTSTRAP_FILE_NAME}`);
+                await fs.outputFile(bootstrapFile, `import(/* webpackChunkName: "async-${entryName}" */ './${INDEX_FILE_NAME}');`, 'utf8');
+                const bootstrapServerFile = path.resolve(internalDirectory, `./${entryName}/${ENTRY_SERVER_BOOTSTRAP_FILE_NAME}`);
+                if (ssrMode) await fs.outputFile(bootstrapServerFile, `export const requestHandler = import('./${SERVER_ENTRY_POINT_FILE_NAME}').then((m) => m.requestHandler)`, 'utf8');
+            }
+            if (ssrMode) {
+                const indexServerCode = __rspack_external__template_server_mjs_38d6edb1.serverIndex({
+                    entry,
+                    entryName,
+                    internalSrcAlias,
+                    metaName,
+                    mode: ssrMode,
+                    customServerEntry,
+                    srcDirectory,
+                    enableRsc: config.server.rsc
+                });
+                const indexServerFile = path.resolve(internalDirectory, `./${entryName}/${SERVER_ENTRY_POINT_FILE_NAME}`);
+                await fs.outputFile(indexServerFile, indexServerCode, 'utf8');
+            } else if (config.server.rsc) {
+                const indexServerFile = path.resolve(internalDirectory, `./${entryName}/${SERVER_ENTRY_POINT_FILE_NAME}`);
+                const indexServerCode = __rspack_external__template_server_mjs_38d6edb1.entryForCSRWithRSC({
+                    entryName,
+                    metaName
+                });
+                await fs.outputFile(indexServerFile, indexServerCode, 'utf8');
+            }
+            const registerCode = __rspack_external__template_mjs_d6ab8956.register();
+            const registerFile = path.resolve(internalDirectory, `./${entryName}/${ENTRY_POINT_REGISTER_FILE_NAME}`);
+            await fs.outputFile(registerFile, registerCode, 'utf8');
+            const registerRuntimeCode = __rspack_external__template_mjs_d6ab8956.runtimeRegister({
+                entryName,
+                srcDirectory,
+                internalSrcAlias,
+                metaName,
+                runtimeConfigFile,
+                runtimePlugins
+            });
+            const registerRuntimeFile = path.resolve(internalDirectory, `./${entryName}/${ENTRY_POINT_RUNTIME_REGISTER_FILE_NAME}`);
+            await fs.outputFile(registerRuntimeFile, registerRuntimeCode, 'utf8');
+            let contextCode = '';
+            if (!config.server.rsc || entrypoint.nestedRoutesEntry) {
+                const route = serverRoutes.find((r)=>r.entryName === entryName);
+                const basename = route?.urlPath || '/';
+                contextCode = __rspack_external__template_mjs_d6ab8956.runtimeGlobalContext({
+                    entryName,
+                    srcDirectory,
+                    internalSrcAlias,
+                    metaName,
+                    entry,
+                    customEntry,
+                    basename
+                });
+            } else {
+                const AppProxyPath = path.join(internalDirectory, entryName, './AppProxy.jsx');
+                const appProxyCode = __rspack_external__template_mjs_d6ab8956.AppProxyForRSC({
+                    srcDirectory,
+                    internalSrcAlias,
+                    entry,
+                    customEntry
+                });
+                await fs.outputFile(AppProxyPath, appProxyCode);
+                contextCode = __rspack_external__template_mjs_d6ab8956.runtimeGlobalContextForRSCClient({
+                    metaName,
+                    customEntry
+                });
+                const contextServerCode = __rspack_external__template_mjs_d6ab8956.runtimeGlobalContextForRSCServer({
+                    metaName
+                });
+                const contextFile = path.resolve(internalDirectory, `./${entryName}/${ENTRY_POINT_RUNTIME_GLOBAL_CONTEXT_FILE_NAME}.server.js`);
+                await fs.outputFile(contextFile, contextServerCode, 'utf8');
+            }
+            const contextFile = path.resolve(internalDirectory, `./${entryName}/${ENTRY_POINT_RUNTIME_GLOBAL_CONTEXT_FILE_NAME}.js`);
+            await fs.outputFile(contextFile, contextCode, 'utf8');
+        }
+    }));
+};
+export { generateCode };

package/dist/esm-node/cli/constants.mjs

@@ -0,0 +1,11 @@
+import "node:module";
+const APP_FILE_NAME = 'App';
+const ENTRY_POINT_FILE_NAME = 'index.jsx';
+const SERVER_ENTRY_POINT_FILE_NAME = 'index.server.jsx';
+const INDEX_FILE_NAME = 'index';
+const ENTRY_BOOTSTRAP_FILE_NAME = 'bootstrap.jsx';
+const ENTRY_SERVER_BOOTSTRAP_FILE_NAME = 'bootstrap.server.jsx';
+const ENTRY_POINT_RUNTIME_REGISTER_FILE_NAME = 'runtime-register.js';
+const ENTRY_POINT_RUNTIME_GLOBAL_CONTEXT_FILE_NAME = 'runtime-global-context';
+const ENTRY_POINT_REGISTER_FILE_NAME = 'register.js';
+export { APP_FILE_NAME, ENTRY_BOOTSTRAP_FILE_NAME, ENTRY_POINT_FILE_NAME, ENTRY_POINT_REGISTER_FILE_NAME, ENTRY_POINT_RUNTIME_GLOBAL_CONTEXT_FILE_NAME, ENTRY_POINT_RUNTIME_REGISTER_FILE_NAME, ENTRY_SERVER_BOOTSTRAP_FILE_NAME, INDEX_FILE_NAME, SERVER_ENTRY_POINT_FILE_NAME };

package/dist/esm-node/cli/entry.mjs

@@ -0,0 +1,7 @@
+import "node:module";
+import { JS_EXTENSIONS, findExists } from "@modern-js/utils";
+import path from "path";
+import { APP_FILE_NAME } from "./constants.mjs";
+const hasApp = (dir)=>findExists(JS_EXTENSIONS.map((ext)=>path.resolve(dir, `${APP_FILE_NAME}${ext}`)));
+const isRuntimeEntry = (dir)=>hasApp(dir);
+export { hasApp, isRuntimeEntry };

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

@@ -0,0 +1,95 @@
+import __rslib_shim_module__ from "node:module";
+const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(/*#__PURE__*/ (()=>import.meta.url)());
+import { cleanRequireCache, isReact18 as utils_isReact18 } from "@modern-js/utils";
+import path_0 from "path";
+import { documentPlugin } from "../document/cli/index.mjs";
+import { getEntrypointRoutesDir, handleFileChange, handleGeneratorEntryCode, handleModifyEntrypoints, isRouteEntry, routerPlugin } from "../router/cli/index.mjs";
+import { builderPluginAlias } from "./alias.mjs";
+import { generateCode } from "./code.mjs";
+import { ENTRY_BOOTSTRAP_FILE_NAME, ENTRY_POINT_FILE_NAME } from "./constants.mjs";
+import { isRuntimeEntry } from "./entry.mjs";
+import { ssrPlugin } from "./ssr/index.mjs";
+const runtimePlugin = (params)=>({
+        name: '@modern-js/runtime',
+        post: [
+            '@modern-js/plugin-ssr',
+            '@modern-js/plugin-router',
+            '@modern-js/plugin-document',
+            '@modern-js/plugin-design-token'
+        ],
+        usePlugins: params?.plugins || [
+            ssrPlugin(),
+            routerPlugin(),
+            documentPlugin()
+        ],
+        setup: (api)=>{
+            api.checkEntryPoint(({ path, entry })=>({
+                    path,
+                    entry: entry || isRuntimeEntry(path)
+                }));
+            api.modifyEntrypoints(({ entrypoints })=>{
+                const { internalDirectory } = api.getAppContext();
+                const { source: { enableAsyncEntry } } = api.getNormalizedConfig();
+                const newEntryPoints = entrypoints.map((entrypoint)=>{
+                    if (entrypoint.isAutoMount) entrypoint.internalEntry = path_0.resolve(internalDirectory, `./${entrypoint.entryName}/${enableAsyncEntry ? ENTRY_BOOTSTRAP_FILE_NAME : ENTRY_POINT_FILE_NAME}`);
+                    return entrypoint;
+                });
+                return {
+                    entrypoints: newEntryPoints
+                };
+            });
+            api.generateEntryCode(async ({ entrypoints })=>{
+                const appContext = api.getAppContext();
+                const resolvedConfig = api.getNormalizedConfig();
+                const hooks = api.getHooks();
+                await generateCode(entrypoints, appContext, resolvedConfig, hooks);
+            });
+            api.onPrepare(()=>{
+                const { builder, entrypoints, internalDirectory, metaName } = api.getAppContext();
+                builder?.addPlugins([
+                    builderPluginAlias({
+                        entrypoints,
+                        internalDirectory,
+                        metaName
+                    })
+                ]);
+            });
+            api.config(()=>{
+                const { appDirectory, metaName } = api.getAppContext();
+                const isReact18 = utils_isReact18(appDirectory);
+                process.env.IS_REACT18 = isReact18.toString();
+                return {
+                    source: {
+                        globalVars: {
+                            'process.env.IS_REACT18': process.env.IS_REACT18
+                        },
+                        include: [
+                            new RegExp(`[\\\\/]node_modules[\\\\/]@${metaName}[\\\\/]runtime[\\\\/].*[\\\\/]head\\.`)
+                        ]
+                    },
+                    tools: {
+                        bundlerChain: (chain)=>{
+                            chain.module.rule('modern-entry').test(/\.jsx?$/).include.add(path_0.resolve(appDirectory, 'node_modules', `.${metaName}`)).end().sideEffects(true);
+                        },
+                        rspack: (_config, { appendPlugins, rspack })=>{
+                            if (!isReact18) appendPlugins([
+                                new rspack.IgnorePlugin({
+                                    resourceRegExp: /^react-dom\/client$/,
+                                    contextRegExp: /@modern-js\/runtime/
+                                })
+                            ]);
+                        }
+                    }
+                };
+            });
+            api.onBeforeRestart(()=>{
+                cleanRequireCache([
+                    require.resolve('../router/cli'),
+                    require.resolve('./ssr')
+                ]);
+            });
+        }
+    });
+const cli = runtimePlugin;
+export default cli;
+export { documentPlugin, getEntrypointRoutesDir, handleFileChange, handleGeneratorEntryCode, handleModifyEntrypoints, isRouteEntry, isRuntimeEntry, routerPlugin, runtimePlugin, ssrPlugin };