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

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

@@ -0,0 +1,33 @@
+import "node:module";
+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-node/router/cli/entry.mjs

@@ -0,0 +1,41 @@
+import "node:module";
+import { fs } from "@modern-js/utils";
+import path from "path";
+import { hasApp } from "../../cli/entry.mjs";
+import { NESTED_ROUTES_DIR } from "./constants.mjs";
+const ROUTES_DIR_META_KEY = '__modernRoutesDir';
+const ROUTES_OWNER_META_KEY = '__modernRoutesOwner';
+const BUILT_IN_ROUTES_OWNER = '@modern-js/plugin-router';
+const getEntrypointRoutesDir = (entrypoint)=>{
+    if (entrypoint[ROUTES_DIR_META_KEY]) return entrypoint[ROUTES_DIR_META_KEY];
+    if (entrypoint.nestedRoutesEntry) return path.basename(entrypoint.nestedRoutesEntry);
+    return null;
+};
+const getEntrypointRoutesOwner = (entrypoint)=>entrypoint[ROUTES_OWNER_META_KEY] || null;
+const hasNestedRoutes = (dir, routesDir = NESTED_ROUTES_DIR)=>fs.existsSync(path.join(dir, routesDir));
+const isRouteEntry = (dir, routesDir = NESTED_ROUTES_DIR)=>{
+    if (hasNestedRoutes(dir, routesDir)) return path.join(dir, routesDir);
+    return false;
+};
+const modifyEntrypoints = (entrypoints, routesDir = NESTED_ROUTES_DIR, routesOwner)=>entrypoints.map((entrypoint)=>{
+        const entrypointWithMeta = entrypoint;
+        if (!entrypoint.isAutoMount) return entrypointWithMeta;
+        if (entrypoint?.isCustomSourceEntry) {
+            if (entrypoint.fileSystemRoutes) {
+                entrypointWithMeta.nestedRoutesEntry = entrypoint.absoluteEntryDir || entrypoint.entry;
+                entrypointWithMeta[ROUTES_DIR_META_KEY] = routesDir;
+                if (routesOwner) entrypointWithMeta[ROUTES_OWNER_META_KEY] = routesOwner;
+            }
+            return entrypointWithMeta;
+        }
+        const isHasApp = hasApp(entrypoint.absoluteEntryDir);
+        if (isHasApp) return entrypointWithMeta;
+        const isHasNestedRoutes = hasNestedRoutes(entrypoint.absoluteEntryDir, routesDir);
+        if (isHasNestedRoutes) {
+            entrypointWithMeta.nestedRoutesEntry = path.join(entrypoint.absoluteEntryDir, routesDir);
+            entrypointWithMeta[ROUTES_DIR_META_KEY] = routesDir;
+            if (routesOwner) entrypointWithMeta[ROUTES_OWNER_META_KEY] = routesOwner;
+        }
+        return entrypointWithMeta;
+    });
+export { BUILT_IN_ROUTES_OWNER, ROUTES_DIR_META_KEY, ROUTES_OWNER_META_KEY, getEntrypointRoutesDir, getEntrypointRoutesOwner, hasNestedRoutes, isRouteEntry, modifyEntrypoints };

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

@@ -0,0 +1,82 @@
+import "node:module";
+import { getMeta } from "@modern-js/utils";
+import { cloneDeep } from "@modern-js/utils/lodash";
+import path from "path";
+import { isPageComponentFile } from "./code/utils.mjs";
+import { modifyEntrypoints } from "./entry.mjs";
+import * as __rspack_external__code_templates_mjs_5e908598 from "./code/templates.mjs";
+const DEFAULT_ENTRYPOINTS_KEY = '__default_router_entries__';
+const originEntrypointsByKey = new Map();
+async function handleModifyEntrypoints(entrypoints, routesDir, options = {}) {
+    return modifyEntrypoints(entrypoints, routesDir, options.routesOwner);
+}
+async function handleGeneratorEntryCode(api, entrypoints, options = {}) {
+    const normalizedOptions = 'string' == typeof options ? {
+        entrypointsKey: options
+    } : options;
+    const entrypointsKey = normalizedOptions.entrypointsKey || DEFAULT_ENTRYPOINTS_KEY;
+    const appContext = api.getAppContext();
+    const { internalDirectory } = appContext;
+    const resolvedConfig = api.getNormalizedConfig();
+    const { generatorRegisterCode, generateCode, generatorServerRegisterCode } = await import("./code/index.mjs");
+    originEntrypointsByKey.set(entrypointsKey, cloneDeep(entrypoints));
+    const enableRsc = resolvedConfig?.server?.rsc;
+    const routesByEntry = await generateCode(appContext, resolvedConfig, entrypoints, api, normalizedOptions.generateCodeOptions);
+    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 __rspack_external__code_templates_mjs_5e908598.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 __rspack_external__code_templates_mjs_5e908598.runtimeGlobalContext({
+                entryName: entrypoint.entryName,
+                metaName: appContext.metaName,
+                srcDirectory: appContext.srcDirectory,
+                nestedRoutesEntry: entrypoint.nestedRoutesEntry,
+                internalSrcAlias: appContext.internalSrcAlias,
+                globalApp: entrypoint.fileSystemRoutes?.globalApp,
+                rscType: 'server',
+                basename
+            }));
+        }
+    }));
+    return routesByEntry;
+}
+async function handleFileChange(api, e, options = {}) {
+    const { includeEntry, regenerate, entrypointsKey = DEFAULT_ENTRYPOINTS_KEY } = options;
+    const appContext = api.getAppContext();
+    const { appDirectory, entrypoints } = appContext;
+    const activeEntrypoints = includeEntry ? entrypoints.filter(includeEntry) : entrypoints;
+    const { filename, eventType } = e;
+    const nestedRouteEntries = activeEntrypoints.map((point)=>point.nestedRoutesEntry).filter(Boolean);
+    const pagesDir = activeEntrypoints.map((point)=>point.entry).filter((entry)=>entry && !path.extname(entry)).concat(nestedRouteEntries);
+    if (0 === pagesDir.length) return;
+    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 cachedEntrypoints = originEntrypointsByKey.get(entrypointsKey) || activeEntrypoints;
+        const entrypoints = cloneDeep(cachedEntrypoints).filter((entrypoint)=>includeEntry ? includeEntry(entrypoint) : true);
+        if (regenerate) return void await regenerate({
+            api,
+            appContext,
+            resolvedConfig,
+            entrypoints
+        });
+        const { generateCode } = await import("./code/index.mjs");
+        await generateCode(appContext, resolvedConfig, entrypoints, api);
+    }
+}
+export { handleFileChange, handleGeneratorEntryCode, handleModifyEntrypoints };

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

@@ -0,0 +1,131 @@
+import "node:module";
+import node_path from "node:path";
+import { NESTED_ROUTE_SPEC_FILE, filterRoutesForServer, findExists, fs } from "@modern-js/utils";
+import { NESTED_ROUTES_DIR } from "./constants.mjs";
+import { BUILT_IN_ROUTES_OWNER, getEntrypointRoutesDir, getEntrypointRoutesOwner, isRouteEntry } from "./entry.mjs";
+import { handleFileChange, handleGeneratorEntryCode, handleModifyEntrypoints } from "./handler.mjs";
+import { fileURLToPath as __rspack_fileURLToPath } from "node:url";
+import { dirname as __rspack_dirname } from "node:path";
+var cli_dirname = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
+const JS_OR_TS_EXTS = [
+    '.js',
+    '.jsx',
+    '.ts',
+    '.tsx',
+    '.mjs',
+    '.mts',
+    '.cjs',
+    '.cts'
+];
+function hasRouterConfigInRuntimeFile(runtimeConfigBase) {
+    const runtimeConfigFile = findExists(JS_OR_TS_EXTS.map((ext)=>`${runtimeConfigBase}${ext}`));
+    if (!runtimeConfigFile) return false;
+    try {
+        const content = fs.readFileSync(runtimeConfigFile, 'utf-8');
+        return /router\s*:/.test(content);
+    } catch  {
+        return false;
+    }
+}
+function isBuiltInRouteEntrypoint(entrypoint) {
+    const entrypointRoutesOwner = getEntrypointRoutesOwner(entrypoint);
+    if (entrypointRoutesOwner) return entrypointRoutesOwner === BUILT_IN_ROUTES_OWNER;
+    if (entrypoint.pageRoutesEntry) return true;
+    const entrypointRoutesDir = getEntrypointRoutesDir(entrypoint);
+    if (entrypointRoutesDir) return entrypointRoutesDir === NESTED_ROUTES_DIR;
+    return Boolean(entrypoint.entry && isRouteEntry(entrypoint.entry));
+}
+function isPluginOwnedRouteEntrypoint(entrypoint) {
+    const entrypointRoutesOwner = getEntrypointRoutesOwner(entrypoint);
+    if (entrypointRoutesOwner) return entrypointRoutesOwner !== BUILT_IN_ROUTES_OWNER;
+    const entrypointRoutesDir = getEntrypointRoutesDir(entrypoint);
+    return Boolean(entrypointRoutesDir && entrypointRoutesDir !== NESTED_ROUTES_DIR);
+}
+const routerPlugin = ()=>({
+        name: '@modern-js/plugin-router',
+        required: [
+            '@modern-js/runtime'
+        ],
+        setup: (api)=>{
+            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.mjs");
+                    await generateRoutesInspectReport(api);
+                });
+            });
+            api._internalRuntimePlugins(({ entrypoint, plugins })=>{
+                const { serverRoutes, metaName, srcDirectory, runtimeConfigFile } = api.getAppContext();
+                const normalizedConfig = api.getNormalizedConfig();
+                const hasUserRouterConfig = normalizedConfig.router && Object.keys(normalizedConfig.router).length > 0;
+                const hasRuntimeRouterConfig = hasRouterConfigInRuntimeFile(node_path.join(srcDirectory, runtimeConfigFile));
+                const serverBase = serverRoutes.filter((route)=>route.entryName === entrypoint.entryName).map((route)=>route.urlPath).sort((a, b)=>a.length - b.length > 0 ? -1 : 1);
+                const shouldInstallBuiltInRouter = isBuiltInRouteEntrypoint(entrypoint) || !isPluginOwnedRouteEntrypoint(entrypoint) && (hasUserRouterConfig || hasRuntimeRouterConfig);
+                if (shouldInstallBuiltInRouter) 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(cli_dirname, '../runtime').replace('cjs', 'esm')
+                        ]
+                    }
+                }));
+            api.modifyEntrypoints(async ({ entrypoints })=>{
+                const newEntryPoints = await handleModifyEntrypoints(entrypoints);
+                return {
+                    entrypoints: newEntryPoints
+                };
+            });
+            api.generateEntryCode(async ({ entrypoints })=>{
+                const builtInEntrypoints = entrypoints.filter(isBuiltInRouteEntrypoint);
+                if (builtInEntrypoints.length > 0) await handleGeneratorEntryCode(api, builtInEntrypoints);
+            });
+            api.onFileChanged(async (e)=>{
+                await handleFileChange(api, e, {
+                    includeEntry: isBuiltInRouteEntrypoint
+                });
+            });
+            api.modifyFileSystemRoutes(({ entrypoint, routes })=>{
+                if (isBuiltInRouteEntrypoint(entrypoint)) nestedRoutesForServer[entrypoint.entryName] = filterRoutesForServer(routes);
+                return {
+                    entrypoint,
+                    routes
+                };
+            });
+            api.onBeforeGenerateRoutes(async ({ entrypoint, code })=>{
+                if (isBuiltInRouteEntrypoint(entrypoint)) {
+                    const { distDirectory } = api.getAppContext();
+                    const nestedRoutesSpecPath = node_path.resolve(distDirectory, NESTED_ROUTE_SPEC_FILE);
+                    const existingNestedRoutes = await fs.pathExists(nestedRoutesSpecPath) ? await fs.readJSON(nestedRoutesSpecPath) : {};
+                    await fs.outputJSON(nestedRoutesSpecPath, {
+                        ...existingNestedRoutes,
+                        ...nestedRoutesForServer
+                    });
+                }
+                return {
+                    entrypoint,
+                    code
+                };
+            });
+        }
+    });
+const cli = routerPlugin;
+export default cli;
+export { BUILT_IN_ROUTES_OWNER, getEntrypointRoutesDir, getEntrypointRoutesOwner, handleFileChange, handleGeneratorEntryCode, handleModifyEntrypoints, isRouteEntry, routerPlugin };

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

@@ -0,0 +1,2 @@
+import "node:module";
+export * from "./runtime/index.mjs";

package/dist/esm-node/router/internal.mjs

@@ -0,0 +1,3 @@
+import "node:module";
+export * from "./runtime/internal.mjs";
+export { routerPlugin as default } from "./runtime/internal.mjs";

package/dist/esm-node/router/runtime/CSSLinks.mjs

@@ -0,0 +1,13 @@
+import "node:module";
+import { Fragment, jsx } from "react/jsx-runtime";
+import "react";
+function CSSLinks({ cssFiles }) {
+    if (0 === cssFiles.length) return null;
+    return /*#__PURE__*/ jsx(Fragment, {
+        children: cssFiles.map((css)=>/*#__PURE__*/ jsx("link", {
+                href: css,
+                rel: "stylesheet"
+            }, css))
+    });
+}
+export { CSSLinks };

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

@@ -0,0 +1,14 @@
+import "node:module";
+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-node/router/runtime/DeferredDataScripts.mjs

@@ -0,0 +1,3 @@
+import "node:module";
+const DeferredDataScripts = ()=>null;
+export default DeferredDataScripts;

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

@@ -0,0 +1,121 @@
+import "node:module";
+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.mjs";
+import { modernInline, runWindowFnStr } from "./constants.mjs";
+import { serializeErrors } from "./utils.mjs";
+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 default DeferredDataScripts_node;

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

@@ -0,0 +1,155 @@
+import "node:module";
+"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/index.mjs";
+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)=>__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_chunk_load__ && !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.mjs

@@ -0,0 +1,11 @@
+import "node:module";
+import { ROUTER_DATA_JSON_ID } from "../../core/constants.mjs";
+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{...e,[n]:_ROUTER_DATA[r](...t)}}),{});_ROUTER_DATA.loaderData=_ROUTER_DATA.loaderData||{},_ROUTER_DATA.loaderData[e]=_ROUTER_DATA.loaderData[e]||{},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 };

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

@@ -0,0 +1,9 @@
+import "node:module";
+import { createSyncHook } from "@modern-js/plugin";
+const modifyRoutes = createSyncHook();
+const onBeforeCreateRoutes = createSyncHook();
+const onBeforeCreateRouter = createSyncHook();
+const onAfterCreateRouter = createSyncHook();
+const onBeforeHydrateRouter = createSyncHook();
+const onAfterHydrateRouter = createSyncHook();
+export { modifyRoutes, onAfterCreateRouter, onAfterHydrateRouter, onBeforeCreateRouter, onBeforeCreateRoutes, onBeforeHydrateRouter };

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

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