@bleedingdev/modern-js-runtime 3.9.0-ultramodern.2 → 3.9.0-ultramodern.21

package/dist/esm-node/core/server/string/loadable.mjs

@@ -1,7 +1,5 @@
 import "node:module";
 import { ChunkExtractor } from "@loadable/server";
-import { createFederatedCssLinks } from "../federatedCss.mjs";
-import { getMatchedRouteChunks, orderHydrationScriptChunks } from "../scriptOrder.mjs";
 import { attributesToString, checkIsNode, hasStylesheetLink } from "../utils.mjs";
 import { fileURLToPath as __rspack_fileURLToPath } from "node:url";
 import { dirname as __rspack_dirname } from "node:path";
@@ -11,7 +9,7 @@ const extname = (uri)=>{
     return `.${uri?.split('.').pop()}` || '';
 };
 const generateChunks = (chunks, ext)=>chunks.filter((chunk)=>Boolean(chunk.url)).filter((chunk)=>extname(chunk.url).slice(1) === ext);
-const routeAssetToChunk = (asset)=>({
+const assetToChunk = (asset)=>({
         chunk: asset,
         filename: asset.replace(/^\//, ''),
         linkType: 'preload',
@@ -22,8 +20,8 @@ const routeAssetToChunk = (asset)=>({
     });
 const checkIsInline = (chunk, enableInline)=>{
     if ('production' !== process.env.NODE_ENV) return false;
-    if (enableInline instanceof RegExp) return enableInline.test(chunk.url);
-    return Boolean(enableInline);
+    else if (enableInline instanceof RegExp) return enableInline.test(chunk.url);
+    else return Boolean(enableInline);
 };
 const readAsset = async (chunk)=>{
     const fs = await import("fs/promises");
@@ -57,16 +55,32 @@ class LoadableCollector {
             ]));
         } catch (e) {}
         const collectedChunks = extractor ? extractor.getChunkAssets(extractor.chunks) : [];
-        const matchedRouteChunks = getMatchedRouteChunks(options.runtimeContext, options.routeManifest, routeAssetToChunk);
-        const orderedScriptChunks = orderHydrationScriptChunks({
-            asyncEntryChunks: asyncChunks,
-            collectedChunks,
-            matchedRouteChunks,
-            entryName
-        });
-        const chunks = [].concat(asyncChunks).concat(collectedChunks).concat(matchedRouteChunks);
-        const scriptChunks = generateChunks(orderedScriptChunks, 'js');
-        const styleChunks = generateChunks(chunks, 'css');
+        const groups = [
+            {
+                name: 'async-entry',
+                assets: asyncChunks
+            },
+            {
+                name: 'loadable',
+                assets: collectedChunks
+            }
+        ];
+        const nativeChunks = [
+            ...asyncChunks,
+            ...collectedChunks
+        ];
+        const prepare = (kind)=>options.lifecycle?.transformAssets(groups, {
+                kind,
+                source: 'loadable',
+                template: options.template,
+                createAsset: assetToChunk
+            }) ?? nativeChunks;
+        const scriptChunks = generateChunks([
+            ...prepare("script")
+        ], 'js');
+        const styleChunks = generateChunks([
+            ...prepare('style')
+        ], 'css');
         if (extractor) {
             this.emitLoadableScripts(extractor);
             await this.emitScriptAssets(scriptChunks);
@@ -100,12 +114,12 @@ class LoadableCollector {
         const scripts = await Promise.all(chunks.filter((chunk)=>!existedScript.includes(chunk.url) && !this.existsAssets?.includes(chunk.path)).map(async (chunk)=>{
             const script = `<script${attributes} src="${chunk.url}"></script>`;
             if (checkIsNode() && checkIsInline(chunk, inlineStyles)) return readAsset(chunk).then((content)=>`<script>${content}</script>`).catch((_)=>script);
-            return script;
+            else return script;
         }));
         chunkSet.jsChunk += scripts.filter((script)=>Boolean(script)).join('');
     }
     async emitStyleAssets(chunks) {
-        const { template, chunkSet, config, moduleFederationCssAssets } = this.options;
+        const { template, chunkSet, config } = this.options;
         const { inlineStyles } = config;
         const atrributes = attributesToString(this.generateAttributes());
         const emittedAssetUrls = new Set();
@@ -117,14 +131,11 @@ class LoadableCollector {
         const css = await Promise.all(emittedChunks.map(async (chunk)=>{
             const link = `<link${atrributes} href="${chunk.url}" rel="stylesheet" />`;
             if (checkIsNode() && checkIsInline(chunk, inlineStyles)) return readAsset(chunk).then((content)=>`<style>${content}</style>`).catch((_)=>link);
-            return link;
+            else return link;
         }));
         chunkSet.cssChunk += css.filter((css)=>Boolean(css)).join('');
-        chunkSet.cssChunk += createFederatedCssLinks(moduleFederationCssAssets, {
-            template,
-            attributes: this.generateAttributes(),
-            existingAssets: emittedChunks.map((chunk)=>chunk.url)
-        });
+        this.stylesheetInfo.emittedAssets = emittedChunks.map((chunk)=>chunk.url);
+        this.stylesheetInfo.attributes = this.generateAttributes();
     }
     generateAttributes(extraAtr = {}) {
         const { config } = this.options;
@@ -137,6 +148,10 @@ class LoadableCollector {
         };
     }
     constructor(options){
+        this.stylesheetInfo = {
+            emittedAssets: [],
+            attributes: {}
+        };
         this.options = options;
     }
 }

package/dist/esm-node/core/server/string/ssrData.mjs

@@ -1,6 +1,5 @@
 import "node:module";
 import { serializeJson } from "@modern-js/runtime-utils/node";
-import { getRouterHydrationScripts, getRouterServerSnapshot } from "../../../router/runtime/lifecycle.mjs";
 import { ROUTER_DATA_JSON_ID, SSR_DATA_JSON_ID } from "../../constants.mjs";
 import { attributesToString, serializeErrors } from "../utils.mjs";
 function _check_private_redeclaration(obj, privateCollection) {
@@ -89,20 +88,15 @@ function getSSRData() {
     };
 }
 function getRouterData() {
-    const { routerContext, runtimeContext } = _class_private_field_get(this, _options);
-    const snapshotRouterData = getRouterServerSnapshot(runtimeContext)?.routerData;
-    if (snapshotRouterData) return {
-        loaderData: snapshotRouterData.loaderData,
-        errors: serializeErrors(snapshotRouterData.errors || null)
-    };
-    return routerContext ? {
-        loaderData: routerContext.loaderData,
-        errors: serializeErrors(routerContext.errors)
+    const { routerContext, lifecycle } = _class_private_field_get(this, _options);
+    const data = lifecycle?.getRouterData() ?? routerContext;
+    return data ? {
+        loaderData: data.loaderData,
+        errors: serializeErrors(data.errors || null)
     } : void 0;
 }
 function getSSRDataScripts(ssrData, routerData) {
     const { nonce, useJsonScript = false } = _class_private_field_get(this, _options);
-    const hydrationScripts = getRouterHydrationScripts(_class_private_field_get(this, _options).runtimeContext);
     const serializeSSRData = serializeJson(ssrData);
     const attrsStr = attributesToString({
         nonce
@@ -112,7 +106,6 @@ function getSSRDataScripts(ssrData, routerData) {
         const serializedRouterData = serializeJson(routerData);
         ssrDataScripts += useJsonScript ? `\n<script type="application/json" id="${ROUTER_DATA_JSON_ID}">${serializedRouterData}</script>` : `\n<script${attrsStr}>window._ROUTER_DATA = ${serializedRouterData}</script>`;
     }
-    if (hydrationScripts.length) ssrDataScripts += `\n${hydrationScripts.join('\n')}`;
     return ssrDataScripts;
 }
 export { SSRDataCollector };

package/dist/esm-node/core/server/utils.mjs

@@ -1,8 +1,7 @@
 import "node:module";
-import { escapeHtmlAttribute, isSafeHtmlAttributeName } from "@modern-js/runtime-extensions";
 import { isRouteErrorResponse } from "../../router/runtime/routerHelper.mjs";
 function attributesToString(attributes) {
-    return Object.entries(attributes).reduce((str, [key, value])=>void 0 !== value && isSafeHtmlAttributeName(key) ? `${str} ${key}="${escapeHtmlAttribute(value)}"` : str, '');
+    return Object.entries(attributes).reduce((str, [key, value])=>void 0 !== value && /^[^\u0000-\u0020"'<>/=]+$/u.test(key) ? `${str} ${key}="${String(value).replaceAll('&', '&amp;').replaceAll('"', '&quot;').replaceAll('<', '&lt;').replaceAll('>', '&gt;')}"` : str, '');
 }
 function safeReplace(source, searchValue, replaceValue) {
     return source.replace(searchValue, ()=>replaceValue);

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

@@ -126,6 +126,7 @@ g.__MODERN_DOC_RENDERERS__[${JSON.stringify(_entryName)}] = render;
 
 export default { render: render };`;
 };
+const getDocumentTempEntry = (internalDirectory, compilerName, entryName)=>path.join(internalDirectory, CONSTANTS.DOCUMENT_OUTPUT_DIR, compilerName ?? '', `${CONSTANTS.TEMP_ENTRY_PREFIX}${entryName}.js`);
 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}`, {
@@ -136,8 +137,7 @@ const processChildCompilation = async (entryName, docPath, compilation, compiler
         }, []);
         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 tempEntry = getDocumentTempEntry(internalDirectory, compiler.name, entryName);
         const finalize = ()=>{
             try {
                 const EntryPlugin = compiler.rspack?.EntryPlugin;
@@ -204,6 +204,7 @@ const documentPlugin = ()=>({
                             const tasks = [];
                             for (const ep of entrypoints || []){
                                 const entryName = ep.entryName;
+                                if (!this.htmlEntryNames.has(entryName)) continue;
                                 const docPath = getDocumentByEntryName(entrypoints, entryName, appDirectory);
                                 if (docPath) {
                                     compilation.fileDependencies?.add?.(docPath);
@@ -220,14 +221,19 @@ const documentPlugin = ()=>({
                         }
                     });
                 }
-                constructor(){
+                constructor(htmlEntryNames){
+                    this.htmlEntryNames = htmlEntryNames;
                     this.name = 'ModernJsDocumentChildCompilerPlugin';
                 }
             }
             api.config(()=>({
                     tools: {
-                        bundlerChain: (chain)=>{
-                            chain.plugin('modernjs-document-child-compiler').use(ModernJsDocumentChildCompilerPlugin, []);
+                        bundlerChain: (chain, { environment })=>{
+                            const htmlEntryNames = new Set(Object.keys(environment.htmlPaths));
+                            if (0 === htmlEntryNames.size) return;
+                            chain.plugin('modernjs-document-child-compiler').use(ModernJsDocumentChildCompilerPlugin, [
+                                htmlEntryNames
+                            ]);
                         }
                     }
                 }));
@@ -348,4 +354,4 @@ const documentPlugin = ()=>({
     });
 const cli = documentPlugin;
 export default cli;
-export { documentPlugin, getDocumentByEntryName, processScriptPlaceholders };
+export { documentPlugin, getDocumentByEntryName, getDocumentTempEntry, processScriptPlaceholders };

package/dist/esm-node/exports/head.mjs

@@ -1,22 +1,15 @@
 import "node:module";
 "use client";
+import { RuntimeComponentResolverContext } from "@modern-js/runtime/context";
 import react from "react";
 import { Helmet, HelmetData, HelmetProvider } from "react-helmet-async";
-import { InternalRuntimeContext } from "../core/context/index.mjs";
-import { ensureHelmetContext } from "../core/context/helmetContext.mjs";
-import * as __rspack_external__modern_js_runtime_extensions_ce611631 from "@modern-js/runtime-extensions";
-const collectServerHelmet = (runtimeContext, props)=>{
-    const helmetContext = ensureHelmetContext(runtimeContext);
-    const createRecord = ()=>__rspack_external__modern_js_runtime_extensions_ce611631.createHelmetRecord(react, props);
-    const deriveState = (records)=>__rspack_external__modern_js_runtime_extensions_ce611631.deriveHelmetServerState(react, records);
-    const marker = __rspack_external__modern_js_runtime_extensions_ce611631.collectHeadState(runtimeContext, createRecord, deriveState, helmetContext);
-    if (void 0 !== marker) return marker;
-    helmetContext.helmet = __rspack_external__modern_js_runtime_extensions_ce611631.collectImmediateHelmetState(react, helmetContext, createRecord());
-};
 const head_Helmet = (props)=>{
-    const runtimeContext = react.useContext(InternalRuntimeContext);
-    if (null !== runtimeContext && false === runtimeContext.isBrowser) return __rspack_external__modern_js_runtime_extensions_ce611631.renderHeadMarker(react, collectServerHelmet(runtimeContext, props));
-    return react.createElement(Helmet, props);
+    const resolveComponent = react.useContext(RuntimeComponentResolverContext);
+    const Component = resolveComponent?.(Helmet, {
+        name: 'head.Helmet'
+    }) ?? Helmet;
+    if (Component === head_Helmet) throw new Error('A component resolver cannot resolve head.Helmet to itself.');
+    return react.createElement(Component, props);
 };
 const head = {
     Helmet: head_Helmet,

package/dist/esm-node/internal.mjs

@@ -1,2 +1,2 @@
 import "node:module";
-export { InternalRuntimeContext } from "./core/context/runtime.mjs";
+export { InternalRuntimeContext } from "@modern-js/runtime/context";

package/dist/esm-node/router/cli/code/nestedRoutes.mjs

@@ -43,8 +43,7 @@ const optimizeRoute = (routeTree)=>{
                 children: optimizedChildren
             }
         ];
-    }
-    {
+    } else {
         const newRoutes = children.map((child)=>{
             const routePath = routeTree.path ? `${routeTree.path}${child.path ? `/${child.path}` : ''}` : child.path || '';
             const newRoute = {

package/dist/esm-node/router/cli/code/templates.mjs

@@ -379,7 +379,7 @@ const runtimeGlobalContext = async ({ entryName, metaName, srcDirectory, nestedR
         enableRsc: true,
       });
     `;
-    return `${imports.join('\n')}
+    else return `${imports.join('\n')}
 
     import { routes } from '${routesImportPath}';
 

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

@@ -11,7 +11,7 @@ const walkDirectory = (dir)=>fs_0.readdirSync(dir).reduce((previous, filename)=>
             ...previous,
             ...walkDirectory(filePath)
         ];
-        return [
+        else return [
             ...previous,
             filePath
         ];
@@ -28,7 +28,7 @@ const isPageComponentFile = (filePath)=>{
 };
 const replaceWithAlias = (base, filePath, alias)=>{
     if (filePath.includes(base)) return normalizeToPosixPath(path.join(alias, path.relative(base, filePath)));
-    return filePath;
+    else return filePath;
 };
 const parseModule = async ({ source, filename })=>{
     let content = source;

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

@@ -52,7 +52,7 @@ const DeferredDataScripts = (props)=>{
                         serializeJson(key)
                     ]
                 };
-                {
+                else {
                     const trackedPromise = deferredData.data[key];
                     if (void 0 !== trackedPromise._error) {
                         const error = toDeferredErrorInfo(trackedPromise._error);
@@ -64,15 +64,16 @@ const DeferredDataScripts = (props)=>{
                                 serializeJson(error)
                             ]
                         };
+                    } else {
+                        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)
+                            ]
+                        };
                     }
-                    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 {

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

@@ -1,10 +1,9 @@
 import "node:module";
 "use client";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
-import { getNavigationWarmupCacheKey } from "@modern-js/runtime-extensions";
+import { InternalRuntimeContext } from "@modern-js/runtime/context";
 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";
 import { __webpack_require__ } from "../../rslib-runtime~0.mjs";
 const getWebpackChunkLoader = ()=>__webpack_chunk_load__;
 const getWebpackPublicPath = ()=>{
@@ -21,62 +20,6 @@ function composeEventHandlers(theirHandler, ourHandler) {
     };
 }
 const ABSOLUTE_URL_REGEX = /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i;
-const DEFAULT_PREFETCH_BEHAVIOR = 'render';
-const INTENT_DELAY = 100;
-const VIEWPORT_ROOT_MARGIN = '200px';
-const MAX_CONCURRENT_WARMUPS = 4;
-const WARMUP_TTL = 30000;
-const SLOW_EFFECTIVE_TYPES = new Set([
-    'slow-2g',
-    '2g'
-]);
-const warmupCache = new Map();
-const warmupQueue = [];
-let activeWarmups = 0;
-const getWarmupTimestamp = ()=>performance.now();
-const getConnection = ()=>{
-    const nav = globalThis.navigator;
-    return nav?.connection || nav?.mozConnection || nav?.webkitConnection;
-};
-const shouldWarmupOnCurrentNetwork = ()=>{
-    const connection = getConnection();
-    if (connection?.saveData) return false;
-    if ('string' == typeof connection?.effectiveType && SLOW_EFFECTIVE_TYPES.has(connection.effectiveType)) return false;
-    return true;
-};
-const pruneWarmupCache = (now = getWarmupTimestamp())=>{
-    for (const [key, timestamp] of warmupCache)if (now - timestamp > WARMUP_TTL) warmupCache.delete(key);
-};
-const runNextWarmup = ()=>{
-    while(activeWarmups < MAX_CONCURRENT_WARMUPS && warmupQueue.length > 0){
-        const task = warmupQueue.shift();
-        if (task.cancelled) continue;
-        activeWarmups += 1;
-        task.run().catch(()=>{
-            warmupCache.delete(task.key);
-        }).finally(()=>{
-            activeWarmups -= 1;
-            runNextWarmup();
-        });
-    }
-};
-const scheduleWarmup = (key, run)=>{
-    if (!shouldWarmupOnCurrentNetwork()) return ()=>{};
-    pruneWarmupCache();
-    if (warmupCache.has(key)) return ()=>{};
-    warmupCache.set(key, getWarmupTimestamp());
-    const task = {
-        key,
-        run,
-        cancelled: false
-    };
-    warmupQueue.push(task);
-    runNextWarmup();
-    return ()=>{
-        task.cancelled = true;
-        if (warmupQueue.includes(task)) warmupCache.delete(task.key);
-    };
-};
 const setRef = (ref, value)=>{
     if (!ref) return;
     if ('function' == typeof ref) return void ref(value);
@@ -84,70 +27,65 @@ const setRef = (ref, value)=>{
         ref.current = value;
     } catch  {}
 };
-const isDataWarmupEnabled = (route)=>{
-    const handle = route.handle;
-    return handle?.navigationWarmup?.data !== false;
-};
-function usePrefetchBehavior(prefetch, preload, theirElementProps) {
-    const [maybeWarmup, setMaybeWarmup] = react.useState(false);
-    const [shouldPrefetch, setShouldPrefetch] = react.useState(false);
-    const [shouldPreload, setShouldPreload] = react.useState(false);
-    const [viewportElement, setViewportElement] = react.useState(null);
+function usePrefetchBehavior(prefetch, preload, theirElementProps, policy) {
+    const [maybePrefetch, setMaybePrefetch] = react.useState(false);
+    const [state, setState] = react.useState({
+        code: false,
+        data: false
+    });
+    const [element, setElement] = react.useState(null);
+    const observerRef = react.useRef(void 0);
     const { onFocus, onBlur, onMouseEnter, onMouseLeave, onTouchStart } = theirElementProps;
     react.useEffect(()=>{
-        if ('render' === prefetch) setShouldPrefetch(true);
-        if ('render' === preload) setShouldPreload(true);
+        if (!policy) return void setState({
+            code: 'render' === prefetch,
+            data: 'render' === prefetch
+        });
+        const observer = policy.observe({
+            element,
+            prefetch,
+            preload,
+            notify: (next)=>setState((previous)=>previous.code === next.code && previous.data === next.data ? previous : next)
+        });
+        observerRef.current = observer;
+        return ()=>{
+            observerRef.current = void 0;
+            observer.dispose();
+        };
     }, [
+        policy,
         prefetch,
-        preload
+        preload,
+        element
+    ]);
+    react.useEffect(()=>{
+        if (policy || !maybePrefetch) return;
+        const timer = setTimeout(()=>setState({
+                code: true,
+                data: true
+            }), 100);
+        return ()=>clearTimeout(timer);
+    }, [
+        policy,
+        maybePrefetch
     ]);
     const setIntent = ()=>{
-        if ('intent' === prefetch || 'intent' === preload) setMaybeWarmup(true);
+        if (policy) observerRef.current?.onIntent();
+        else if ('intent' === prefetch) setMaybePrefetch(true);
     };
     const cancelIntent = ()=>{
-        if ('intent' === prefetch || 'intent' === preload) {
-            setMaybeWarmup(false);
-            setShouldPrefetch(false);
-            setShouldPreload(false);
+        if (policy) observerRef.current?.onCancel();
+        else if ('intent' === prefetch) {
+            setMaybePrefetch(false);
+            setState({
+                code: false,
+                data: false
+            });
         }
     };
-    react.useEffect(()=>{
-        if (maybeWarmup) {
-            const id = setTimeout(()=>{
-                if ('intent' === prefetch) setShouldPrefetch(true);
-                if ('intent' === preload) setShouldPreload(true);
-            }, INTENT_DELAY);
-            return ()=>{
-                clearTimeout(id);
-            };
-        }
-    }, [
-        maybeWarmup,
-        prefetch,
-        preload
-    ]);
-    react.useEffect(()=>{
-        if (!viewportElement || 'viewport' !== prefetch && 'viewport' !== preload || "u" < typeof IntersectionObserver) return;
-        const observer = new IntersectionObserver((entries)=>{
-            if (!entries.some((entry)=>entry.isIntersecting)) return;
-            if ('viewport' === prefetch) setShouldPrefetch(true);
-            if ('viewport' === preload) setShouldPreload(true);
-            observer.disconnect();
-        }, {
-            rootMargin: VIEWPORT_ROOT_MARGIN
-        });
-        observer.observe(viewportElement);
-        return ()=>{
-            observer.disconnect();
-        };
-    }, [
-        prefetch,
-        preload,
-        viewportElement
-    ]);
     return [
-        shouldPrefetch,
-        shouldPreload,
+        state.data,
+        state.code,
         {
             onFocus: composeEventHandlers(onFocus, setIntent),
             onBlur: composeEventHandlers(onBlur, cancelIntent),
@@ -155,7 +93,7 @@ function usePrefetchBehavior(prefetch, preload, theirElementProps) {
             onMouseLeave: composeEventHandlers(onMouseLeave, cancelIntent),
             onTouchStart: composeEventHandlers(onTouchStart, setIntent)
         },
-        setViewportElement
+        setElement
     ];
 }
 async function loadRouteModule(route, routeAssets, chunkLoader) {
@@ -196,7 +134,8 @@ const PrefetchPageLinks = ({ path, includeData })=>{
     const context = useContext(InternalRuntimeContext);
     const { routeManifest, routes } = context;
     const { routeAssets } = routeManifest || {};
-    const allowNetworkWarmup = shouldWarmupOnCurrentNetwork();
+    const policy = context.linkPrefetchPolicy;
+    const allowNetworkWarmup = policy?.canWarmup() ?? true;
     const matches = useMemo(()=>Array.isArray(routes) ? matchRoutes(routes, pathname) : [], [
         pathname,
         routes
@@ -216,7 +155,16 @@ const PrefetchPageLinks = ({ path, includeData })=>{
             const routeAsset = routeId ? routeAssets[routeId] : void 0;
             const chunkIds = routeAsset?.chunkIds;
             if (!routeId || !Array.isArray(chunkIds) || 0 === chunkIds.length) return ()=>{};
-            return scheduleWarmup(getNavigationWarmupCacheKey(context, chunkLoader, getWebpackPublicPath(), `route-module:${routeId}:${chunkIds.join(',')}`), ()=>loadRouteModule(match.route, routeAssets, chunkLoader));
+            const run = ()=>loadRouteModule(match.route, routeAssets, chunkLoader);
+            if (policy) return policy.schedule({
+                runtimeContext: context,
+                chunkLoader,
+                publicPath: getWebpackPublicPath(),
+                key: `route-module:${routeId}:${chunkIds.join(',')}`,
+                run
+            });
+            run().catch(()=>{});
+            return ()=>{};
         });
         return ()=>{
             cancellations.forEach((cancel)=>cancel());
@@ -225,6 +173,7 @@ const PrefetchPageLinks = ({ path, includeData })=>{
         allowNetworkWarmup,
         chunkLoader,
         context,
+        policy,
         routeAssetGeneration
     ]);
     if (!allowNetworkWarmup || !includeData || !window._SSR_DATA) return null;
@@ -236,10 +185,11 @@ const PrefetchPageLinks = ({ path, includeData })=>{
 };
 const PrefetchDataLinks = ({ matches, path, routeManifest })=>{
     const { pathname, search, hash } = path;
+    const policy = useContext(InternalRuntimeContext).linkPrefetchPolicy;
     const currentMatches = useMatches();
     const basename = useHref('/');
     const dataHrefs = useMemo(()=>matches?.filter((match, index)=>{
-            if (!isDataWarmupEnabled(match.route) || !match.route.loader || 'function' != typeof match.route.loader || 0 === match.route.loader.length) return false;
+            if (policy?.allowData(match.route) === false || !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);
@@ -266,16 +216,10 @@ const PrefetchDataLinks = ({ matches, path, routeManifest })=>{
         children: dataHrefs
     });
 };
-const normalizePreloadBehavior = (preload, prefetch)=>{
-    if (false === preload || 'none' === preload) return 'none';
-    if (void 0 !== preload) return preload;
-    if ('none' === prefetch) return 'none';
-    return prefetch;
-};
-const createPrefetchLink = (Link)=>/*#__PURE__*/ react.forwardRef(({ to, prefetch = DEFAULT_PREFETCH_BEHAVIOR, preload, ...props }, forwardedRef)=>{
+const createPrefetchLink = (Link)=>/*#__PURE__*/ react.forwardRef(({ to, prefetch, preload, ...props }, forwardedRef)=>{
         const isAbsolute = 'string' == typeof to && ABSOLUTE_URL_REGEX.test(to);
-        const resolvedPreload = normalizePreloadBehavior(preload, prefetch);
-        const [shouldPrefetch, shouldPreload, prefetchHandlers, setViewportElement] = usePrefetchBehavior(prefetch, resolvedPreload, props);
+        const policy = useContext(InternalRuntimeContext).linkPrefetchPolicy;
+        const [shouldPrefetch, shouldPreload, prefetchHandlers, setViewportElement] = usePrefetchBehavior(prefetch, preload, props, policy);
         const setAnchorRef = react.useCallback((element)=>{
             setViewportElement(element);
             setRef(forwardedRef, element);

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

@@ -7,4 +7,12 @@ const onBeforeCreateRouter = createRouterSyncHook();
 const onAfterCreateRouter = createRouterSyncHook();
 const onBeforeHydrateRouter = createRouterSyncHook();
 const onAfterHydrateRouter = createRouterSyncHook();
-export { modifyRoutes, onAfterCreateRouter, onAfterHydrateRouter, onBeforeCreateRouter, onBeforeCreateRoutes, onBeforeHydrateRouter };
+const routerProviderRegistryHooks = {
+    modifyRoutes: modifyRoutes,
+    onBeforeCreateRoutes: onBeforeCreateRoutes,
+    onBeforeCreateRouter: onBeforeCreateRouter,
+    onAfterCreateRouter: onAfterCreateRouter,
+    onBeforeHydrateRouter: onBeforeHydrateRouter,
+    onAfterHydrateRouter: onAfterHydrateRouter
+};
+export { modifyRoutes, onAfterCreateRouter, onAfterHydrateRouter, onBeforeCreateRouter, onBeforeCreateRoutes, onBeforeHydrateRouter, routerProviderRegistryHooks };

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

@@ -1,35 +1,4 @@
 import "node:module";
-import { merge } from "@modern-js/runtime-utils/merge";
-import { modifyRoutes, routerPlugin } from "./plugin.mjs";
-import { createRouterProviderRealm, registerRouterProvider, reportUnsupportedProviderRegistryHooks, resolveRouterProvider, routerProviderRegistryHooks } from "./provider.mjs";
-registerRouterProvider('react-router', routerPlugin, {
-    isDefault: true
-});
-const createRouterPlugin = (localProviders = [])=>{
-    const providerRealm = createRouterProviderRealm([
-        {
-            name: 'react-router',
-            factory: routerPlugin,
-            isDefault: true
-        },
-        ...localProviders
-    ]);
-    return (userConfig = {})=>({
-            name: '@modern-js/plugin-router',
-            registryHooks: routerProviderRegistryHooks,
-            setup: (api)=>{
-                const mergedConfig = merge(api.getRuntimeConfig().router || {}, userConfig);
-                const pluginFactory = resolveRouterProvider(mergedConfig.framework, {
-                    realm: providerRealm
-                });
-                const providerPlugin = pluginFactory(userConfig);
-                reportUnsupportedProviderRegistryHooks(providerPlugin);
-                providerPlugin.setup?.(api);
-            }
-        });
-};
-const internal_routerPlugin = createRouterPlugin();
-const internal = internal_routerPlugin;
+export { routerProviderRegistryHooks } from "./hooks.mjs";
+export { modifyRoutes, routerPlugin as default, routerPlugin } from "./plugin.mjs";
 export { renderRoutes } from "./utils.mjs";
-export default internal;
-export { createRouterPlugin, createRouterProviderRealm, internal_routerPlugin as routerPlugin, modifyRoutes, registerRouterProvider, resolveRouterProvider };