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

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

@@ -0,0 +1,351 @@
+import { createDebugger, findExists, fs, logger } from "@modern-js/utils";
+import { decodeHTML } from "entities";
+import module_0, { builtinModules } from "module";
+import path from "path";
+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.mjs";
+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;
+    if (child.options.optimization && 'object' == typeof child.options.optimization) child.options.optimization.minimize = false;
+    else child.options.optimization = {
+        minimize: false
+    };
+};
+const applyExternalsPlugin = (child, compiler)=>{
+    const ExternalsPlugin = compiler.rspack?.ExternalsPlugin;
+    if (ExternalsPlugin) new ExternalsPlugin('commonjs', [
+        createExternalHandler(),
+        EXTERNAL_MAPPINGS
+    ]).apply(child);
+};
+const generateEntryCode = (docPath, _entryName)=>{
+    const runtimeAPI = require.resolve('../');
+    const esmRuntimeAPI = runtimeAPI.replace("cjs", "esm").replace(/.js$/, '.mjs');
+    return `import React from 'react';
+import ReactDomServer from 'react-dom/server';
+import Document from ${JSON.stringify(docPath)};
+import { DocumentContext } from ${JSON.stringify(esmRuntimeAPI)};
+
+// 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;
+
+export default { 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) {
+                        logger.error(`Document child compiler failed for entry "${entryName}": ${err.message}`);
+                        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) {
+                            const errorMsg = `Document child compiler produced empty output for entry "${entryName}". Please check your Document component for syntax errors.`;
+                            logger.error(errorMsg);
+                            reject(new Error(errorMsg));
+                            return;
+                        }
+                        entryName2DocCode.set(entryName, code);
+                        debug('Document child compiler: cached injected bundle for %s', entryName);
+                        resolve();
+                    } catch (e) {
+                        const err = e;
+                        logger.error(`Document child compiler failed to process output for entry "${entryName}": ${err.message}`);
+                        reject(err);
+                    }
+                });
+            } catch (e) {
+                const err = e;
+                logger.error(`Document child compiler failed to initialize for entry "${entryName}": ${err.message}`);
+                reject(err);
+            }
+        };
+        try {
+            fs.ensureFile(tempEntry).then(()=>{
+                const entryCode = generateEntryCode(docPath, entryName);
+                return fs.writeFile(tempEntry, entryCode);
+            }).then(finalize).catch((e)=>{
+                const err = e;
+                logger.error(`Document child compiler failed to prepare entry file for "${entryName}": ${err.message}`);
+                reject(err);
+            });
+        } catch (e) {
+            const err = e;
+            logger.error(`Document child compiler failed to create entry directory for "${entryName}": ${err.message}`);
+            reject(err);
+        }
+    });
+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) {
+                            const err = e;
+                            logger.error(`Document child compiler failed: ${err.message}`);
+                            debug('Document child compiler make hook failed: %o', e);
+                            throw err;
+                        }
+                    });
+                }
+                constructor(){
+                    this.name = 'ModernJsDocumentChildCompilerPlugin';
+                }
+            }
+            api.config(()=>({
+                    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(`Document bundle not found for entry "${entryName}". The Document component compilation may have failed.`);
+                const filename = path.join(internalDirectory, `./${CONSTANTS.DOCUMENT_OUTPUT_DIR}/${CONSTANTS.HTML_OUTPUT_PREFIX}${entryName}${CONSTANTS.HTML_OUTPUT_SUFFIX}`);
+                requireFromString(cached, filename);
+                const renderer = renderers[entryName];
+                if (!renderer) throw new Error(`Document renderer not found for entry "${entryName}". Please ensure your Document component exports a valid default component.`);
+                return {
+                    renderer
+                };
+            };
+            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 = (htmlPlugin, templateParameters)=>{
+                const scripts = [
+                    htmlPlugin.tags.headTags.filter((item)=>"script" === item.tagName).join(''),
+                    htmlPlugin.tags.bodyTags.toString()
+                ].join('');
+                const links = htmlPlugin.tags.headTags.filter((item)=>'link' === item.tagName).join('');
+                const metas = [
+                    templateParameters.meta,
+                    htmlPlugin.tags.headTags.filter((item)=>"script" !== item.tagName && 'link' !== item.tagName && 'title' !== item.tagName).join('')
+                ].join('');
+                const titles = htmlPlugin.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 ({ htmlPlugin })=>{
+                    const config = api.getNormalizedConfig();
+                    const documentParams = getDocParams({
+                        config: config,
+                        entryName,
+                        templateParameters
+                    });
+                    let html;
+                    try {
+                        const { renderer } = await loadRender(entryName, internalDirectory);
+                        html = renderer(documentParams);
+                    } catch (error) {
+                        const err = error;
+                        logger.error(`Failed to render Document for entry "${entryName}": ${err.message}`);
+                        throw err;
+                    }
+                    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(htmlPlugin, 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 default cli;
+export { 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/document/index.mjs

@@ -0,0 +1,12 @@
+export * from "./Body.mjs";
+export * from "./Comment.mjs";
+export * from "./constants.mjs";
+export * from "./DocumentContext.mjs";
+export * from "./DocumentStructureContext.mjs";
+export * from "./Head.mjs";
+export * from "./Html.mjs";
+export * from "./Links.mjs";
+export * from "./Root.mjs";
+export * from "./Script.mjs";
+export * from "./Scripts.mjs";
+export * from "./Style.mjs";

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,5 @@
+"use client";
+import react_helmet, { Helmet } from "react-helmet";
+const head = react_helmet;
+export default head;
+export { Helmet };

package/dist/esm/exports/loadable.mjs

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

package/dist/esm/exports/tanstack-router.mjs

@@ -0,0 +1,3 @@
+export * from "@tanstack/react-router";
+export { Form, RouteActionResponseError, useFetcher } from "../router/runtime/tanstack/dataMutation.mjs";
+export { Link, NavLink } from "../router/runtime/tanstack/prefetchLink.mjs";

package/dist/esm/index.mjs

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

package/dist/esm/internal.mjs

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

package/dist/esm/react-server.mjs

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

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

@@ -0,0 +1,115 @@
+import { fs } from "@modern-js/utils";
+import path from "path";
+import { FILE_SYSTEM_ROUTES_COMPONENTS_DIR, FILE_SYSTEM_ROUTES_DYNAMIC_REGEXP, FILE_SYSTEM_ROUTES_INDEX } from "../../constants.mjs";
+import { makeLegalIdentifier } from "../makeLegalIdentifier.mjs";
+import { replaceWithAlias } from "../utils.mjs";
+import { debug, getRouteWeight, shouldSkip } from "./utils.mjs";
+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 @@
+export { getClientRoutes } from "./getRoutes.mjs";

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

@@ -0,0 +1,12 @@
+import { JS_EXTENSIONS, createDebugger, fs } from "@modern-js/utils";
+import path from "path";
+import { FILE_SYSTEM_ROUTES_IGNORED_REGEX } from "../../constants.mjs";
+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 };