@modern-js/runtime 2.69.7 → 3.0.0-alpha.1

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

@@ -0,0 +1,73 @@
+import fs from "fs";
+import path from "path";
+import { JS_EXTENSIONS, fs as utils_fs, normalizeToPosixPath } from "@modern-js/utils";
+import { parse } from "es-module-lexer";
+import { transform } from "esbuild";
+import { ACTION_EXPORT_NAME, LOADER_EXPORT_NAME } from "../constants";
+const walkDirectory = (dir)=>fs.readdirSync(dir).reduce((previous, filename)=>{
+        const filePath = path.join(dir, filename);
+        if (fs.statSync(filePath).isDirectory()) return [
+            ...previous,
+            ...walkDirectory(filePath)
+        ];
+        return [
+            ...previous,
+            filePath
+        ];
+    }, []);
+const isPageComponentFile = (filePath)=>{
+    if (/\.(d|test|spec|e2e)\.(js|jsx|ts|tsx)$/.test(filePath)) return false;
+    if ([
+        '.js',
+        '.jsx',
+        '.ts',
+        '.tsx'
+    ].includes(path.extname(filePath))) return true;
+    return false;
+};
+const replaceWithAlias = (base, filePath, alias)=>{
+    if (filePath.includes(base)) return normalizeToPosixPath(path.join(alias, path.relative(base, filePath)));
+    return filePath;
+};
+const parseModule = async ({ source, filename })=>{
+    let content = source;
+    if (JS_EXTENSIONS.some((ext)=>filename.endsWith(ext))) {
+        const result = await transform(content, {
+            loader: path.extname(filename).slice(1),
+            format: 'esm'
+        });
+        content = result.code;
+    }
+    return parse(content);
+};
+const hasLoader = async (filename, source)=>{
+    let content = source;
+    if (!source) content = (await utils_fs.readFile(filename, 'utf-8')).toString();
+    if (content) {
+        const [, moduleExports] = await parseModule({
+            source: content.toString(),
+            filename
+        });
+        return moduleExports.some((e)=>e.n === LOADER_EXPORT_NAME);
+    }
+    return false;
+};
+const hasAction = async (filename, source)=>{
+    let content = source;
+    if (!source) content = (await utils_fs.readFile(filename, 'utf-8')).toString();
+    if (content) {
+        const [, moduleExports] = await parseModule({
+            source: content.toString(),
+            filename
+        });
+        return moduleExports.some((e)=>e.n === ACTION_EXPORT_NAME);
+    }
+    return false;
+};
+const getServerLoadersFile = (internalDirectory, entryName)=>path.join(internalDirectory, entryName, 'route-server-loaders.js');
+const getServerCombinedModueFile = (internalDirectory, entryName)=>path.join(internalDirectory, entryName, 'server-loader-combined.js');
+const getPathWithoutExt = (filename)=>{
+    const extname = path.extname(filename);
+    return extname ? filename.slice(0, -extname.length) : filename;
+};
+export { getPathWithoutExt, getServerCombinedModueFile, getServerLoadersFile, hasAction, hasLoader, isPageComponentFile, parseModule, replaceWithAlias, walkDirectory };

package/dist/esm/router/cli/config-routes/converter.mjs

@@ -0,0 +1,82 @@
+import node_path from "node:path";
+import { fs, normalizeToPosixPath } from "@modern-js/utils";
+import { getRouteId } from "../code/nestedRoutes";
+import { getPathWithoutExt, replaceWithAlias } from "../code/utils";
+async function processConfigRoutes(configRoutes, entryName, isMainEntry, configRoutesDir, alias) {
+    return Promise.all(configRoutes.map((configRoute)=>processConfigRoute(configRoute, entryName, isMainEntry, configRoutesDir, alias)));
+}
+async function processConfigRoute(configRoute, entryName, isMainEntry, configRoutesDir, alias) {
+    if ('config' !== configRoute.origin) {
+        if (configRoute.children && configRoute.children.length > 0) {
+            const processedChildren = await Promise.all(configRoute.children.map((child)=>processConfigRoute(child, entryName, isMainEntry, configRoutesDir, alias)));
+            return {
+                ...configRoute,
+                children: processedChildren
+            };
+        }
+        return configRoute;
+    }
+    const componentPath = configRoute.component;
+    const absoluteComponentPath = componentPath ? node_path.isAbsolute(componentPath) ? componentPath : node_path.resolve(configRoutesDir, componentPath) : void 0;
+    const routeId = configRoute.id || getRouteId(componentPath, configRoutesDir, entryName, isMainEntry);
+    const processedRoute = {
+        ...configRoute,
+        id: routeId,
+        path: configRoute.path ?? '',
+        type: 'nested',
+        origin: 'config'
+    };
+    if (absoluteComponentPath) {
+        const componentPathWithAlias = alias ? getPathWithoutExt(replaceWithAlias(alias.basename, absoluteComponentPath, alias.name)) : getPathWithoutExt(absoluteComponentPath);
+        processedRoute._component = componentPathWithAlias;
+    }
+    if (configRoute.children && configRoute.children.length > 0) {
+        const processedChildren = await Promise.all(configRoute.children.map((child)=>processConfigRoute(child, entryName, isMainEntry, configRoutesDir, alias)));
+        processedRoute.children = processedChildren;
+    }
+    if ('page' === configRoute.routeType || !configRoute.routeType && !configRoute.children) {
+        const rawPath = configRoute.path;
+        const isIndexPath = '' === rawPath || '/' === rawPath || 'string' == typeof rawPath && '' === rawPath.replace(/^\/+/, '');
+        if (isIndexPath) {
+            processedRoute.index = true;
+            delete processedRoute.path;
+        }
+    }
+    if (absoluteComponentPath) await discoverRelatedFiles(processedRoute, absoluteComponentPath, alias);
+    return processedRoute;
+}
+async function discoverRelatedFiles(nestedRoute, componentPath, alias) {
+    if ('config' !== nestedRoute.origin) return;
+    const componentDir = node_path.dirname(componentPath);
+    const componentName = node_path.basename(componentPath, node_path.extname(componentPath));
+    const relatedFiles = {
+        data: `${componentName}.data.ts`,
+        clientData: `${componentName}.data.client.ts`,
+        error: `${componentName}.error.tsx`,
+        loading: `${componentName}.loading.tsx`,
+        config: `${componentName}.config.ts`
+    };
+    await Promise.all(Object.entries(relatedFiles).map(async ([key, filename])=>{
+        const filePath = node_path.resolve(componentDir, filename);
+        try {
+            if (await fs.promises.stat(filePath).then((stat)=>stat.isFile()).catch(()=>false)) {
+                const aliasedPath = alias ? replaceWithAlias(alias.basename, filePath, alias.name) : filePath;
+                nestedRoute[key] = normalizeToPosixPath(aliasedPath);
+            }
+        } catch (e) {}
+    }));
+}
+function normalizeRoutes(generatedRoutes) {
+    return generatedRoutes.map((route)=>normalizeRoute(route));
+}
+function normalizeRoute(route) {
+    const { component, ...rest } = route;
+    const processedRoute = {
+        ...rest,
+        ...route.children && route.children.length > 0 ? {
+            children: route.children.map((child)=>normalizeRoute(child))
+        } : {}
+    };
+    return processedRoute;
+}
+export { normalizeRoutes, processConfigRoutes };

package/dist/esm/router/cli/config-routes/parseRouteConfig.mjs

@@ -0,0 +1,105 @@
+import node_path from "node:path";
+import { fs, getMeta, logger } from "@modern-js/utils";
+function createRouteFunctions(basePath) {
+    const resolveComponentPath = (component)=>{
+        if (!component) return component;
+        if (node_path.isAbsolute(component)) return component;
+        if (component.startsWith('./') || component.startsWith('../') || !component.startsWith('@')) return node_path.resolve(basePath, component);
+        return component;
+    };
+    const createNestedRoute = (component, routePath, children = [], routeType, wildcard = false)=>{
+        if ('string' == typeof component && component.startsWith('@')) throw new Error('component path must be absolute or relative; alias is not allowed');
+        if (void 0 !== routePath && 'string' != typeof routePath) throw new Error('Route path must be a string');
+        const resolvedComponent = resolveComponentPath(component);
+        if ('page' === routeType || wildcard) {
+            if (!component || '' === component.trim()) throw new Error('page route must specify a non-empty component path');
+            if (!fs.pathExistsSync(resolvedComponent)) throw new Error(`page component not found: ${resolvedComponent}`);
+        }
+        if (wildcard) return {
+            path: routePath || '*',
+            component: resolvedComponent,
+            routeType: 'page',
+            origin: 'config',
+            type: 'nested',
+            children: children.length > 0 ? children : void 0
+        };
+        if (!routeType) throw new Error('createRouteConfig must specify route type');
+        return {
+            path: routePath,
+            component: resolvedComponent,
+            routeType,
+            origin: 'config',
+            type: 'nested',
+            children: children.length > 0 ? children : void 0
+        };
+    };
+    return {
+        route: (component, pathOrChildren, maybeChildren)=>{
+            const path = Array.isArray(pathOrChildren) ? void 0 : pathOrChildren;
+            const children = Array.isArray(pathOrChildren) ? pathOrChildren : maybeChildren ?? [];
+            const routeType = children.length > 0 ? 'layout' : 'page';
+            return createNestedRoute(component, path, children, routeType);
+        },
+        layout: (component, pathOrChildren, maybeChildren)=>{
+            const path = Array.isArray(pathOrChildren) ? void 0 : pathOrChildren;
+            const children = Array.isArray(pathOrChildren) ? pathOrChildren : maybeChildren ?? [];
+            if (0 === children.length) throw new Error('layout route must have children');
+            return createNestedRoute(component, path, children, 'layout');
+        },
+        page: (component, path)=>createNestedRoute(component, path, [], 'page'),
+        $: (component, path)=>createNestedRoute(component, path, [], void 0, true)
+    };
+}
+async function findConfigRoutesFile(entrypoint, appContext) {
+    const { absoluteEntryDir } = entrypoint;
+    if (!absoluteEntryDir) return null;
+    const { metaName } = appContext;
+    const meta = getMeta(metaName);
+    const possibleNames = [
+        `${meta}.routes.ts`,
+        `${meta}.routes.mts`,
+        `${meta}.routes.tsx`,
+        `${meta}.routes.js`,
+        `${meta}.routes.mjs`,
+        `${meta}.routes.jsx`
+    ];
+    for (const filename of possibleNames){
+        const filePath = node_path.resolve(absoluteEntryDir, filename);
+        if (await fs.pathExists(filePath)) {
+            const stats = await fs.stat(filePath);
+            if (stats.isFile()) {
+                logger.debug(`Found config routes file: ${filePath}`);
+                return filePath;
+            }
+        }
+    }
+    return null;
+}
+async function parseConfigRoutesFile(filePath, entrypoint, fileRoutes) {
+    const { loadTypeScriptFile } = await import("@modern-js/plugin/run");
+    const configModule = loadTypeScriptFile(filePath);
+    if (!configModule.default || 'function' != typeof configModule.default) throw new Error(`Config routes file must export a default function. Found: ${typeof configModule.default}`);
+    const routeFunctions = createRouteFunctions(entrypoint.absoluteEntryDir);
+    let routesConfig;
+    if (!fileRoutes) throw new Error("Routes function expects file routes parameter, but none provided");
+    routesConfig = configModule.default(routeFunctions, fileRoutes);
+    if (!Array.isArray(routesConfig)) throw new Error(`Config routes function must return an array of routes. Received: ${typeof routesConfig}`);
+    return {
+        entryName: entrypoint.entryName,
+        filePath,
+        routes: routesConfig,
+        isMainEntry: entrypoint.isMainEntry || false
+    };
+}
+async function discoverAndParseConfigRoutes(entrypoint, appContext, fileRoutes) {
+    const configFilePath = await findConfigRoutesFile(entrypoint, appContext);
+    if (!configFilePath) {
+        logger.debug(`No config routes file found for entry: ${entrypoint.entryName}`);
+        return null;
+    }
+    const configRouteFile = await parseConfigRoutesFile(configFilePath, entrypoint, fileRoutes);
+    logger.debug(`Successfully loaded config routes from: ${configFilePath}`);
+    logger.debug(`Found ${configRouteFile.routes.length} route(s) for entry: ${entrypoint.entryName}`);
+    return configRouteFile;
+}
+export { discoverAndParseConfigRoutes, findConfigRoutesFile, parseConfigRoutesFile };

package/dist/esm/router/cli/constants.mjs

@@ -0,0 +1,32 @@
+const NESTED_ROUTES_DIR = 'routes';
+const FILE_SYSTEM_ROUTES_FILE_NAME = 'routes.js';
+const LOADER_EXPORT_NAME = 'loader';
+const ACTION_EXPORT_NAME = 'action';
+const TEMP_LOADERS_DIR = '__loaders__';
+const FILE_SYSTEM_ROUTES_INDEX = 'index';
+const FILE_SYSTEM_ROUTES_IGNORED_REGEX = /\.(d|test|spec|e2e)\.(js|jsx|ts|tsx)$/;
+const FILE_SYSTEM_ROUTES_DYNAMIC_REGEXP = /^\[(\S+)\]([*+?]?)$/;
+const FILE_SYSTEM_ROUTES_COMPONENTS_DIR = 'internal_components';
+const APP_CONFIG_NAME = 'config';
+const APP_INIT_EXPORTED = 'init';
+const NESTED_ROUTE = {
+    LAYOUT_FILE: 'layout',
+    LAYOUT_CONFIG_FILE: 'layout.config',
+    LAYOUT_LOADER_FILE: 'layout.loader',
+    LAYOUT_DATA_FILE: 'layout.data',
+    LAYOUT_CLIENT_LOADER: 'layout.data.client',
+    PAGE_FILE: 'page',
+    PAGE_CONFIG_FILE: 'page.config',
+    PAGE_LOADER_FILE: 'page.loader',
+    PAGE_DATA_FILE: 'page.data',
+    PAGE_CLIENT_LOADER: 'page.data.client',
+    SPLATE_FILE: '$',
+    SPLATE_CONFIG_FILE: '$.config',
+    SPLATE_LOADER_FILE: '$.loader',
+    SPLATE_DATA_FILE: '$.data',
+    SPLATE_CLIENT_DATA: '$.data.client',
+    LOADING_FILE: 'loading',
+    ERROR_FILE: 'error',
+    LOADER_FILE: 'loader'
+};
+export { ACTION_EXPORT_NAME, APP_CONFIG_NAME, APP_INIT_EXPORTED, FILE_SYSTEM_ROUTES_COMPONENTS_DIR, FILE_SYSTEM_ROUTES_DYNAMIC_REGEXP, FILE_SYSTEM_ROUTES_FILE_NAME, FILE_SYSTEM_ROUTES_IGNORED_REGEX, FILE_SYSTEM_ROUTES_INDEX, LOADER_EXPORT_NAME, NESTED_ROUTE, NESTED_ROUTES_DIR, TEMP_LOADERS_DIR };

package/dist/esm/router/cli/entry.mjs

@@ -0,0 +1,22 @@
+import path from "path";
+import { fs } from "@modern-js/utils";
+import { hasApp } from "../../cli/entry";
+import { NESTED_ROUTES_DIR } from "./constants";
+const hasNestedRoutes = (dir)=>fs.existsSync(path.join(dir, NESTED_ROUTES_DIR));
+const isRouteEntry = (dir)=>{
+    if (hasNestedRoutes(dir)) return path.join(dir, NESTED_ROUTES_DIR);
+    return false;
+};
+const modifyEntrypoints = (entrypoints)=>entrypoints.map((entrypoint)=>{
+        if (!entrypoint.isAutoMount) return entrypoint;
+        if (entrypoint?.isCustomSourceEntry) {
+            if (entrypoint.fileSystemRoutes) entrypoint.nestedRoutesEntry = entrypoint.absoluteEntryDir || entrypoint.entry;
+            return entrypoint;
+        }
+        const isHasApp = hasApp(entrypoint.absoluteEntryDir);
+        if (isHasApp) return entrypoint;
+        const isHasNestedRoutes = hasNestedRoutes(entrypoint.absoluteEntryDir);
+        if (isHasNestedRoutes) entrypoint.nestedRoutesEntry = path.join(entrypoint.absoluteEntryDir, NESTED_ROUTES_DIR);
+        return entrypoint;
+    });
+export { hasNestedRoutes, isRouteEntry, modifyEntrypoints };

package/dist/esm/router/cli/handler.mjs

@@ -0,0 +1,66 @@
+import path from "path";
+import { getMeta } from "@modern-js/utils";
+import { cloneDeep } from "@modern-js/utils/lodash";
+import { runtimeGlobalContext } from "./code/templates";
+import { isPageComponentFile } from "./code/utils";
+import { modifyEntrypoints } from "./entry";
+let originEntrypoints = [];
+async function handleModifyEntrypoints(entrypoints) {
+    return modifyEntrypoints(entrypoints);
+}
+async function handleGeneratorEntryCode(api, entrypoints) {
+    const appContext = api.getAppContext();
+    const { internalDirectory } = appContext;
+    const resolvedConfig = api.getNormalizedConfig();
+    const { generatorRegisterCode, generateCode, generatorServerRegisterCode } = await import("./code");
+    originEntrypoints = cloneDeep(entrypoints);
+    const enableRsc = resolvedConfig?.server?.rsc;
+    await generateCode(appContext, resolvedConfig, entrypoints, api);
+    await Promise.all(entrypoints.map(async (entrypoint)=>{
+        if (entrypoint.nestedRoutesEntry || entrypoint.pageRoutesEntry) {
+            const route = appContext.serverRoutes.find((r)=>r.entryName === entrypoint.entryName);
+            const basename = route?.urlPath || '/';
+            generatorRegisterCode(internalDirectory, entrypoint.entryName, await runtimeGlobalContext({
+                entryName: entrypoint.entryName,
+                metaName: appContext.metaName,
+                srcDirectory: appContext.srcDirectory,
+                nestedRoutesEntry: entrypoint.nestedRoutesEntry,
+                internalSrcAlias: appContext.internalSrcAlias,
+                globalApp: entrypoint.fileSystemRoutes?.globalApp,
+                rscType: enableRsc ? 'client' : void 0,
+                basename
+            }));
+            if (enableRsc) generatorServerRegisterCode(internalDirectory, entrypoint.entryName, await runtimeGlobalContext({
+                entryName: entrypoint.entryName,
+                metaName: appContext.metaName,
+                srcDirectory: appContext.srcDirectory,
+                nestedRoutesEntry: entrypoint.nestedRoutesEntry,
+                internalSrcAlias: appContext.internalSrcAlias,
+                globalApp: entrypoint.fileSystemRoutes?.globalApp,
+                rscType: 'server',
+                basename
+            }));
+        }
+    }));
+    return entrypoints;
+}
+async function handleFileChange(api, e) {
+    const appContext = api.getAppContext();
+    const { appDirectory, entrypoints } = appContext;
+    const { filename, eventType } = e;
+    const nestedRouteEntries = entrypoints.map((point)=>point.nestedRoutesEntry).filter(Boolean);
+    const pagesDir = entrypoints.map((point)=>point.entry).filter((entry)=>entry && !path.extname(entry)).concat(nestedRouteEntries);
+    const isPageFile = (name)=>pagesDir.some((pageDir)=>name.includes(pageDir));
+    const absoluteFilePath = path.resolve(appDirectory, filename);
+    const isRouteComponent = isPageFile(absoluteFilePath) && isPageComponentFile(absoluteFilePath);
+    const meta = getMeta(appContext.metaName);
+    const normalizedFilename = filename.replace(/\\/g, '/');
+    const isConfigRoutesFile = normalizedFilename.includes(`${meta}.routes.`) && /\.(js|ts|jsx|tsx|mjs|mts)$/i.test(path.extname(filename));
+    if (isRouteComponent && ('add' === eventType || 'unlink' === eventType) || isConfigRoutesFile && ('change' === eventType || 'add' === eventType || 'unlink' === eventType)) {
+        const resolvedConfig = api.getNormalizedConfig();
+        const { generateCode } = await import("./code");
+        const entrypoints = cloneDeep(originEntrypoints);
+        await generateCode(appContext, resolvedConfig, entrypoints, api);
+    }
+}
+export { handleFileChange, handleGeneratorEntryCode, handleModifyEntrypoints };

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

@@ -0,0 +1,80 @@
+import node_path from "node:path";
+import { NESTED_ROUTE_SPEC_FILE, filterRoutesForServer, fs } from "@modern-js/utils";
+import { isRouteEntry } from "./entry";
+import { handleFileChange, handleGeneratorEntryCode, handleModifyEntrypoints } from "./handler";
+const routerPlugin = ()=>({
+        name: '@modern-js/plugin-router',
+        required: [
+            '@modern-js/runtime'
+        ],
+        setup: (api)=>{
+            const nestedRoutes = {};
+            const nestedRoutesForServer = {};
+            const { metaName } = api.getAppContext();
+            api.addCommand(({ program })=>{
+                program.command('routes').description('generate routes inspect report').action(async ()=>{
+                    const { generateRoutesInspectReport } = await import("./code/inspect");
+                    await generateRoutesInspectReport(api);
+                });
+            });
+            api._internalRuntimePlugins(({ entrypoint, plugins })=>{
+                const { nestedRoutesEntry } = entrypoint;
+                const { serverRoutes, metaName } = api.getAppContext();
+                const serverBase = serverRoutes.filter((route)=>route.entryName === entrypoint.entryName).map((route)=>route.urlPath).sort((a, b)=>a.length - b.length > 0 ? -1 : 1);
+                if (nestedRoutesEntry) plugins.push({
+                    name: 'router',
+                    path: `@${metaName}/runtime/router/internal`,
+                    config: {
+                        serverBase
+                    }
+                });
+                return {
+                    entrypoint,
+                    plugins
+                };
+            });
+            api.checkEntryPoint(({ path, entry })=>({
+                    path,
+                    entry: entry || isRouteEntry(path)
+                }));
+            api.config(()=>({
+                    source: {
+                        include: [
+                            /[\\/]node_modules[\\/]react-router[\\/]/,
+                            /[\\/]node_modules[\\/]react-router-dom[\\/]/,
+                            node_path.resolve(__dirname, '../runtime').replace('cjs', 'esm')
+                        ]
+                    }
+                }));
+            api.modifyEntrypoints(async ({ entrypoints })=>{
+                const newEntryPoints = await handleModifyEntrypoints(entrypoints);
+                return {
+                    entrypoints: newEntryPoints
+                };
+            });
+            api.generateEntryCode(async ({ entrypoints })=>{
+                await handleGeneratorEntryCode(api, entrypoints);
+            });
+            api.onFileChanged(async (e)=>{
+                await handleFileChange(api, e);
+            });
+            api.modifyFileSystemRoutes(({ entrypoint, routes })=>{
+                nestedRoutes[entrypoint.entryName] = routes;
+                nestedRoutesForServer[entrypoint.entryName] = filterRoutesForServer(routes);
+                return {
+                    entrypoint,
+                    routes
+                };
+            });
+            api.onBeforeGenerateRoutes(async ({ entrypoint, code })=>{
+                const { distDirectory } = api.getAppContext();
+                await fs.outputJSON(node_path.resolve(distDirectory, NESTED_ROUTE_SPEC_FILE), nestedRoutesForServer);
+                return {
+                    entrypoint,
+                    code
+                };
+            });
+        }
+    });
+const cli = routerPlugin;
+export { cli as default, handleFileChange, handleModifyEntrypoints, isRouteEntry, routerPlugin };

package/dist/{esm-node/router/internal.js → esm/router/internal.mjs}

@@ -1,5 +1,3 @@
-export * from "./runtime/internal";
 import { routerPlugin } from "./runtime/internal";
-export {
-  routerPlugin as default
-};
+export * from "./runtime/internal";
+export { routerPlugin as default };

package/dist/esm/router/runtime/DefaultNotFound.mjs

@@ -0,0 +1,13 @@
+import { jsx } from "react/jsx-runtime";
+import "react";
+const DefaultNotFound = ()=>/*#__PURE__*/ jsx("div", {
+        style: {
+            margin: '150px auto',
+            textAlign: 'center',
+            display: 'flex',
+            alignItems: 'center',
+            justifyContent: 'center'
+        },
+        children: "404"
+    });
+export { DefaultNotFound };

package/dist/esm/router/runtime/DeferredDataScripts.mjs

@@ -0,0 +1,2 @@
+const DeferredDataScripts = ()=>null;
+export { DeferredDataScripts as default };

package/dist/esm/router/runtime/DeferredDataScripts.node.mjs

@@ -0,0 +1,120 @@
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { serializeJson, storage } from "@modern-js/runtime-utils/node";
+import { useEffect, useMemo, useRef } from "react";
+import { ROUTER_DATA_JSON_ID } from "../../core/constants";
+import { modernInline, runWindowFnStr } from "./constants";
+import { serializeErrors } from "./utils";
+const DeferredDataScripts = (props)=>{
+    const staticContext = props?.context;
+    const useJsonScript = props?.useJsonScript;
+    const hydratedRef = useRef(false);
+    useEffect(()=>{
+        hydratedRef.current = true;
+    }, []);
+    const deferredScripts = useMemo(()=>{
+        if (!staticContext) return null;
+        const activeDeferreds = storage.useContext().activeDeferreds;
+        const _ROUTER_DATA = {
+            loaderData: staticContext.loaderData,
+            errors: serializeErrors(staticContext.errors)
+        };
+        const initialScript0 = useJsonScript ? `${serializeJson(_ROUTER_DATA)}` : '';
+        const initialScript1 = useJsonScript ? modernInline : [
+            `_ROUTER_DATA = ${serializeJson(_ROUTER_DATA)};`,
+            modernInline
+        ].join('\n');
+        const deferredDataScripts = [];
+        const initialScripts = Array.from(activeDeferreds.entries()).map(([routeId, deferredData])=>{
+            const pendingKeys = new Set(deferredData.pendingKeys);
+            const { deferredKeys } = deferredData;
+            const deferredKeyPromiseManifests = deferredKeys.map((key)=>{
+                if (pendingKeys.has(key)) return {
+                    key,
+                    routerDataFnName: 's',
+                    routerDataFnArgs: [
+                        serializeJson(routeId),
+                        serializeJson(key)
+                    ]
+                };
+                {
+                    const trackedPromise = deferredData.data[key];
+                    if (void 0 !== trackedPromise._error) {
+                        const error = {
+                            message: trackedPromise._error.message,
+                            stack: 'production' !== process.env.NODE_ENV ? trackedPromise._error.stack : void 0
+                        };
+                        return {
+                            key,
+                            routerDataFnName: 'p',
+                            routerDataFnArgs: [
+                                serializeJson(void 0),
+                                serializeJson(error)
+                            ]
+                        };
+                    }
+                    if (void 0 === trackedPromise._data) throw new Error(`The deferred data for ${key} was not resolved, did you forget to return data from a deferred promise`);
+                    return {
+                        key,
+                        routerDataFnName: 'p',
+                        routerDataFnArgs: [
+                            serializeJson(trackedPromise._data)
+                        ]
+                    };
+                }
+            });
+            return {
+                fnName: "mergeLoaderData",
+                fnRun: runWindowFnStr,
+                fnArgs: [
+                    routeId,
+                    deferredKeyPromiseManifests
+                ],
+                fnScriptSrc: 'modern-run-window-fn'
+            };
+        });
+        return [
+            initialScript0,
+            initialScript1,
+            initialScripts,
+            deferredDataScripts
+        ];
+    }, []);
+    if (!deferredScripts) return null;
+    return /*#__PURE__*/ jsx(Fragment, {
+        children: !hydratedRef.current && /*#__PURE__*/ jsxs(Fragment, {
+            children: [
+                0 !== deferredScripts[0].length && /*#__PURE__*/ jsx("script", {
+                    type: "application/json",
+                    id: ROUTER_DATA_JSON_ID,
+                    nonce: props?.nonce,
+                    suppressHydrationWarning: true,
+                    dangerouslySetInnerHTML: {
+                        __html: deferredScripts[0]
+                    }
+                }),
+                /*#__PURE__*/ jsx("script", {
+                    async: true,
+                    nonce: props?.nonce,
+                    "data-script-src": "modern-inline",
+                    suppressHydrationWarning: true,
+                    dangerouslySetInnerHTML: {
+                        __html: deferredScripts[1]
+                    }
+                }),
+                deferredScripts[2].map(({ fnName, fnArgs, fnRun, fnScriptSrc })=>/*#__PURE__*/ jsx("script", {
+                        async: true,
+                        "data-script-src": fnScriptSrc,
+                        "data-fn-name": fnName,
+                        "data-fn-args": JSON.stringify(fnArgs),
+                        nonce: props?.nonce,
+                        suppressHydrationWarning: true,
+                        dangerouslySetInnerHTML: {
+                            __html: fnRun
+                        }
+                    }, fnName))
+            ]
+        })
+    });
+};
+const DeferredDataScripts_node = DeferredDataScripts;
+export { DeferredDataScripts_node as default };