@bleedingdev/modern-js-runtime 3.2.0-ultramodern.102 → 3.2.0-ultramodern.103

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

@@ -11,45 +11,141 @@ function composeEventHandlers(theirHandler, ourHandler) {
     };
 }
 const ABSOLUTE_URL_REGEX = /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i;
-function usePrefetchBehavior(prefetch, theirElementProps) {
-    const [maybePrefetch, setMaybePrefetch] = react.useState(false);
+const DEFAULT_PREFETCH_BEHAVIOR = 'render';
+const DEFAULT_PRELOAD_BEHAVIOR = 'viewport';
+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 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 = Date.now())=>{
+    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((error)=>{
+            console.error(error);
+            warmupCache.delete(task.key);
+        }).finally(()=>{
+            activeWarmups -= 1;
+            runNextWarmup();
+        });
+    }
+};
+const scheduleWarmup = (key, run)=>{
+    if (!shouldWarmupOnCurrentNetwork()) return ()=>{};
+    pruneWarmupCache();
+    if (warmupCache.has(key)) return ()=>{};
+    warmupCache.set(key, Date.now());
+    const task = {
+        key,
+        run,
+        cancelled: false
+    };
+    warmupQueue.push(task);
+    runNextWarmup();
+    return ()=>{
+        task.cancelled = true;
+    };
+};
+const setRef = (ref, value)=>{
+    if (!ref) return;
+    if ('function' == typeof ref) return void ref(value);
+    try {
+        ref.current = value;
+    } catch  {}
+};
+const isDataWarmupEnabled = (route)=>{
+    const handle = route.handle;
+    return handle?.navigationWarmup?.data === true;
+};
+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);
     const { onFocus, onBlur, onMouseEnter, onMouseLeave, onTouchStart } = theirElementProps;
     react.useEffect(()=>{
         if ('render' === prefetch) setShouldPrefetch(true);
+        if ('render' === preload) setShouldPreload(true);
     }, [
-        prefetch
+        prefetch,
+        preload
     ]);
     const setIntent = ()=>{
-        if ('intent' === prefetch) setMaybePrefetch(true);
+        if ('intent' === prefetch || 'intent' === preload) setMaybeWarmup(true);
     };
     const cancelIntent = ()=>{
-        if ('intent' === prefetch) {
-            setMaybePrefetch(false);
+        if ('intent' === prefetch || 'intent' === preload) {
+            setMaybeWarmup(false);
             setShouldPrefetch(false);
+            setShouldPreload(false);
         }
     };
     react.useEffect(()=>{
-        if (maybePrefetch) {
+        if (maybeWarmup) {
             const id = setTimeout(()=>{
-                setShouldPrefetch(true);
-            }, 100);
+                if ('intent' === prefetch) setShouldPrefetch(true);
+                if ('intent' === preload) setShouldPreload(true);
+            }, INTENT_DELAY);
             return ()=>{
                 clearTimeout(id);
             };
         }
     }, [
-        maybePrefetch
+        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,
         {
             onFocus: composeEventHandlers(onFocus, setIntent),
             onBlur: composeEventHandlers(onBlur, cancelIntent),
             onMouseEnter: composeEventHandlers(onMouseEnter, setIntent),
             onMouseLeave: composeEventHandlers(onMouseLeave, cancelIntent),
             onTouchStart: composeEventHandlers(onTouchStart, setIntent)
-        }
+        },
+        setViewportElement
     ];
 }
 async function loadRouteModule(route, routeAssets) {
@@ -84,14 +180,34 @@ const getDataHref = (route, pathname, basename)=>{
     const url = getRequestUrl(path, id);
     return createDataHref(url.toString());
 };
-const PrefetchPageLinks = ({ path })=>{
+const PrefetchPageLinks = ({ path, includeData })=>{
     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;
+    const allowNetworkWarmup = shouldWarmupOnCurrentNetwork();
+    const matches = useMemo(()=>Array.isArray(routes) ? matchRoutes(routes, pathname) : [], [
+        pathname,
+        routes
+    ]);
+    react.useEffect(()=>{
+        if (!allowNetworkWarmup || !Array.isArray(matches) || !routeAssets || !__webpack_chunk_load__) return;
+        const cancellations = matches.map((match)=>{
+            const routeId = match.route.id;
+            const routeAsset = routeId ? routeAssets[routeId] : void 0;
+            const chunkIds = routeAsset?.chunkIds;
+            if (!routeId || !Array.isArray(chunkIds) || 0 === chunkIds.length) return ()=>{};
+            return scheduleWarmup(`route-module:${routeId}:${chunkIds.join(',')}`, ()=>loadRouteModule(match.route, routeAssets));
+        });
+        return ()=>{
+            cancellations.forEach((cancel)=>cancel());
+        };
+    }, [
+        allowNetworkWarmup,
+        matches,
+        routeAssets
+    ]);
+    if (!allowNetworkWarmup || !includeData || !window._SSR_DATA) return null;
     return /*#__PURE__*/ jsx(PrefetchDataLinks, {
         matches: matches,
         path: path,
@@ -103,7 +219,7 @@ const PrefetchDataLinks = ({ matches, path, routeManifest })=>{
     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 (!isDataWarmupEnabled(match.route) || !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);
@@ -130,20 +246,35 @@ const PrefetchDataLinks = ({ matches, path, routeManifest })=>{
         children: dataHrefs
     });
 };
-const createPrefetchLink = (Link)=>/*#__PURE__*/ react.forwardRef(({ to, prefetch = 'none', ...props }, forwardedRef)=>{
+const normalizePreloadBehavior = (preload, prefetch)=>{
+    if (false === preload || 'none' === preload) return 'none';
+    if (void 0 !== preload) return preload;
+    if ('none' === prefetch) return 'none';
+    return DEFAULT_PRELOAD_BEHAVIOR;
+};
+const createPrefetchLink = (Link)=>/*#__PURE__*/ react.forwardRef(({ to, prefetch = DEFAULT_PREFETCH_BEHAVIOR, preload, ...props }, forwardedRef)=>{
         const isAbsolute = 'string' == typeof to && ABSOLUTE_URL_REGEX.test(to);
-        const [shouldPrefetch, prefetchHandlers] = usePrefetchBehavior(prefetch, props);
+        const resolvedPreload = normalizePreloadBehavior(preload, prefetch);
+        const [shouldPrefetch, shouldPreload, prefetchHandlers, setViewportElement] = usePrefetchBehavior(prefetch, resolvedPreload, props);
+        const setAnchorRef = react.useCallback((element)=>{
+            setViewportElement(element);
+            setRef(forwardedRef, element);
+        }, [
+            forwardedRef,
+            setViewportElement
+        ]);
         const resolvedPath = useResolvedPath(to);
         return /*#__PURE__*/ jsxs(Fragment, {
             children: [
                 /*#__PURE__*/ jsx(Link, {
-                    ref: forwardedRef,
+                    ref: setAnchorRef,
                     to: to,
                     ...props,
                     ...prefetchHandlers
                 }),
-                shouldPrefetch && __webpack_chunk_load__ && !isAbsolute ? /*#__PURE__*/ jsx(PrefetchPageLinks, {
-                    path: resolvedPath
+                (shouldPrefetch || shouldPreload) && !isAbsolute ? /*#__PURE__*/ jsx(PrefetchPageLinks, {
+                    path: resolvedPath,
+                    includeData: shouldPrefetch
                 }) : null
             ]
         });

package/dist/esm-node/router/runtime/tanstack/prefetchLink.mjs

@@ -5,7 +5,7 @@ function resolvePreloadFromPrefetch(prefetch, preload) {
     if (void 0 !== preload) return preload;
     if ('none' === prefetch) return false;
     if ('intent' === prefetch || 'render' === prefetch || 'viewport' === prefetch) return prefetch;
-    return preload;
+    return 'viewport';
 }
 const LinkComponentImpl = (props)=>{
     const { prefetch, preload, ...rest } = props;

package/dist/types/cli/entry.d.ts

@@ -1,2 +1,2 @@
-export declare const hasApp: (dir: string) => any;
-export declare const isRuntimeEntry: (dir: string) => any;
+export declare const hasApp: (dir: string) => string | false;
+export declare const isRuntimeEntry: (dir: string) => string | false;

package/dist/types/core/context/response/index.server.d.ts

@@ -1,4 +1,7 @@
-export declare const getResponseProxy: () => any;
+export declare const getResponseProxy: () => {
+    headers: Record<string, string>;
+    status: number;
+} | undefined;
 export declare const setHeaders: (headers: Record<string, string>) => void;
 export declare const setStatus: (status: number) => void;
 export declare const redirect: (url: string, init?: number | ResponseInit) => void;

package/dist/types/core/plugin/index.d.ts

@@ -2,4 +2,4 @@ import type { InternalRuntimeContext } from '@modern-js/plugin/runtime';
 import type { RuntimeConfig, RuntimeExtends, RuntimePlugin } from './types';
 export type { RuntimePlugin };
 export declare function registerPlugin(internalPlugins: RuntimePlugin[], runtimeConfig?: RuntimeConfig): InternalRuntimeContext<RuntimeExtends>;
-export declare function mergeConfig(config: Record<string, any>, ...otherConfig: Record<string, any>[]): any;
+export declare function mergeConfig(config: Record<string, any>, ...otherConfig: Record<string, any>[]): Record<string, any>;

package/dist/types/core/server/utils.d.ts

@@ -15,5 +15,15 @@ export declare function checkIsNode(): boolean;
  * license at https://github.com/remix-run/remix/blob/main/LICENSE.md
  */
 export declare function serializeErrors(errors: StaticHandlerContext['errors']): StaticHandlerContext['errors'];
-export declare function getSSRConfigByEntry(entryName: string, ssr?: ServerUserConfig['ssr'], ssrByEntries?: ServerUserConfig['ssrByEntries']): any;
+export declare function getSSRConfigByEntry(entryName: string, ssr?: ServerUserConfig['ssr'], ssrByEntries?: ServerUserConfig['ssrByEntries']): true | {
+    forceCSR?: boolean;
+    mode?: import("@modern-js/types").SSRMode;
+    preload?: boolean | {
+        [x: string]: unknown;
+    };
+    inlineScript?: boolean;
+    disablePrerender?: boolean;
+    unsafeHeaders?: string[];
+    moduleFederationAppSSR?: boolean;
+};
 export declare function getSSRMode(ssrConfig?: SSRConfig): 'string' | 'stream' | false;

package/dist/types/router/cli/code/utils.d.ts

@@ -1,6 +1,6 @@
 export declare const walkDirectory: (dir: string) => string[];
 export declare const isPageComponentFile: (filePath: string) => boolean;
-export declare const replaceWithAlias: (base: string, filePath: string, alias: string) => any;
+export declare const replaceWithAlias: (base: string, filePath: string, alias: string) => string;
 export declare const parseModule: ({ source, filename, }: {
     source: string;
     filename: string;

package/dist/types/router/cli/entry.d.ts

@@ -13,6 +13,6 @@ export declare const getEntrypointRoutesDir: (entrypoint: {
 export declare const getEntrypointRoutesOwner: (entrypoint: {
     [ROUTES_OWNER_META_KEY]?: string;
 }) => string | null;
-export declare const hasNestedRoutes: (dir: string, routesDir?: string) => any;
+export declare const hasNestedRoutes: (dir: string, routesDir?: string) => boolean;
 export declare const isRouteEntry: (dir: string, routesDir?: string) => string | false;
 export declare const modifyEntrypoints: (entrypoints: Entrypoint[], routesDir?: string, routesOwner?: string) => EntrypointWithRoutesMeta[];

package/dist/types/router/runtime/PrefetchLink.d.ts

@@ -13,14 +13,18 @@ import React from 'react';
  *
  * - "intent": Fetched when the user focuses or hovers the link
  * - "render": Fetched when the link is rendered
+ * - "viewport": Fetched when the link enters the viewport
  * - "none": Never fetched
  */
-type PrefetchBehavior = 'intent' | 'render' | 'none';
+type PrefetchBehavior = 'intent' | 'render' | 'viewport' | 'none';
+type PreloadBehavior = PrefetchBehavior | false;
 export interface LinkProps extends RouterLinkProps {
     prefetch?: PrefetchBehavior;
+    preload?: PreloadBehavior;
 }
 export interface NavLinkProps extends RouterNavLinkProps {
     prefetch?: PrefetchBehavior;
+    preload?: PreloadBehavior;
 }
 declare const Link: React.ForwardRefExoticComponent<LinkProps & React.RefAttributes<HTMLAnchorElement>>;
 declare const NavLink: React.ForwardRefExoticComponent<NavLinkProps & React.RefAttributes<HTMLAnchorElement>>;

package/package.json

@@ -17,7 +17,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "3.2.0-ultramodern.102",
+  "version": "3.2.0-ultramodern.103",
   "engines": {
     "node": ">=20"
   },
@@ -233,12 +233,12 @@
     "isbot": "5.1.40",
     "react-helmet-async": "3.0.0",
     "react-is": "^19.2.6",
-    "@modern-js/plugin-data-loader": "npm:@bleedingdev/modern-js-plugin-data-loader@3.2.0-ultramodern.102",
-    "@modern-js/plugin": "npm:@bleedingdev/modern-js-plugin@3.2.0-ultramodern.102",
-    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.2.0-ultramodern.102",
-    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.2.0-ultramodern.102",
-    "@modern-js/render": "npm:@bleedingdev/modern-js-render@3.2.0-ultramodern.102",
-    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.2.0-ultramodern.102"
+    "@modern-js/plugin": "npm:@bleedingdev/modern-js-plugin@3.2.0-ultramodern.103",
+    "@modern-js/plugin-data-loader": "npm:@bleedingdev/modern-js-plugin-data-loader@3.2.0-ultramodern.103",
+    "@modern-js/render": "npm:@bleedingdev/modern-js-render@3.2.0-ultramodern.103",
+    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.2.0-ultramodern.103",
+    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.2.0-ultramodern.103",
+    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.2.0-ultramodern.103"
   },
   "peerDependencies": {
     "react": "^19.2.6",
@@ -246,7 +246,7 @@
   },
   "devDependencies": {
     "@remix-run/web-fetch": "^4.4.2",
-    "@rsbuild/core": "2.0.7",
+    "@rsbuild/core": "2.0.10",
     "@rslib/core": "0.21.5",
     "@tanstack/history": "1.162.0",
     "@testing-library/dom": "^10.4.1",
@@ -257,7 +257,7 @@
     "@typescript/native-preview": "7.0.0-dev.20260527.2",
     "react": "^19.2.6",
     "react-dom": "^19.2.6",
-    "@modern-js/app-tools": "npm:@bleedingdev/modern-js-app-tools@3.2.0-ultramodern.102",
+    "@modern-js/app-tools": "npm:@bleedingdev/modern-js-app-tools@3.2.0-ultramodern.103",
     "@scripts/rstest-config": "2.66.0"
   },
   "sideEffects": false,
@@ -267,7 +267,7 @@
   },
   "scripts": {
     "dev": "rslib build --watch",
-    "build": "rslib build && pnpm run gen-static",
+    "build": "rslib build && pnpm run gen-static && pnpm -w tsgo:dts \"$PWD\"",
     "gen-static": "node --disable-warning=ExperimentalWarning --experimental-strip-types ./scripts/gen-static.mts",
     "test": "rstest"
   }