@modern-js/runtime 2.69.4 → 3.0.0-alpha.0

package/dist/esm/document/Script.mjs

@@ -0,0 +1,21 @@
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { renderToString } from "react-dom/server";
+import { DOCUMENT_SCRIPT_ATTRIBUTES_END, DOCUMENT_SCRIPT_ATTRIBUTES_START, DOCUMENT_SCRIPT_PLACEHOLDER_END, DOCUMENT_SCRIPT_PLACEHOLDER_START } from "./constants";
+function Script(props) {
+    const { content, ...rests } = props;
+    const contentStr = content?.toString();
+    const contentIIFE = contentStr?.length ? encodeURIComponent(`(${contentStr})()`) : '';
+    const scriptProperties = renderToString(/*#__PURE__*/ jsx("script", {
+        ...rests
+    }));
+    const scriptpPropertiesStr = encodeURIComponent(scriptProperties.replace("<script ", '').replace("><\/script>", ''));
+    return /*#__PURE__*/ jsxs(Fragment, {
+        children: [
+            `${DOCUMENT_SCRIPT_PLACEHOLDER_START}`,
+            `${DOCUMENT_SCRIPT_ATTRIBUTES_START}${scriptpPropertiesStr}${DOCUMENT_SCRIPT_ATTRIBUTES_END}`,
+            `${contentIIFE}`,
+            `${DOCUMENT_SCRIPT_PLACEHOLDER_END}`
+        ]
+    });
+}
+export { Script };

package/dist/esm/document/Scripts.mjs

@@ -0,0 +1,9 @@
+import { Fragment, jsx } from "react/jsx-runtime";
+import "react";
+import { DOCUMENT_SCRIPTS_PLACEHOLDER } from "./constants";
+function Scripts() {
+    return /*#__PURE__*/ jsx(Fragment, {
+        children: `${DOCUMENT_SCRIPTS_PLACEHOLDER}`
+    });
+}
+export { Scripts };

package/dist/esm/document/Style.mjs

@@ -0,0 +1,16 @@
+import { Fragment, jsxs } from "react/jsx-runtime";
+import "react";
+import { DOCUMENT_STYLE_PLACEHOLDER_END, DOCUMENT_STYLE_PLACEHOLDER_START } from "./constants";
+function Style(props) {
+    const { content, children } = props;
+    const contentStr = children || content;
+    const styleContent = encodeURIComponent(`${contentStr}`);
+    return /*#__PURE__*/ jsxs(Fragment, {
+        children: [
+            `${DOCUMENT_STYLE_PLACEHOLDER_START}`,
+            `${styleContent}`,
+            `${DOCUMENT_STYLE_PLACEHOLDER_END}`
+        ]
+    });
+}
+export { Style };

package/dist/esm/document/Title.mjs

@@ -0,0 +1,8 @@
+import { jsx } from "react/jsx-runtime";
+import { DOCUMENT_TITLE_PLACEHOLDER } from "./constants";
+function Title() {
+    return /*#__PURE__*/ jsx("title", {
+        children: DOCUMENT_TITLE_PLACEHOLDER
+    });
+}
+export { Title };

package/dist/esm/document/cli/index.mjs

@@ -0,0 +1,323 @@
+import module_0, { builtinModules } from "module";
+import path from "path";
+import { createDebugger, findExists, fs } from "@modern-js/utils";
+import { decodeHTML } from "entities";
+import { BODY_PARTICALS_SEPARATOR, DOCUMENT_CHUNKSMAP_PLACEHOLDER, DOCUMENT_COMMENT_PLACEHOLDER_END, DOCUMENT_COMMENT_PLACEHOLDER_START, DOCUMENT_FILE_NAME, DOCUMENT_LINKS_PLACEHOLDER, DOCUMENT_META_PLACEHOLDER, DOCUMENT_SCRIPTS_PLACEHOLDER, DOCUMENT_SCRIPT_ATTRIBUTES_END, DOCUMENT_SCRIPT_ATTRIBUTES_START, DOCUMENT_SCRIPT_PLACEHOLDER_END, DOCUMENT_SCRIPT_PLACEHOLDER_START, DOCUMENT_SSRDATASCRIPT_PLACEHOLDER, DOCUMENT_SSR_PLACEHOLDER, DOCUMENT_STYLE_PLACEHOLDER_END, DOCUMENT_STYLE_PLACEHOLDER_START, DOCUMENT_TITLE_PLACEHOLDER, DOC_EXT, HEAD_PARTICALS_SEPARATOR, HTML_SEPARATOR, PLACEHOLDER_REPLACER_MAP, TOP_PARTICALS_SEPARATOR } from "../constants";
+const debug = createDebugger('document');
+const entryName2DocCode = new Map();
+const CONSTANTS = {
+    GLOBAL_DOC_RENDERERS: '__MODERN_DOC_RENDERERS__',
+    DOCUMENT_OUTPUT_DIR: 'document',
+    TEMP_ENTRY_PREFIX: '_entry_',
+    HTML_OUTPUT_PREFIX: '_',
+    HTML_OUTPUT_SUFFIX: '.html.js',
+    CHILD_COMPILER_PREFIX: 'modernjs-document-',
+    COMMONJS_EXTERNAL_PREFIX: 'commonjs ',
+    NODE_PREFIX: 'node:'
+};
+const EXTERNAL_MAPPINGS = {
+    react: 'react',
+    'react/jsx-runtime': 'react/jsx-runtime',
+    'react/jsx-dev-runtime': 'react/jsx-dev-runtime',
+    'react-dom/server': 'react-dom/server'
+};
+const getGlobalDocRenderers = ()=>{
+    const g = globalThis;
+    g[CONSTANTS.GLOBAL_DOC_RENDERERS] = g[CONSTANTS.GLOBAL_DOC_RENDERERS] || {};
+    return g[CONSTANTS.GLOBAL_DOC_RENDERERS];
+};
+const clearGlobalDocRenderer = (entryName)=>{
+    const renderers = getGlobalDocRenderers();
+    if (renderers[entryName]) delete renderers[entryName];
+};
+const decodeHtmlEntities = (input)=>decodeHTML(input);
+const isWindowsAbs = (req)=>/^[a-zA-Z]:[\\/]/.test(req);
+const isRelativeOrAbs = (req)=>req.startsWith('.') || req.startsWith('/') || isWindowsAbs(req);
+const isAsset = (req)=>/\.(css|less|scss|sass|styl|png|jpe?g|gif|svg|ico|woff2?|ttf|eot)(?:[?#].*)?$/.test(req);
+const processScriptPlaceholders = (html, nonce)=>{
+    if (!html.includes(DOCUMENT_SCRIPT_PLACEHOLDER_START) || !html.includes(DOCUMENT_SCRIPT_PLACEHOLDER_END)) return html;
+    const nonceAttr = nonce ? `nonce="${nonce}"` : '';
+    return html.replace(new RegExp(`${DOCUMENT_SCRIPT_PLACEHOLDER_START}${DOCUMENT_SCRIPT_ATTRIBUTES_START}([\\s\\S]*?)${DOCUMENT_SCRIPT_ATTRIBUTES_END}([\\s\\S]*?)${DOCUMENT_SCRIPT_PLACEHOLDER_END}`, 'g'), (_scriptStr, $1, $2)=>`<script ${decodeURIComponent($1)} ${nonceAttr}>${decodeHtmlEntities(decodeURIComponent($2))}</script>`);
+};
+const processStylePlaceholders = (html)=>{
+    if (!html.includes(DOCUMENT_STYLE_PLACEHOLDER_START) || !html.includes(DOCUMENT_STYLE_PLACEHOLDER_END)) return html;
+    return html.replace(new RegExp(`${DOCUMENT_STYLE_PLACEHOLDER_START}([\\s\\S]*?)${DOCUMENT_STYLE_PLACEHOLDER_END}`, 'g'), (_styleStr, $1)=>`<style>${decodeHtmlEntities(decodeURIComponent($1))}</style>`);
+};
+const processCommentPlaceholders = (html)=>{
+    if (!html.includes(DOCUMENT_COMMENT_PLACEHOLDER_START) || !html.includes(DOCUMENT_COMMENT_PLACEHOLDER_END)) return html;
+    return html.replace(new RegExp(`${DOCUMENT_COMMENT_PLACEHOLDER_START}([\\s\\S]*?)${DOCUMENT_COMMENT_PLACEHOLDER_END}`, 'g'), (_scriptStr, $1)=>`${decodeHtmlEntities(decodeURIComponent($1))}`);
+};
+const requireFromString = (code, filename)=>{
+    const m = new module_0.Module(filename, module.parent);
+    m.filename = filename;
+    m.paths = module_0.Module._nodeModulePaths(path.dirname(filename));
+    m._compile(code, filename);
+    return m.exports;
+};
+const getDocumentByEntryName = function(entrypoints, entryName, fallbackDir) {
+    const entryDir = entrypoints.find((item)=>item.entryName === entryName)?.absoluteEntryDir;
+    const entryDirs = DOC_EXT.map((item)=>`${entryDir}${path.sep}${DOCUMENT_FILE_NAME}.${item}`);
+    const fallbackDirs = fallbackDir ? DOC_EXT.map((item)=>[
+            fallbackDir,
+            'src',
+            `${DOCUMENT_FILE_NAME}.${item}`
+        ].join(path.sep)) : [];
+    const docFile = findExists([
+        ...entryDirs,
+        ...fallbackDirs
+    ]);
+    return docFile || void 0;
+};
+const createExternalHandler = ()=>({ request })=>{
+        const req = request || '';
+        if (isAsset(req)) return;
+        if (req.startsWith(CONSTANTS.NODE_PREFIX)) return `${CONSTANTS.COMMONJS_EXTERNAL_PREFIX}${req}`;
+        if (builtinModules.includes(req)) return `${CONSTANTS.COMMONJS_EXTERNAL_PREFIX}${req}`;
+        isRelativeOrAbs(req);
+    };
+const configureChildCompiler = (child, compiler, appDirectory)=>{
+    child.options.mode = compiler.options.mode;
+    child.options.target = 'node';
+    child.options.context = compiler.options.context || appDirectory;
+    child.options.resolve = {
+        ...compiler.options.resolve,
+        fallback: {}
+    };
+    child.options.module = compiler.options.module;
+    child.options.externalsPresets = {
+        node: true
+    };
+    child.options.devtool = false;
+};
+const applyExternalsPlugin = (child, compiler)=>{
+    const ExternalsPlugin = compiler.rspack?.ExternalsPlugin;
+    if (ExternalsPlugin) new ExternalsPlugin('commonjs', [
+        createExternalHandler(),
+        EXTERNAL_MAPPINGS
+    ]).apply(child);
+};
+const generateEntryCode = (docPath, _entryName)=>`var React = require('react');
+var ReactDomServer = require('react-dom/server');
+var exp = require(${JSON.stringify(docPath)});
+var DocumentContext = require('@meta/runtime/document').DocumentContext;
+
+var Document = exp && exp.default;
+
+// expose to global for host to consume
+var g = (typeof globalThis !== 'undefined' ? globalThis : global);
+g.__MODERN_DOC_RENDERERS__ = g.__MODERN_DOC_RENDERERS__ || {};
+
+function render(documentParams) {
+  var HTMLElement = React.createElement(
+    DocumentContext.Provider,
+    { value: documentParams },
+    React.createElement(Document, null)
+  );
+  return ReactDomServer.renderToStaticMarkup(HTMLElement);
+}
+
+g.__MODERN_DOC_RENDERERS__[${JSON.stringify(_entryName)}] = render;
+
+module.exports = { render: render };`;
+const processChildCompilation = async (entryName, docPath, compilation, compiler, appDirectory, internalDirectory)=>new Promise((resolve, reject)=>{
+        const outFile = path.posix.join(CONSTANTS.DOCUMENT_OUTPUT_DIR, `${CONSTANTS.HTML_OUTPUT_PREFIX}${entryName}${CONSTANTS.HTML_OUTPUT_SUFFIX}`);
+        const child = compilation.createChildCompiler(`${CONSTANTS.CHILD_COMPILER_PREFIX}${entryName}`, {
+            filename: outFile,
+            library: {
+                type: 'commonjs2'
+            }
+        }, []);
+        configureChildCompiler(child, compiler, appDirectory);
+        applyExternalsPlugin(child, compiler);
+        const entryDir = path.join(internalDirectory, CONSTANTS.DOCUMENT_OUTPUT_DIR);
+        const tempEntry = path.join(entryDir, `${CONSTANTS.TEMP_ENTRY_PREFIX}${entryName}.js`);
+        const finalize = ()=>{
+            try {
+                const EntryPlugin = compiler.rspack?.EntryPlugin;
+                if (!EntryPlugin) throw new Error('EntryPlugin not available');
+                new EntryPlugin(compiler.context, tempEntry, {
+                    name: `${CONSTANTS.CHILD_COMPILER_PREFIX}${entryName}`
+                }).apply(child);
+                child.runAsChild((err, _entries, childCompilation)=>{
+                    if (err) return reject(err);
+                    try {
+                        if (!childCompilation) throw new Error('Child compilation is undefined');
+                        const asset = childCompilation.assets[outFile] || childCompilation.getAsset?.(outFile)?.source;
+                        const code = 'function' == typeof asset?.source ? asset.source().toString() : 'string' == typeof asset ? asset : asset?.buffer?.().toString?.() || '';
+                        if (code) {
+                            entryName2DocCode.set(entryName, code);
+                            debug('Document child compiler: cached injected bundle for %s', entryName);
+                        } else debug('Document child compiler: empty asset for %s', entryName);
+                        resolve();
+                    } catch (e) {
+                        reject(e);
+                    }
+                });
+            } catch (e) {
+                reject(e);
+            }
+        };
+        try {
+            fs.ensureFile(tempEntry).then(()=>{
+                const entryCode = generateEntryCode(docPath, entryName);
+                return fs.writeFile(tempEntry, entryCode);
+            }).then(finalize).catch((e)=>reject(e));
+        } catch (e) {
+            reject(e);
+        }
+    });
+const documentPlugin = ()=>({
+        name: '@modern-js/plugin-document',
+        pre: [
+            '@modern-js/plugin-analyze'
+        ],
+        setup: async (api)=>{
+            class ModernJsDocumentChildCompilerPlugin {
+                apply(compiler) {
+                    compiler.hooks.make.tapPromise(this.name, async (compilation)=>{
+                        try {
+                            const { entrypoints, appDirectory, internalDirectory } = api.getAppContext();
+                            const tasks = [];
+                            for (const ep of entrypoints || []){
+                                const entryName = ep.entryName;
+                                const docPath = getDocumentByEntryName(entrypoints, entryName, appDirectory);
+                                if (docPath) {
+                                    compilation.fileDependencies?.add?.(docPath);
+                                    clearGlobalDocRenderer(entryName);
+                                    tasks.push(processChildCompilation(entryName, docPath, compilation, compiler, appDirectory, internalDirectory));
+                                }
+                            }
+                            await Promise.all(tasks);
+                        } catch (e) {
+                            debug('Document child compiler make hook failed: %o', e);
+                        }
+                    });
+                }
+                constructor(){
+                    this.name = 'ModernJsDocumentChildCompilerPlugin';
+                }
+            }
+            api.config(()=>{
+                const documentPath = require.resolve('../');
+                return {
+                    resolve: {
+                        alias: {
+                            '@meta/runtime/document$': documentPath.replace(`${path.sep}cjs${path.sep}`, `${path.sep}esm${path.sep}`).replace(/.js$/, '.mjs')
+                        }
+                    },
+                    tools: {
+                        bundlerChain: (chain)=>{
+                            chain.plugin('modernjs-document-child-compiler').use(ModernJsDocumentChildCompilerPlugin, []);
+                        }
+                    }
+                };
+            });
+            const getDocParams = (params)=>{
+                const { config, templateParameters, entryName } = params;
+                return {
+                    processEnv: process.env,
+                    config: {
+                        output: config.output
+                    },
+                    entryName,
+                    templateParams: templateParameters
+                };
+            };
+            const loadRender = async (entryName, internalDirectory)=>{
+                const renderers = getGlobalDocRenderers();
+                const globalRenderer = renderers[entryName];
+                if (globalRenderer) return {
+                    renderer: globalRenderer
+                };
+                const cached = entryName2DocCode.get(entryName);
+                if (!cached) throw new Error(`Failed to load Document bundle for entry "${entryName}". This is likely because the Document component compilation failed or the bundle was not generated correctly. Please check your Document component implementation.`);
+                const filename = path.join(internalDirectory, `./${CONSTANTS.DOCUMENT_OUTPUT_DIR}/${CONSTANTS.HTML_OUTPUT_PREFIX}${entryName}${CONSTANTS.HTML_OUTPUT_SUFFIX}`);
+                requireFromString(cached, filename);
+                return {
+                    renderer: renderers[entryName]
+                };
+            };
+            const processPartials = (html, entryName, partialsByEntrypoint)=>{
+                const partialsContent = {
+                    partialsTop: '',
+                    partialsHead: '',
+                    partialsBody: ''
+                };
+                if (partialsByEntrypoint?.[entryName]) {
+                    partialsContent.partialsTop = partialsByEntrypoint[entryName].top.join('\n');
+                    partialsContent.partialsHead = partialsByEntrypoint[entryName].head.join('\n');
+                    partialsContent.partialsBody = partialsByEntrypoint[entryName].body.join('\n');
+                }
+                return html.replace(TOP_PARTICALS_SEPARATOR, ()=>partialsContent.partialsTop).replace(HEAD_PARTICALS_SEPARATOR, ()=>partialsContent.partialsHead).replace(BODY_PARTICALS_SEPARATOR, ()=>partialsContent.partialsBody);
+            };
+            const extractHtmlTags = (htmlWebpackPlugin, templateParameters)=>{
+                const scripts = [
+                    htmlWebpackPlugin.tags.headTags.filter((item)=>"script" === item.tagName).join(''),
+                    htmlWebpackPlugin.tags.bodyTags.toString()
+                ].join('');
+                const links = htmlWebpackPlugin.tags.headTags.filter((item)=>'link' === item.tagName).join('');
+                const metas = [
+                    templateParameters.meta,
+                    htmlWebpackPlugin.tags.headTags.filter((item)=>"script" !== item.tagName && 'link' !== item.tagName && 'title' !== item.tagName).join('')
+                ].join('');
+                const titles = htmlWebpackPlugin.tags.headTags.filter((item)=>'title' === item.tagName).join('').replace('<title>', '').replace('</title>', '');
+                return {
+                    scripts,
+                    links,
+                    metas,
+                    titles
+                };
+            };
+            const processPlaceholders = (html, config, scripts, links, metas, titles)=>{
+                const { nonce } = config.security || {};
+                let processedHtml = processScriptPlaceholders(html, nonce);
+                processedHtml = processStylePlaceholders(processedHtml);
+                processedHtml = processCommentPlaceholders(processedHtml);
+                return `<!DOCTYPE html>${processedHtml}`.replace(DOCUMENT_META_PLACEHOLDER, ()=>metas).replace(DOCUMENT_SSR_PLACEHOLDER, ()=>HTML_SEPARATOR).replace(DOCUMENT_SCRIPTS_PLACEHOLDER, ()=>scripts).replace(DOCUMENT_LINKS_PLACEHOLDER, ()=>links).replace(DOCUMENT_CHUNKSMAP_PLACEHOLDER, ()=>PLACEHOLDER_REPLACER_MAP[DOCUMENT_CHUNKSMAP_PLACEHOLDER]).replace(DOCUMENT_SSRDATASCRIPT_PLACEHOLDER, ()=>PLACEHOLDER_REPLACER_MAP[DOCUMENT_SSRDATASCRIPT_PLACEHOLDER]).replace(DOCUMENT_TITLE_PLACEHOLDER, ()=>titles);
+            };
+            const documentEntry = (entryName, templateParameters)=>{
+                const { entrypoints, internalDirectory, appDirectory } = api.getAppContext();
+                const documentFilePath = getDocumentByEntryName(entrypoints, entryName, appDirectory);
+                if (!documentFilePath) return null;
+                return async ({ htmlWebpackPlugin })=>{
+                    const config = api.getNormalizedConfig();
+                    const documentParams = getDocParams({
+                        config: config,
+                        entryName,
+                        templateParameters
+                    });
+                    const { renderer } = await loadRender(entryName, internalDirectory);
+                    let html = renderer?.(documentParams);
+                    debug("entry %s's document jsx rendered html: %o", entryName, html);
+                    const { partialsByEntrypoint } = api.getAppContext();
+                    html = processPartials(html, entryName, partialsByEntrypoint || {});
+                    const { scripts, links, metas, titles } = extractHtmlTags(htmlWebpackPlugin, templateParameters);
+                    return processPlaceholders(html, config, scripts, links, metas, titles);
+                };
+            };
+            api.config(()=>{
+                const userConfig = api.getConfig();
+                if (userConfig.tools?.htmlPlugin === false) return {};
+                return {
+                    tools: {
+                        htmlPlugin: (options, entry)=>{
+                            const hackParameters = 'function' == typeof options?.templateParameters ? options?.templateParameters({}, {}, {}, {}) : {
+                                ...options?.templateParameters
+                            };
+                            const templateContent = documentEntry(entry.entryName, hackParameters);
+                            const documentHtmlOptions = templateContent ? {
+                                templateContent,
+                                inject: false
+                            } : {};
+                            return {
+                                ...options,
+                                ...documentHtmlOptions
+                            };
+                        }
+                    }
+                };
+            });
+        }
+    });
+const cli = documentPlugin;
+export { cli as default, documentPlugin, getDocumentByEntryName };

package/dist/esm/document/constants.mjs

@@ -0,0 +1,34 @@
+import { HTML_CHUNKSMAP_SEPARATOR } from "@modern-js/utils/universal/constants";
+const DOC_EXT = [
+    'jsx',
+    'tsx',
+    'ts',
+    'js'
+];
+const DOCUMENT_META_PLACEHOLDER = encodeURIComponent('<%= meta %>');
+const DOCUMENT_TITLE_PLACEHOLDER = encodeURIComponent('<%= title %>');
+const HTML_SEPARATOR = '<!--<?- html ?>-->';
+const HEAD_PARTICALS_SEPARATOR = encodeURIComponent('<!--<?- partials.head ?>-->');
+const BODY_PARTICALS_SEPARATOR = encodeURIComponent('<!--<?- partials.body ?>-->');
+const TOP_PARTICALS_SEPARATOR = encodeURIComponent('<!--<?- partials.top ?>-->');
+const HTML_SSRDATASCRIPT_SEPARATOR = '<!--<?- SSRDataScript ?>-->';
+const DOCUMENT_SSR_PLACEHOLDER = encodeURIComponent(HTML_SEPARATOR);
+const DOCUMENT_CHUNKSMAP_PLACEHOLDER = encodeURIComponent(HTML_CHUNKSMAP_SEPARATOR);
+const DOCUMENT_SSRDATASCRIPT_PLACEHOLDER = encodeURIComponent(HTML_SSRDATASCRIPT_SEPARATOR);
+const DOCUMENT_FILE_NAME = 'Document';
+const DOCUMENT_SCRIPTS_PLACEHOLDER = encodeURIComponent("\x3c!-- chunk scripts placeholder --\x3e");
+const DOCUMENT_LINKS_PLACEHOLDER = encodeURIComponent('<!-- chunk links placeholder -->');
+const DOCUMENT_SCRIPT_PLACEHOLDER_START = encodeURIComponent("\x3c!-- script-start --\x3e");
+const DOCUMENT_SCRIPT_PLACEHOLDER_END = encodeURIComponent("\x3c!-- script-end --\x3e");
+const DOCUMENT_SCRIPT_ATTRIBUTES_START = encodeURIComponent("\x3c!-- script-scriptpProperties-start --\x3e");
+const DOCUMENT_SCRIPT_ATTRIBUTES_END = encodeURIComponent("\x3c!-- script-scriptpProperties-end --\x3e");
+const DOCUMENT_STYLE_PLACEHOLDER_START = encodeURIComponent('<!-- style-start -->');
+const DOCUMENT_STYLE_PLACEHOLDER_END = encodeURIComponent('<!-- style-end -->');
+const DOCUMENT_COMMENT_PLACEHOLDER_START = encodeURIComponent('<!-- comment-start -->');
+const DOCUMENT_COMMENT_PLACEHOLDER_END = encodeURIComponent('<!-- comment-end -->');
+const PLACEHOLDER_REPLACER_MAP = {
+    [DOCUMENT_SSR_PLACEHOLDER]: HTML_SEPARATOR,
+    [DOCUMENT_CHUNKSMAP_PLACEHOLDER]: HTML_CHUNKSMAP_SEPARATOR,
+    [DOCUMENT_SSRDATASCRIPT_PLACEHOLDER]: HTML_SSRDATASCRIPT_SEPARATOR
+};
+export { BODY_PARTICALS_SEPARATOR, DOCUMENT_CHUNKSMAP_PLACEHOLDER, DOCUMENT_COMMENT_PLACEHOLDER_END, DOCUMENT_COMMENT_PLACEHOLDER_START, DOCUMENT_FILE_NAME, DOCUMENT_LINKS_PLACEHOLDER, DOCUMENT_META_PLACEHOLDER, DOCUMENT_SCRIPTS_PLACEHOLDER, DOCUMENT_SCRIPT_ATTRIBUTES_END, DOCUMENT_SCRIPT_ATTRIBUTES_START, DOCUMENT_SCRIPT_PLACEHOLDER_END, DOCUMENT_SCRIPT_PLACEHOLDER_START, DOCUMENT_SSRDATASCRIPT_PLACEHOLDER, DOCUMENT_SSR_PLACEHOLDER, DOCUMENT_STYLE_PLACEHOLDER_END, DOCUMENT_STYLE_PLACEHOLDER_START, DOCUMENT_TITLE_PLACEHOLDER, DOC_EXT, HEAD_PARTICALS_SEPARATOR, HTML_SEPARATOR, HTML_SSRDATASCRIPT_SEPARATOR, PLACEHOLDER_REPLACER_MAP, TOP_PARTICALS_SEPARATOR };

package/dist/esm/exports/config-routes.mjs

@@ -0,0 +1,4 @@
+function defineRoutes(routesCallback) {
+    return routesCallback;
+}
+export { defineRoutes };

package/dist/esm/exports/head.mjs

@@ -0,0 +1,4 @@
+import react_helmet from "react-helmet";
+export * from "react-helmet";
+const head = react_helmet;
+export { head as default };

package/dist/esm/exports/loadable.mjs

@@ -0,0 +1,4 @@
+import component from "@loadable/component";
+export * from "@loadable/component";
+const loadable = component;
+export { loadable as default };

package/dist/esm/index.mjs

@@ -0,0 +1,6 @@
+import { isBrowser } from "./common";
+import { getMonitors } from "./core/context/monitors";
+import { getRequest } from "./core/context/request";
+import { redirect, setHeaders, setStatus } from "./core/context/response";
+import { RuntimeContext, defineRuntimeConfig, useRuntimeContext } from "./core";
+export { RuntimeContext, defineRuntimeConfig, getMonitors, getRequest, isBrowser, redirect, setHeaders, setStatus, useRuntimeContext };

package/dist/esm/internal.mjs

@@ -0,0 +1,2 @@
+import { InternalRuntimeContext } from "./core/context/runtime";
+export { InternalRuntimeContext };

package/dist/esm/react-server.mjs

@@ -0,0 +1,4 @@
+import { getRequest } from "./core/context/request";
+import { getMonitors } from "./core/context/monitors";
+import { redirect, setHeaders, setStatus } from "./core/context/response";
+export { getMonitors, getRequest, redirect, setHeaders, setStatus };

package/dist/esm/router/cli/code/getClientRoutes/getRoutes.mjs

@@ -0,0 +1,115 @@
+import path from "path";
+import { fs } from "@modern-js/utils";
+import { FILE_SYSTEM_ROUTES_COMPONENTS_DIR, FILE_SYSTEM_ROUTES_DYNAMIC_REGEXP, FILE_SYSTEM_ROUTES_INDEX } from "../../constants";
+import { makeLegalIdentifier } from "../makeLegalIdentifier";
+import { replaceWithAlias } from "../utils";
+import { debug, getRouteWeight, shouldSkip } from "./utils";
+const compName = (srcDirectory, filePath)=>{
+    const legalCompName = makeLegalIdentifier(path.relative(srcDirectory, filePath));
+    return `Comp_${legalCompName}`;
+};
+const layoutNameAbbr = (filePath)=>{
+    const prefix = 'L_';
+    const dirName = path.dirname(filePath).split('/').pop() || '';
+    return `${prefix}${makeLegalIdentifier(dirName)}`;
+};
+const parents = [];
+const recursiveReadDir = ({ dir, routes, basePath = '/', srcDirectory, srcAlias })=>{
+    let hasDynamicRoute = false;
+    const resetParent = false;
+    const parent = parents[parents.length - 1];
+    for (const relative of fs.readdirSync(dir)){
+        const filePath = path.join(dir, relative);
+        if (!shouldSkip(filePath)) {
+            const filename = path.basename(filePath, path.extname(filePath));
+            const alias = replaceWithAlias(srcDirectory, filePath, srcAlias);
+            const componentName = compName(srcDirectory, filePath);
+            const dynamicRouteMatched = FILE_SYSTEM_ROUTES_DYNAMIC_REGEXP.exec(filename);
+            if (dynamicRouteMatched) if (hasDynamicRoute) throw new Error(`Can't set two dynamic route in one directory: ${dir}`);
+            else hasDynamicRoute = true;
+            const route = {
+                path: `${basePath}${dynamicRouteMatched ? `:${dynamicRouteMatched[1].replace(/\$$/, '?')}${dynamicRouteMatched[2]}` : filename}`,
+                _component: alias,
+                component: componentName,
+                parent,
+                type: 'page'
+            };
+            if (fs.statSync(filePath).isDirectory()) {
+                recursiveReadDir({
+                    dir: filePath,
+                    routes,
+                    basePath: `${route.path}/`,
+                    srcDirectory,
+                    srcAlias
+                });
+                continue;
+            }
+            if (filename === FILE_SYSTEM_ROUTES_INDEX) route.path = '/' === basePath ? basePath : `${basePath.substring(0, basePath.length - 1)}`;
+            if ('404' === filename && '/' === basePath) route.path = '*';
+            routes.push(route);
+        }
+    }
+    if (resetParent) parents.pop();
+};
+const normalizeNestedRoutes = (nested, internalComponentsDir, internalDirectory, internalDirAlias)=>{
+    const flat = (routes)=>routes.reduce((memo, route)=>memo.concat(Array.isArray(route.children) ? flat(route.children) : [
+                route
+            ]), []);
+    const generate = (route)=>{
+        const codes = [];
+        let lastComponent = route.component;
+        const imports = [
+            "import React from 'react';",
+            `import ${lastComponent} from '${route._component}'`
+        ];
+        while(route = route.parent){
+            const layoutComponent = route.component;
+            const layoutComponentAbbr = layoutNameAbbr(route._component);
+            imports.push(`import ${layoutComponent} from '${route._component}';`);
+            const currentComponent = `${layoutComponentAbbr}_${lastComponent}`;
+            codes.push(`const ${currentComponent} = props => <${layoutComponent} Component={${lastComponent}} {...props} />;`);
+            lastComponent = currentComponent;
+        }
+        const file = path.resolve(internalComponentsDir, `${lastComponent}.jsx`);
+        fs.outputFileSync(file, `${imports.join('\n')}\n${codes.join('\n')}\nexport default ${lastComponent}`);
+        return {
+            component: lastComponent,
+            _component: replaceWithAlias(internalDirectory, file, internalDirAlias)
+        };
+    };
+    const normalized = flat(nested).map((route)=>route.parent ? {
+            ...route,
+            ...generate(route),
+            parent: void 0
+        } : {
+            ...route,
+            parent: void 0
+        });
+    return normalized;
+};
+const getClientRoutes = ({ entrypoint, srcDirectory, srcAlias, internalDirectory, internalDirAlias })=>{
+    const { entryName, pageRoutesEntry } = entrypoint;
+    if (!pageRoutesEntry) return [];
+    if (!fs.existsSync(pageRoutesEntry)) throw new Error(`generate file system routes error, ${pageRoutesEntry} directory not found.`);
+    if (!(fs.existsSync(pageRoutesEntry) && fs.statSync(pageRoutesEntry).isDirectory())) throw new Error(`generate file system routes error, ${pageRoutesEntry} should be directory.`);
+    let routes = [];
+    recursiveReadDir({
+        dir: pageRoutesEntry,
+        routes,
+        basePath: '/',
+        srcDirectory,
+        srcAlias
+    });
+    const internalComponentsDir = path.resolve(internalDirectory, `${entryName}/${FILE_SYSTEM_ROUTES_COMPONENTS_DIR}`);
+    fs.emptyDirSync(internalComponentsDir);
+    routes = normalizeNestedRoutes(routes, internalComponentsDir, internalDirectory, internalDirAlias);
+    parents.length = 0;
+    routes.sort((a, b)=>{
+        const delta = getRouteWeight(a.path) - getRouteWeight(b.path);
+        if (0 === delta) return a.path.length - b.path.length;
+        return delta;
+    });
+    debug("fileSystem routes: %o", routes);
+    return routes;
+};
+export { getClientRoutes };

package/dist/esm/router/cli/code/getClientRoutes/index.mjs

@@ -0,0 +1,2 @@
+import { getClientRoutes } from "./getRoutes";
+export { getClientRoutes };

package/dist/esm/router/cli/code/getClientRoutes/utils.mjs

@@ -0,0 +1,12 @@
+import path from "path";
+import { JS_EXTENSIONS, createDebugger, fs } from "@modern-js/utils";
+import { FILE_SYSTEM_ROUTES_IGNORED_REGEX } from "../../constants";
+const debug = createDebugger('get-client-routes');
+const getRouteWeight = (route)=>'*' === route ? 999 : route.split(':').length - 1;
+const shouldSkip = (file)=>{
+    if (fs.statSync(file).isDirectory()) return false;
+    const ext = path.extname(file);
+    if (FILE_SYSTEM_ROUTES_IGNORED_REGEX.test(file) || !JS_EXTENSIONS.includes(ext)) return true;
+    return false;
+};
+export { debug, getRouteWeight, shouldSkip };