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

package/dist/cjs/core/server/string/loadable.js

@@ -31,15 +31,13 @@ __webpack_require__.d(__webpack_exports__, {
     LoadableCollector: ()=>LoadableCollector
 });
 const server_namespaceObject = require("@loadable/server");
-const external_federatedCss_js_namespaceObject = require("../federatedCss.js");
-const external_scriptOrder_js_namespaceObject = require("../scriptOrder.js");
 const external_utils_js_namespaceObject = require("../utils.js");
 const extname = (uri)=>{
     if ('string' != typeof uri || !uri.includes('.')) return '';
     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',
@@ -50,8 +48,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");
@@ -85,16 +83,32 @@ class LoadableCollector {
             ]));
         } catch (e) {}
         const collectedChunks = extractor ? extractor.getChunkAssets(extractor.chunks) : [];
-        const matchedRouteChunks = (0, external_scriptOrder_js_namespaceObject.getMatchedRouteChunks)(options.runtimeContext, options.routeManifest, routeAssetToChunk);
-        const orderedScriptChunks = (0, external_scriptOrder_js_namespaceObject.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);
@@ -128,12 +142,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 ((0, external_utils_js_namespaceObject.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 = (0, external_utils_js_namespaceObject.attributesToString)(this.generateAttributes());
         const emittedAssetUrls = new Set();
@@ -145,14 +159,11 @@ class LoadableCollector {
         const css = await Promise.all(emittedChunks.map(async (chunk)=>{
             const link = `<link${atrributes} href="${chunk.url}" rel="stylesheet" />`;
             if ((0, external_utils_js_namespaceObject.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 += (0, external_federatedCss_js_namespaceObject.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;
@@ -165,6 +176,10 @@ class LoadableCollector {
         };
     }
     constructor(options){
+        this.stylesheetInfo = {
+            emittedAssets: [],
+            attributes: {}
+        };
         this.options = options;
     }
 }

package/dist/cjs/core/server/string/ssrData.js

@@ -31,7 +31,6 @@ __webpack_require__.d(__webpack_exports__, {
     SSRDataCollector: ()=>SSRDataCollector
 });
 const node_namespaceObject = require("@modern-js/runtime-utils/node");
-const lifecycle_js_namespaceObject = require("../../../router/runtime/lifecycle.js");
 const external_constants_js_namespaceObject = require("../../constants.js");
 const external_utils_js_namespaceObject = require("../utils.js");
 function _check_private_redeclaration(obj, privateCollection) {
@@ -120,20 +119,15 @@ function getSSRData() {
     };
 }
 function getRouterData() {
-    const { routerContext, runtimeContext } = _class_private_field_get(this, _options);
-    const snapshotRouterData = (0, lifecycle_js_namespaceObject.getRouterServerSnapshot)(runtimeContext)?.routerData;
-    if (snapshotRouterData) return {
-        loaderData: snapshotRouterData.loaderData,
-        errors: (0, external_utils_js_namespaceObject.serializeErrors)(snapshotRouterData.errors || null)
-    };
-    return routerContext ? {
-        loaderData: routerContext.loaderData,
-        errors: (0, external_utils_js_namespaceObject.serializeErrors)(routerContext.errors)
+    const { routerContext, lifecycle } = _class_private_field_get(this, _options);
+    const data = lifecycle?.getRouterData() ?? routerContext;
+    return data ? {
+        loaderData: data.loaderData,
+        errors: (0, external_utils_js_namespaceObject.serializeErrors)(data.errors || null)
     } : void 0;
 }
 function getSSRDataScripts(ssrData, routerData) {
     const { nonce, useJsonScript = false } = _class_private_field_get(this, _options);
-    const hydrationScripts = (0, lifecycle_js_namespaceObject.getRouterHydrationScripts)(_class_private_field_get(this, _options).runtimeContext);
     const serializeSSRData = (0, node_namespaceObject.serializeJson)(ssrData);
     const attrsStr = (0, external_utils_js_namespaceObject.attributesToString)({
         nonce
@@ -143,7 +137,6 @@ function getSSRDataScripts(ssrData, routerData) {
         const serializedRouterData = (0, node_namespaceObject.serializeJson)(routerData);
         ssrDataScripts += useJsonScript ? `\n<script type="application/json" id="${external_constants_js_namespaceObject.ROUTER_DATA_JSON_ID}">${serializedRouterData}</script>` : `\n<script${attrsStr}>window._ROUTER_DATA = ${serializedRouterData}</script>`;
     }
-    if (hydrationScripts.length) ssrDataScripts += `\n${hydrationScripts.join('\n')}`;
     return ssrDataScripts;
 }
 exports.SSRDataCollector = __webpack_exports__.SSRDataCollector;

package/dist/cjs/core/server/utils.js

@@ -37,10 +37,9 @@ __webpack_require__.d(__webpack_exports__, {
     serializeErrors: ()=>serializeErrors,
     shouldRedactServerError: ()=>shouldRedactServerError
 });
-const runtime_extensions_namespaceObject = require("@modern-js/runtime-extensions");
 const routerHelper_js_namespaceObject = require("../../router/runtime/routerHelper.js");
 function attributesToString(attributes) {
-    return Object.entries(attributes).reduce((str, [key, value])=>void 0 !== value && (0, runtime_extensions_namespaceObject.isSafeHtmlAttributeName)(key) ? `${str} ${key}="${(0, runtime_extensions_namespaceObject.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/cjs/exports/head.js

@@ -41,24 +41,17 @@ __webpack_require__.d(__webpack_exports__, {
     Helmet: ()=>Helmet,
     default: ()=>exports_head
 });
-const runtime_extensions_namespaceObject = require("@modern-js/runtime-extensions");
+const context_namespaceObject = require("@modern-js/runtime/context");
 const external_react_namespaceObject = require("react");
 var external_react_default = /*#__PURE__*/ __webpack_require__.n(external_react_namespaceObject);
 const external_react_helmet_async_namespaceObject = require("react-helmet-async");
-const index_js_namespaceObject = require("../core/context/index.js");
-const helmetContext_js_namespaceObject = require("../core/context/helmetContext.js");
-const collectServerHelmet = (runtimeContext, props)=>{
-    const helmetContext = (0, helmetContext_js_namespaceObject.ensureHelmetContext)(runtimeContext);
-    const createRecord = ()=>runtime_extensions_namespaceObject.createHelmetRecord(external_react_default(), props);
-    const deriveState = (records)=>runtime_extensions_namespaceObject.deriveHelmetServerState(external_react_default(), records);
-    const marker = runtime_extensions_namespaceObject.collectHeadState(runtimeContext, createRecord, deriveState, helmetContext);
-    if (void 0 !== marker) return marker;
-    helmetContext.helmet = runtime_extensions_namespaceObject.collectImmediateHelmetState(external_react_default(), helmetContext, createRecord());
-};
 const Helmet = (props)=>{
-    const runtimeContext = external_react_default().useContext(index_js_namespaceObject.InternalRuntimeContext);
-    if (null !== runtimeContext && false === runtimeContext.isBrowser) return runtime_extensions_namespaceObject.renderHeadMarker(external_react_default(), collectServerHelmet(runtimeContext, props));
-    return external_react_default().createElement(external_react_helmet_async_namespaceObject.Helmet, props);
+    const resolveComponent = external_react_default().useContext(context_namespaceObject.RuntimeComponentResolverContext);
+    const Component = resolveComponent?.(external_react_helmet_async_namespaceObject.Helmet, {
+        name: 'head.Helmet'
+    }) ?? external_react_helmet_async_namespaceObject.Helmet;
+    if (Component === Helmet) throw new Error('A component resolver cannot resolve head.Helmet to itself.');
+    return external_react_default().createElement(Component, props);
 };
 const head = {
     Helmet,

package/dist/cjs/internal.js

@@ -28,9 +28,9 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    InternalRuntimeContext: ()=>runtime_js_namespaceObject.InternalRuntimeContext
+    InternalRuntimeContext: ()=>context_namespaceObject.InternalRuntimeContext
 });
-const runtime_js_namespaceObject = require("./core/context/runtime.js");
+const context_namespaceObject = require("@modern-js/runtime/context");
 exports.InternalRuntimeContext = __webpack_exports__.InternalRuntimeContext;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "InternalRuntimeContext"

package/dist/cjs/router/cli/code/nestedRoutes.js

@@ -76,8 +76,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/cjs/router/cli/code/templates.js

@@ -422,7 +422,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/cjs/router/cli/code/utils.js

@@ -61,7 +61,7 @@ const walkDirectory = (dir)=>external_fs_default().readdirSync(dir).reduce((prev
             ...previous,
             ...walkDirectory(filePath)
         ];
-        return [
+        else return [
             ...previous,
             filePath
         ];
@@ -78,7 +78,7 @@ const isPageComponentFile = (filePath)=>{
 };
 const replaceWithAlias = (base, filePath, alias)=>{
     if (filePath.includes(base)) return (0, utils_namespaceObject.normalizeToPosixPath)(external_path_default().join(alias, external_path_default().relative(base, filePath)));
-    return filePath;
+    else return filePath;
 };
 const parseModule = async ({ source, filename })=>{
     let content = source;

package/dist/cjs/router/runtime/DeferredDataScripts.node.js

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

package/dist/cjs/router/runtime/PrefetchLink.js

@@ -70,11 +70,10 @@ __webpack_require__.d(__webpack_exports__, {
     NavLink: ()=>NavLink
 });
 const jsx_runtime_namespaceObject = require("react/jsx-runtime");
-const runtime_extensions_namespaceObject = require("@modern-js/runtime-extensions");
+const context_namespaceObject = require("@modern-js/runtime/context");
 const router_namespaceObject = require("@modern-js/runtime-utils/router");
 const external_react_namespaceObject = require("react");
 var external_react_default = /*#__PURE__*/ __webpack_require__.n(external_react_namespaceObject);
-const index_js_namespaceObject = require("../../core/context/index.js");
 const getWebpackChunkLoader = ()=>__webpack_chunk_load__;
 const getWebpackPublicPath = ()=>{
     try {
@@ -90,62 +89,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);
@@ -153,70 +96,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] = external_react_default().useState(false);
-    const [shouldPrefetch, setShouldPrefetch] = external_react_default().useState(false);
-    const [shouldPreload, setShouldPreload] = external_react_default().useState(false);
-    const [viewportElement, setViewportElement] = external_react_default().useState(null);
+function usePrefetchBehavior(prefetch, preload, theirElementProps, policy) {
+    const [maybePrefetch, setMaybePrefetch] = external_react_default().useState(false);
+    const [state, setState] = external_react_default().useState({
+        code: false,
+        data: false
+    });
+    const [element, setElement] = external_react_default().useState(null);
+    const observerRef = external_react_default().useRef(void 0);
     const { onFocus, onBlur, onMouseEnter, onMouseLeave, onTouchStart } = theirElementProps;
     external_react_default().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
+    ]);
+    external_react_default().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
+            });
         }
     };
-    external_react_default().useEffect(()=>{
-        if (maybeWarmup) {
-            const id = setTimeout(()=>{
-                if ('intent' === prefetch) setShouldPrefetch(true);
-                if ('intent' === preload) setShouldPreload(true);
-            }, INTENT_DELAY);
-            return ()=>{
-                clearTimeout(id);
-            };
-        }
-    }, [
-        maybeWarmup,
-        prefetch,
-        preload
-    ]);
-    external_react_default().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),
@@ -224,7 +162,7 @@ function usePrefetchBehavior(prefetch, preload, theirElementProps) {
             onMouseLeave: composeEventHandlers(onMouseLeave, cancelIntent),
             onTouchStart: composeEventHandlers(onTouchStart, setIntent)
         },
-        setViewportElement
+        setElement
     ];
 }
 async function loadRouteModule(route, routeAssets, chunkLoader) {
@@ -262,10 +200,11 @@ const getDataHref = (route, pathname, basename)=>{
 };
 const PrefetchPageLinks = ({ path, includeData })=>{
     const { pathname } = path;
-    const context = (0, external_react_namespaceObject.useContext)(index_js_namespaceObject.InternalRuntimeContext);
+    const context = (0, external_react_namespaceObject.useContext)(context_namespaceObject.InternalRuntimeContext);
     const { routeManifest, routes } = context;
     const { routeAssets } = routeManifest || {};
-    const allowNetworkWarmup = shouldWarmupOnCurrentNetwork();
+    const policy = context.linkPrefetchPolicy;
+    const allowNetworkWarmup = policy?.canWarmup() ?? true;
     const matches = (0, external_react_namespaceObject.useMemo)(()=>Array.isArray(routes) ? (0, router_namespaceObject.matchRoutes)(routes, pathname) : [], [
         pathname,
         routes
@@ -285,7 +224,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((0, runtime_extensions_namespaceObject.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());
@@ -294,6 +242,7 @@ const PrefetchPageLinks = ({ path, includeData })=>{
         allowNetworkWarmup,
         chunkLoader,
         context,
+        policy,
         routeAssetGeneration
     ]);
     if (!allowNetworkWarmup || !includeData || !window._SSR_DATA) return null;
@@ -305,10 +254,11 @@ const PrefetchPageLinks = ({ path, includeData })=>{
 };
 const PrefetchDataLinks = ({ matches, path, routeManifest })=>{
     const { pathname, search, hash } = path;
+    const policy = (0, external_react_namespaceObject.useContext)(context_namespaceObject.InternalRuntimeContext).linkPrefetchPolicy;
     const currentMatches = (0, router_namespaceObject.useMatches)();
     const basename = (0, router_namespaceObject.useHref)('/');
     const dataHrefs = (0, external_react_namespaceObject.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);
@@ -335,16 +285,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__*/ (external_react_default()).forwardRef(({ to, prefetch = DEFAULT_PREFETCH_BEHAVIOR, preload, ...props }, forwardedRef)=>{
+const createPrefetchLink = (Link)=>/*#__PURE__*/ (external_react_default()).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 = (0, external_react_namespaceObject.useContext)(context_namespaceObject.InternalRuntimeContext).linkPrefetchPolicy;
+        const [shouldPrefetch, shouldPreload, prefetchHandlers, setViewportElement] = usePrefetchBehavior(prefetch, preload, props, policy);
         const setAnchorRef = external_react_default().useCallback((element)=>{
             setViewportElement(element);
             setRef(forwardedRef, element);

package/dist/cjs/router/runtime/hooks.js

@@ -33,7 +33,8 @@ __webpack_require__.d(__webpack_exports__, {
     onAfterHydrateRouter: ()=>onAfterHydrateRouter,
     onBeforeCreateRouter: ()=>onBeforeCreateRouter,
     onBeforeCreateRoutes: ()=>onBeforeCreateRoutes,
-    onBeforeHydrateRouter: ()=>onBeforeHydrateRouter
+    onBeforeHydrateRouter: ()=>onBeforeHydrateRouter,
+    routerProviderRegistryHooks: ()=>routerProviderRegistryHooks
 });
 const plugin_namespaceObject = require("@modern-js/plugin");
 const createRouterSyncHook = ()=>(0, plugin_namespaceObject.createSyncHook)();
@@ -43,19 +44,29 @@ const onBeforeCreateRouter = createRouterSyncHook();
 const onAfterCreateRouter = createRouterSyncHook();
 const onBeforeHydrateRouter = createRouterSyncHook();
 const onAfterHydrateRouter = createRouterSyncHook();
+const routerProviderRegistryHooks = {
+    modifyRoutes,
+    onBeforeCreateRoutes,
+    onBeforeCreateRouter,
+    onAfterCreateRouter,
+    onBeforeHydrateRouter,
+    onAfterHydrateRouter
+};
 exports.modifyRoutes = __webpack_exports__.modifyRoutes;
 exports.onAfterCreateRouter = __webpack_exports__.onAfterCreateRouter;
 exports.onAfterHydrateRouter = __webpack_exports__.onAfterHydrateRouter;
 exports.onBeforeCreateRouter = __webpack_exports__.onBeforeCreateRouter;
 exports.onBeforeCreateRoutes = __webpack_exports__.onBeforeCreateRoutes;
 exports.onBeforeHydrateRouter = __webpack_exports__.onBeforeHydrateRouter;
+exports.routerProviderRegistryHooks = __webpack_exports__.routerProviderRegistryHooks;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "modifyRoutes",
     "onAfterCreateRouter",
     "onAfterHydrateRouter",
     "onBeforeCreateRouter",
     "onBeforeCreateRoutes",
-    "onBeforeHydrateRouter"
+    "onBeforeHydrateRouter",
+    "routerProviderRegistryHooks"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true