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

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

@@ -0,0 +1,161 @@
+"use client";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { Link as router_Link, NavLink, matchRoutes, useHref, useMatches, useResolvedPath } from "@modern-js/runtime-utils/router";
+import react, { useContext, useMemo } from "react";
+import { InternalRuntimeContext } from "../../core/context";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.e = ()=>Promise.resolve();
+})();
+function composeEventHandlers(theirHandler, ourHandler) {
+    return (event)=>{
+        theirHandler?.(event);
+        if (!event.defaultPrevented) ourHandler(event);
+    };
+}
+const ABSOLUTE_URL_REGEX = /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i;
+function usePrefetchBehavior(prefetch, theirElementProps) {
+    const [maybePrefetch, setMaybePrefetch] = react.useState(false);
+    const [shouldPrefetch, setShouldPrefetch] = react.useState(false);
+    const { onFocus, onBlur, onMouseEnter, onMouseLeave, onTouchStart } = theirElementProps;
+    react.useEffect(()=>{
+        if ('render' === prefetch) setShouldPrefetch(true);
+    }, [
+        prefetch
+    ]);
+    const setIntent = ()=>{
+        if ('intent' === prefetch) setMaybePrefetch(true);
+    };
+    const cancelIntent = ()=>{
+        if ('intent' === prefetch) {
+            setMaybePrefetch(false);
+            setShouldPrefetch(false);
+        }
+    };
+    react.useEffect(()=>{
+        if (maybePrefetch) {
+            const id = setTimeout(()=>{
+                setShouldPrefetch(true);
+            }, 100);
+            return ()=>{
+                clearTimeout(id);
+            };
+        }
+    }, [
+        maybePrefetch
+    ]);
+    return [
+        shouldPrefetch,
+        {
+            onFocus: composeEventHandlers(onFocus, setIntent),
+            onBlur: composeEventHandlers(onBlur, cancelIntent),
+            onMouseEnter: composeEventHandlers(onMouseEnter, setIntent),
+            onMouseLeave: composeEventHandlers(onMouseLeave, cancelIntent),
+            onTouchStart: composeEventHandlers(onTouchStart, setIntent)
+        }
+    ];
+}
+async function loadRouteModule(route, routeAssets) {
+    const routeId = route.id;
+    if (!routeId) return;
+    if (!routeAssets[routeId]) return;
+    const { chunkIds } = routeAssets[routeId];
+    if (!chunkIds) return;
+    try {
+        await Promise.all(chunkIds.map((chunkId)=>{
+            if ('test' === process.env.NODE_ENV) return __webpack_require__.e?.(chunkId);
+            return __webpack_chunk_load__?.(chunkId);
+        }));
+    } catch (error) {
+        console.error(error);
+    }
+}
+const getRequestUrl = (pathname, routeId)=>{
+    const LOADER_ID_PARAM = '__loader';
+    const DIRECT_PARAM = '__ssrDirect';
+    const { protocol, host } = window.location;
+    const url = new URL(pathname, `${protocol}//${host}`);
+    url.searchParams.append(LOADER_ID_PARAM, routeId);
+    url.searchParams.append(DIRECT_PARAM, 'true');
+    return url;
+};
+const createDataHref = (href)=>/*#__PURE__*/ jsx("link", {
+        rel: "prefetch",
+        as: "fetch",
+        href: href
+    }, href);
+const getDataHref = (route, pathname, basename)=>{
+    const { id } = route;
+    const path = '/' === basename ? pathname : `${basename}${pathname}`;
+    const url = getRequestUrl(path, id);
+    return createDataHref(url.toString());
+};
+const PrefetchPageLinks = ({ path })=>{
+    const { pathname } = path;
+    const context = useContext(InternalRuntimeContext);
+    const { routeManifest, routes } = context;
+    const { routeAssets } = routeManifest || {};
+    const matches = Array.isArray(routes) ? matchRoutes(routes, pathname) : [];
+    if (Array.isArray(matches) && routeAssets) matches?.forEach((match)=>loadRouteModule(match.route, routeAssets));
+    if (!window._SSR_DATA) return null;
+    return /*#__PURE__*/ jsx(PrefetchDataLinks, {
+        matches: matches,
+        path: path,
+        routeManifest: routeManifest
+    });
+};
+const PrefetchDataLinks = ({ matches, path, routeManifest })=>{
+    const { pathname, search, hash } = path;
+    const currentMatches = useMatches();
+    const basename = useHref('/');
+    const dataHrefs = useMemo(()=>matches?.filter((match, index)=>{
+            if (!match.route.loader || 'function' != typeof match.route.loader || 0 === match.route.loader.length) return false;
+            if (match.route.shouldRevalidate) {
+                const currentUrl = new URL(location.pathname + location.search + location.hash, window.origin);
+                const nextUrl = new URL(pathname + search + hash, window.origin);
+                const shouldLoad = match.route.shouldRevalidate({
+                    currentUrl,
+                    currentParams: currentMatches[0]?.params || {},
+                    nextUrl,
+                    nextParams: match.params,
+                    defaultShouldRevalidate: true
+                });
+                if ('boolean' == typeof shouldLoad) return shouldLoad;
+            }
+            const currentMatch = currentMatches[index];
+            if (!currentMatch || currentMatch.id !== match.route.id) return true;
+            if (currentMatch.pathname !== match.pathname) return true;
+            if (currentMatch.pathname.endsWith('*') && currentMatch.params['*'] !== match.params['*']) return true;
+            return false;
+        }).map((match)=>getDataHref(match.route, pathname, basename)), [
+        matches,
+        pathname,
+        routeManifest
+    ]);
+    return /*#__PURE__*/ jsx(Fragment, {
+        children: dataHrefs
+    });
+};
+const createPrefetchLink = (Link)=>/*#__PURE__*/ react.forwardRef(({ to, prefetch = 'none', ...props }, forwardedRef)=>{
+        const isAbsolute = 'string' == typeof to && ABSOLUTE_URL_REGEX.test(to);
+        const [shouldPrefetch, prefetchHandlers] = usePrefetchBehavior(prefetch, props);
+        const resolvedPath = useResolvedPath(to);
+        return /*#__PURE__*/ jsxs(Fragment, {
+            children: [
+                /*#__PURE__*/ jsx(Link, {
+                    ref: forwardedRef,
+                    to: to,
+                    ...props,
+                    ...prefetchHandlers
+                }),
+                shouldPrefetch && __webpack_require__.e && !isAbsolute ? /*#__PURE__*/ jsx(PrefetchPageLinks, {
+                    path: resolvedPath
+                }) : null
+            ]
+        });
+    });
+const PrefetchLink_Link = createPrefetchLink(router_Link);
+PrefetchLink_Link.displayName = 'Link';
+const PrefetchLink_NavLink = createPrefetchLink(NavLink);
+PrefetchLink_NavLink.displayName = 'NavLink';
+export { PrefetchLink_Link as Link, PrefetchLink_NavLink as NavLink };

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

@@ -1,19 +1,10 @@
 import { ROUTER_DATA_JSON_ID } from "../../core/constants";
-const setupFnStr = `function s(r,e){_ROUTER_DATA.r=_ROUTER_DATA.r||{},_ROUTER_DATA.r[r]=_ROUTER_DATA.r[r]||{};return new Promise((function(A,R){_ROUTER_DATA.r[r][e]={resolve:A,reject:R}}))};`;
-const resolveFnStr = `function r(e,r,o,A){A?_ROUTER_DATA.r[e][r].reject(A):_ROUTER_DATA.r[e][r].resolve(o)};`;
-const preResolvedFnStr = `function p(e,r){return void 0!==r?Promise.reject(new Error(r.message)):Promise.resolve(e)};`;
-const mergeLoaderDataStr = `function mergeLoaderData(e,n){var r=n.reduce((function(e,{key:n,routerDataFnName:r,routerDataFnArgs:a}){var t=a.map((e=>{if("undefined"!==e&&null!==e)return JSON.parse(e)}));return console.info("args",t),{...e,[n]:_ROUTER_DATA[r](...t)}}),{});Object.assign(_ROUTER_DATA.loaderData[e],r)}`;
+const setupFnStr = "function s(r,e){_ROUTER_DATA.r=_ROUTER_DATA.r||{},_ROUTER_DATA.r[r]=_ROUTER_DATA.r[r]||{};return new Promise((function(A,R){_ROUTER_DATA.r[r][e]={resolve:A,reject:R}}))};";
+const resolveFnStr = "function r(e,r,o,A){A?_ROUTER_DATA.r[e][r].reject(A):_ROUTER_DATA.r[e][r].resolve(o)};";
+const preResolvedFnStr = "function p(e,r){return void 0!==r?Promise.reject(new Error(r.message)):Promise.resolve(e)};";
+const mergeLoaderDataStr = 'function mergeLoaderData(e,n){var r=n.reduce((function(e,{key:n,routerDataFnName:r,routerDataFnArgs:a}){var t=a.map((e=>{if("undefined"!==e&&null!==e)return JSON.parse(e)}));return console.info("args",t),{...e,[n]:_ROUTER_DATA[r](...t)}}),{});Object.assign(_ROUTER_DATA.loaderData[e],r)}';
 const initRouterDataAttrs = `_ROUTER_DATA.s = ${setupFnStr}_ROUTER_DATA.r = ${resolveFnStr}_ROUTER_DATA.p = ${preResolvedFnStr}${mergeLoaderDataStr}`;
 const modernInline = `function runWindowFn(){window[document.currentScript.getAttribute("data-fn-name")].apply(window,JSON.parse(document.currentScript.getAttribute("data-fn-args")))}function runRouterDataFn(){_ROUTER_DATA[document.currentScript.getAttribute("data-fn-name")].apply(_ROUTER_DATA,JSON.parse(document.currentScript.getAttribute("data-fn-args")))}function initRouterData(e){var r=document.getElementById(e);if(r)try{_ROUTER_DATA=JSON.parse(r.textContent)}catch(r){console.error("parse ".concat(e," error"),t),_ROUTER_DATA={}}};initRouterData('${ROUTER_DATA_JSON_ID}');${initRouterDataAttrs}`;
-const runRouterDataFnStr = `runRouterDataFn();`;
-const runWindowFnStr = `runWindowFn();`;
-export {
-  initRouterDataAttrs,
-  mergeLoaderDataStr,
-  modernInline,
-  preResolvedFnStr,
-  resolveFnStr,
-  runRouterDataFnStr,
-  runWindowFnStr,
-  setupFnStr
-};
+const runRouterDataFnStr = "runRouterDataFn();";
+const runWindowFnStr = "runWindowFn();";
+export { initRouterDataAttrs, mergeLoaderDataStr, modernInline, preResolvedFnStr, resolveFnStr, runRouterDataFnStr, runWindowFnStr, setupFnStr };

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

@@ -0,0 +1,4 @@
+import { createSyncHook } from "@modern-js/plugin";
+const modifyRoutes = createSyncHook();
+const onBeforeCreateRoutes = createSyncHook();
+export { modifyRoutes, onBeforeCreateRoutes };

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

@@ -0,0 +1,9 @@
+import { useRouteLoaderData } from "@modern-js/runtime-utils/router";
+import { Link, NavLink } from "./PrefetchLink";
+export * from "@modern-js/runtime-utils/router";
+export * from "./withRouter";
+const runtime_useRouteLoaderData = (routeId)=>{
+    const realRouteId = routeId.replace(/\[(.*?)\]/g, '($1)');
+    return useRouteLoaderData(realRouteId);
+};
+export { Link, NavLink, runtime_useRouteLoaderData as useRouteLoaderData };

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

@@ -0,0 +1,4 @@
+import { modifyRoutes, routerPlugin } from "./plugin";
+import { renderRoutes } from "./utils";
+const internal = routerPlugin;
+export { internal as default, modifyRoutes, renderRoutes, routerPlugin };

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

@@ -0,0 +1,181 @@
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { merge } from "@modern-js/runtime-utils/merge";
+import { RouterProvider, createBrowserRouter, createHashRouter, createRoutesFromElements, useHref, useLocation, useMatches } from "@modern-js/runtime-utils/router";
+import { normalizePathname } from "@modern-js/runtime-utils/url";
+import { InternalRuntimeContext, getGlobalIsRscClient, getGlobalLayoutApp, getGlobalRoutes } from "../../core/context";
+import { modifyRoutes, onBeforeCreateRoutes } from "./hooks";
+import { createClientRouterFromPayload } from "./rsc-router";
+import { createRouteObjectsFromConfig, deserializeErrors, renderRoutes, urlJoin } from "./utils";
+import * as __rspack_external_react from "react";
+let finalRouteConfig = {
+    routes: []
+};
+let beforeCreateRouter = true;
+function plugin_modifyRoutes(modifyFunction) {
+    if (beforeCreateRouter) {
+        const { routes: originRoutes } = finalRouteConfig;
+        const newRoutes = modifyFunction(originRoutes);
+        finalRouteConfig.routes = newRoutes;
+    } else console.error('It is not allowed to modify routes config after create router.');
+}
+const routerPlugin = (userConfig = {})=>({
+        name: '@modern-js/plugin-router',
+        registryHooks: {
+            modifyRoutes: modifyRoutes,
+            onBeforeCreateRoutes: onBeforeCreateRoutes
+        },
+        setup: (api)=>{
+            const routesContainer = {
+                current: []
+            };
+            api.onBeforeRender((context)=>{
+                if (window._SSR_DATA && userConfig.unstable_reloadOnURLMismatch) {
+                    const { ssrContext } = context;
+                    const currentPathname = normalizePathname(window.location.pathname);
+                    const initialPathname = ssrContext?.request?.pathname && normalizePathname(ssrContext.request.pathname);
+                    if (initialPathname && initialPathname !== currentPathname) {
+                        const errorMsg = `The initial URL ${initialPathname} and the URL ${currentPathname} to be hydrated do not match, reload.`;
+                        console.error(errorMsg);
+                        window.location.reload();
+                    }
+                }
+                context.router = {
+                    useMatches: useMatches,
+                    useLocation: useLocation,
+                    useHref: useHref
+                };
+                Object.defineProperty(context, 'routes', {
+                    get () {
+                        return routesContainer.current;
+                    },
+                    enumerable: true
+                });
+            });
+            api.wrapRoot((App)=>{
+                const mergedConfig = merge(api.getRuntimeConfig().router || {}, userConfig);
+                const { serverBase = [], supportHtml5History = true, basename = '', routesConfig, createRoutes } = mergedConfig;
+                finalRouteConfig = {
+                    routes: getGlobalRoutes(),
+                    globalApp: getGlobalLayoutApp(),
+                    ...routesConfig
+                };
+                if (!finalRouteConfig.routes && !createRoutes) return App;
+                const selectBasePath = (pathname)=>{
+                    const match = serverBase.find((baseUrl)=>isSegmentPrefix(pathname, baseUrl));
+                    return match || '/';
+                };
+                let cachedRouter = null;
+                const RouterWrapper = (props)=>{
+                    const routerResult = useRouterCreation({
+                        ...props,
+                        rscPayload: props?.rscPayload
+                    }, {
+                        api: api,
+                        createRoutes,
+                        supportHtml5History,
+                        selectBasePath,
+                        basename
+                    });
+                    const router = (0, __rspack_external_react.useMemo)(()=>{
+                        if (cachedRouter) return cachedRouter;
+                        cachedRouter = routerResult.router;
+                        return cachedRouter;
+                    }, []);
+                    const { routes } = routerResult;
+                    routesContainer.current = routes;
+                    beforeCreateRouter = false;
+                    const RouterContent = ()=>/*#__PURE__*/ jsxs(Fragment, {
+                            children: [
+                                /*#__PURE__*/ jsx(RouterProvider, {
+                                    router: router
+                                }),
+                                /*#__PURE__*/ jsx(EmptyComponent, {}),
+                                /*#__PURE__*/ jsx(EmptyComponent, {})
+                            ]
+                        });
+                    return App ? /*#__PURE__*/ jsx(App, {
+                        children: /*#__PURE__*/ jsx(RouterContent, {})
+                    }) : /*#__PURE__*/ jsx(RouterContent, {});
+                };
+                return RouterWrapper;
+            });
+        }
+    });
+const EmptyComponent = ()=>null;
+const safeUse = (promise)=>{
+    const useProp = 'use';
+    const useHook = __rspack_external_react && __rspack_external_react[useProp];
+    if ('function' == typeof useHook) return useHook(promise);
+    return null;
+};
+function normalizeBase(b) {
+    if (b.length > 1 && b.endsWith('/')) return b.slice(0, -1);
+    return b || '/';
+}
+function isSegmentPrefix(pathname, base) {
+    const b = normalizeBase(base);
+    const p = pathname || '/';
+    return p === b || p.startsWith(`${b}/`);
+}
+function useRouterCreation(props, options) {
+    const { api, createRoutes, supportHtml5History, selectBasePath, basename } = options;
+    const runtimeContext = (0, __rspack_external_react.useContext)(InternalRuntimeContext);
+    const baseUrl = selectBasePath(location.pathname).replace(/^\/*/, '/');
+    const _basename = '/' === baseUrl ? urlJoin(baseUrl, runtimeContext._internalRouterBaseName || basename || '') : baseUrl;
+    const { unstable_getBlockNavState: getBlockNavState } = runtimeContext;
+    const rscPayload = props?.rscPayload ? safeUse(props.rscPayload) : null;
+    let hydrationData = window._ROUTER_DATA || rscPayload;
+    return (0, __rspack_external_react.useMemo)(()=>{
+        if (hydrationData?.errors) hydrationData = {
+            ...hydrationData,
+            errors: deserializeErrors(hydrationData.errors)
+        };
+        const isRscClient = getGlobalIsRscClient();
+        let routes = null;
+        routes = isRscClient ? createRoutes ? createRoutes() : createRouteObjectsFromConfig({
+            routesConfig: finalRouteConfig
+        }) : createRoutes ? createRoutes() : createRoutesFromElements(renderRoutes({
+            routesConfig: finalRouteConfig,
+            props
+        }));
+        if (!routes) routes = [];
+        const hooks = api.getHooks();
+        if (rscPayload) try {
+            const router = createClientRouterFromPayload(rscPayload, routes, _basename);
+            return {
+                router,
+                routes: router.routes || []
+            };
+        } catch (e) {
+            console.error('Failed to create router from RSC payload:', e);
+        }
+        const modifiedRoutes = hooks.modifyRoutes.call(routes);
+        const router = supportHtml5History ? createBrowserRouter(modifiedRoutes, {
+            basename: _basename,
+            hydrationData
+        }) : createHashRouter(modifiedRoutes, {
+            basename: _basename,
+            hydrationData
+        });
+        const originSubscribe = router.subscribe;
+        router.subscribe = (listener)=>{
+            const wrappedListener = (...args)=>{
+                const blockRoute = getBlockNavState ? getBlockNavState() : false;
+                if (blockRoute) return;
+                return listener(...args);
+            };
+            return originSubscribe(wrappedListener);
+        };
+        return {
+            router,
+            routes: modifiedRoutes
+        };
+    }, [
+        finalRouteConfig,
+        props,
+        _basename,
+        hydrationData,
+        getBlockNavState
+    ]);
+}
+export { beforeCreateRouter, finalRouteConfig, plugin_modifyRoutes as modifyRoutes, routerPlugin };

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

@@ -0,0 +1,136 @@
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { merge } from "@modern-js/runtime-utils/merge";
+import { createRequestContext } from "@modern-js/runtime-utils/node";
+import { StaticRouterProvider, createRoutesFromElements, createStaticHandler, createStaticRouter } from "@modern-js/runtime-utils/router";
+import { time } from "@modern-js/runtime-utils/time";
+import { LOADER_REPORTER_NAME } from "@modern-js/utils/universal/constants";
+import { useContext } from "react";
+import { InternalRuntimeContext, getGlobalEnableRsc, getGlobalLayoutApp, getGlobalRoutes } from "../../core/context";
+import { setServerPayload } from "../../core/context/serverPayload/index.server.mjs";
+import DeferredDataScripts_node from "./DeferredDataScripts.node.mjs";
+import { modifyRoutes, onBeforeCreateRoutes } from "./hooks";
+import { RSCStaticRouter, createServerPayload, handleRSCRedirect, prepareRSCRoutes } from "./rsc-router";
+import { createRouteObjectsFromConfig, renderRoutes, urlJoin } from "./utils";
+function createRemixReuqest(request) {
+    const method = 'GET';
+    const { headers } = request;
+    const controller = new AbortController();
+    return new Request(request.url, {
+        method,
+        headers,
+        signal: controller.signal
+    });
+}
+const routerPlugin = (userConfig = {})=>({
+        name: '@modern-js/plugin-router',
+        registryHooks: {
+            modifyRoutes: modifyRoutes,
+            onBeforeCreateRoutes: onBeforeCreateRoutes
+        },
+        setup: (api)=>{
+            let finalRouteConfig = {};
+            api.onBeforeRender(async (context, interrupt)=>{
+                const pluginConfig = api.getRuntimeConfig();
+                const { basename = '', routesConfig, createRoutes } = merge(pluginConfig.router || {}, userConfig);
+                finalRouteConfig = {
+                    routes: getGlobalRoutes(),
+                    globalApp: getGlobalLayoutApp(),
+                    ...routesConfig
+                };
+                if (!finalRouteConfig.routes && !createRoutes) return;
+                const enableRsc = getGlobalEnableRsc();
+                if (enableRsc) await prepareRSCRoutes(finalRouteConfig.routes);
+                const { request, mode: ssrMode, nonce, loaderFailureMode = 'errorBoundary', baseUrl } = context.ssrContext;
+                const _basename = '/' === baseUrl ? urlJoin(baseUrl, basename) : baseUrl;
+                const requestContext = createRequestContext(context.ssrContext?.loaderContext);
+                const hooks = api.getHooks();
+                await hooks.onBeforeCreateRoutes.call(context);
+                let routes = [];
+                routes = enableRsc ? createRoutes ? createRoutes() : createRouteObjectsFromConfig({
+                    routesConfig: finalRouteConfig
+                }) : createRoutes ? createRoutes() : createRoutesFromElements(renderRoutes({
+                    routesConfig: finalRouteConfig,
+                    ssrMode,
+                    props: {
+                        nonce
+                    }
+                }));
+                routes = hooks.modifyRoutes.call(routes);
+                const { query } = createStaticHandler(routes, {
+                    basename: _basename
+                });
+                const remixRequest = createRemixReuqest(context.ssrContext.request.raw);
+                const end = time();
+                const routerContext = await query(remixRequest, {
+                    requestContext
+                });
+                const cost = end();
+                context.ssrContext?.onTiming?.(LOADER_REPORTER_NAME, cost);
+                const isRSCNavigation = 'true' === remixRequest.headers.get('x-rsc-tree');
+                if (routerContext instanceof Response) if (enableRsc && isRSCNavigation) return interrupt(handleRSCRedirect(routerContext.headers, _basename, routerContext.status));
+                else return interrupt(routerContext);
+                const errors = Object.values(routerContext.errors || {});
+                if (errors.length > 0 && 'clientRender' === loaderFailureMode) {
+                    routerContext.statusCode = 200;
+                    throw errors[0];
+                }
+                context.routerContext = routerContext;
+                let payload;
+                if (enableRsc) {
+                    if (isRSCNavigation) {
+                        for (const match of routerContext.matches)if (match.route.hasClientLoader) delete routerContext.loaderData[match.route.id];
+                    }
+                    payload = createServerPayload(routerContext, routes);
+                    setServerPayload(payload);
+                }
+                Object.defineProperty(context, 'routes', {
+                    get () {
+                        return routes;
+                    },
+                    enumerable: true
+                });
+            });
+            api.wrapRoot((App)=>{
+                if (!finalRouteConfig) return App;
+                const getRouteApp = ()=>{
+                    const enableRsc = getGlobalEnableRsc();
+                    return (props)=>{
+                        const context = useContext(InternalRuntimeContext);
+                        const { routerContext, ssrContext, routes } = context;
+                        const { nonce, mode, useJsonScript } = ssrContext;
+                        const { basename } = routerContext;
+                        const remixRouter = createStaticRouter(routes, routerContext);
+                        if (enableRsc) return App ? /*#__PURE__*/ jsx(App, {
+                            children: /*#__PURE__*/ jsx(RSCStaticRouter, {
+                                basename: basename
+                            })
+                        }) : /*#__PURE__*/ jsx(RSCStaticRouter, {
+                            basename: basename
+                        });
+                        {
+                            const routerWrapper = /*#__PURE__*/ jsxs(Fragment, {
+                                children: [
+                                    /*#__PURE__*/ jsx(StaticRouterProvider, {
+                                        router: remixRouter,
+                                        context: routerContext,
+                                        hydrate: false
+                                    }),
+                                    'stream' === mode && /*#__PURE__*/ jsx(DeferredDataScripts_node, {
+                                        nonce: nonce,
+                                        context: routerContext,
+                                        useJsonScript: useJsonScript
+                                    })
+                                ]
+                            });
+                            return App ? /*#__PURE__*/ jsx(App, {
+                                children: routerWrapper
+                            }) : routerWrapper;
+                        }
+                    };
+                };
+                return getRouteApp();
+            });
+        }
+    });
+const plugin_node_modifyRoutes = ()=>{};
+export { plugin_node_modifyRoutes as modifyRoutes, routerPlugin };

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

@@ -0,0 +1,15 @@
+import { ROUTE_MODULES } from "@modern-js/utils/universal/constants";
+const createShouldRevalidate = (routeId)=>(arg)=>{
+        const routeModule = window?.[ROUTE_MODULES]?.[routeId];
+        if (routeModule && 'function' == typeof routeModule.shouldRevalidate) return routeModule.shouldRevalidate(arg);
+        return arg.defaultShouldRevalidate;
+    };
+const handleRouteModule = (routeModule, routeId)=>{
+    if ("u" > typeof document) window[ROUTE_MODULES][routeId] = routeModule;
+    return routeModule;
+};
+const handleRouteModuleError = (error)=>{
+    console.error(error);
+    return null;
+};
+export { createShouldRevalidate, handleRouteModule, handleRouteModuleError };