vike 0.4.196 → 0.4.197-commit-f4d8658

package/dist/esm/client/client-routing-runtime/prefetch.js

@@ -1,21 +1,46 @@
 export { prefetch };
+export { getPageContextPrefetched };
+export { initLinkPrefetchHandlers };
+export { populatePageContextPrefetchCache };
 export { addLinkPrefetchHandlers };
-import { assert, assertClientRouting, assertUsage, assertUsageUrlPathname, assertWarning, checkIfClientRouting, getGlobalObject } from './utils.js';
+export { addLinkPrefetchHandlers_watch };
+export { addLinkPrefetchHandlers_unwatch };
+import { assert, assertClientRouting, assertUsage, assertUsageUrlPathname, assertWarning, checkIfClientRouting, getGlobalObject, hasProp, objectAssign } from './utils.js';
 import { isErrorFetchingStaticAssets, loadUserFilesClientSide } from '../shared/loadUserFilesClientSide.js';
 import { skipLink } from './skipLink.js';
-import { getPrefetchSettings } from './prefetch/getPrefetchSettings.js';
-import { isAlreadyPrefetched, markAsAlreadyPrefetched } from './prefetch/alreadyPrefetched.js';
 import { disableClientRouting } from './renderPageClientSide.js';
 import { isClientSideRoutable } from './isClientSideRoutable.js';
 import { createPageContext } from './createPageContext.js';
 import { route } from '../../shared/route/index.js';
 import { noRouteMatch } from '../../shared/route/noRouteMatch.js';
+import { getPageContextFromServerHooks } from './getPageContextFromHooks.js';
+import { getPageContextCurrent } from './getPageContextCurrent.js';
+import { PAGE_CONTEXT_MAX_AGE_DEFAULT, getPrefetchSettings } from './prefetch/getPrefetchSettings.js';
 import pc from '@brillout/picocolors';
 assertClientRouting();
-const globalObject = getGlobalObject('prefetch.ts', { linkPrefetchHandlerAdded: new WeakMap() });
-async function prefetchAssets(pageId, pageContext) {
+const globalObject = getGlobalObject('prefetch.ts', {
+    linkPrefetchHandlerAdded: new WeakSet(),
+    addLinkPrefetchHandlers_debounce: null,
+    mutationObserver: new MutationObserver(addLinkPrefetchHandlers),
+    // `linkTags` [is automatically updated](https://developer.mozilla.org/en-US/docs/Web/API/HTMLCollection#:~:text=An%20HTMLCollection%20in%20the%20HTML%20DOM%20is%20live%3B%20it%20is%20automatically%20updated%20when%20the%20underlying%20document%20is%20changed.)
+    linkTags: document.getElementsByTagName('A'),
+    prefetchedPageContexts: {}
+});
+function getPageContextPrefetched(pageContext) {
+    const key = getCacheKey(pageContext.urlPathname);
+    const found = globalObject.prefetchedPageContexts[key];
+    if (!found || found.result.is404ServerSideRouted || isExpired(found))
+        return null;
+    const pageContextPrefetched = found.result.pageContextFromServerHooks;
+    /* TODO/pageContext-prefetch: make it work for when resultMaxAge is Infinity.
+    // We discard the prefetched pageContext whenever we use it, so that the user always sees fresh data upon naivgating.
+    delete globalObject.prefetchedPageContexts[key]
+    */
+    return pageContextPrefetched;
+}
+async function prefetchAssets(pageContextLink) {
     try {
-        await loadUserFilesClientSide(pageId, pageContext._pageFilesAll, pageContext._pageConfigs);
+        await loadUserFilesClientSide(pageContextLink.pageId, pageContextLink._pageFilesAll, pageContextLink._pageConfigs);
     }
     catch (err) {
         if (isErrorFetchingStaticAssets(err)) {
@@ -26,6 +51,32 @@ async function prefetchAssets(pageId, pageContext) {
         }
     }
 }
+async function prefetchPageContextFromServerHooks(pageContextLink, resultMaxAge) {
+    const result = await getPageContextFromServerHooks(pageContextLink, false);
+    setPageContextPrefetchCache(pageContextLink, result, resultMaxAge);
+}
+function populatePageContextPrefetchCache(pageContext, result) {
+    setPageContextPrefetchCache(pageContext, result, null);
+}
+function setPageContextPrefetchCache(pageContext, result, resultMaxAge) {
+    if (resultMaxAge === null)
+        resultMaxAge = getResultMaxAge();
+    const key = getCacheKey(pageContext.urlPathname);
+    globalObject.prefetchedPageContexts[key] = {
+        resultFetchedAt: Date.now(),
+        resultMaxAge,
+        result
+    };
+}
+function getResultMaxAge() {
+    const pageContextCurrent = getPageContextCurrent();
+    // TODO/pageContext-prefetch: remove this dirty hack used by @brillout/docpress and, instead, use Vike's default if pageContextCurrent isn't defined yet.
+    if (!pageContextCurrent)
+        return Infinity;
+    const prefetchSettings = getPrefetchSettings(pageContextCurrent, null);
+    const resultMaxAge = typeof prefetchSettings.pageContext === 'number' ? prefetchSettings.pageContext : PAGE_CONTEXT_MAX_AGE_DEFAULT;
+    return resultMaxAge;
+}
 /**
  * Programmatically prefetch client assets.
  *
@@ -33,85 +84,147 @@ async function prefetchAssets(pageId, pageContext) {
  *
  * @param url - The URL of the page you want to prefetch.
  */
-async function prefetch(url) {
+async function prefetch(url, options) {
     assertUsage(checkIfClientRouting(), 'prefetch() only works with Client Routing, see https://vike.dev/prefetch', {
         showStackTrace: true
     });
     const errPrefix = '[prefetch(url)] url';
     assertUsageUrlPathname(url, errPrefix);
-    if (isAlreadyPrefetched(url))
-        return;
-    markAsAlreadyPrefetched(url);
-    const pageContext = await createPageContext(url);
-    let pageContextFromRoute;
-    try {
-        pageContextFromRoute = await route(pageContext);
-    }
-    catch {
-        // If a route() hook has a bug or `throw render()` / `throw redirect()`
-        return;
-    }
-    const pageId = pageContextFromRoute._pageId;
-    if (!pageId) {
+    const pageContextLink = await getPageContextLink(url);
+    if (!pageContextLink?.pageId) {
         assertWarning(false, `${errPrefix} ${pc.string(url)} ${noRouteMatch}`, {
             showStackTrace: true,
             onlyOnce: false
         });
         return;
     }
-    await prefetchAssets(pageId, pageContext);
+    assert(hasProp(pageContextLink, 'pageId', 'string')); // help TypeScript
+    await Promise.all([
+        (async () => {
+            if (options?.staticAssets !== false) {
+                await prefetchAssets(pageContextLink);
+            }
+        })(),
+        (async () => {
+            if (options?.pageContext !== false) {
+                const resultMaxAge = typeof options?.pageContext === 'number' ? options.pageContext : null;
+                await prefetchPageContextFromServerHooks(pageContextLink, resultMaxAge);
+            }
+        })()
+    ]);
 }
-function addLinkPrefetchHandlers(pageContext) {
-    // Current URL is already prefetched
-    markAsAlreadyPrefetched(pageContext.urlPathname);
-    const linkTags = [...document.getElementsByTagName('A')];
-    linkTags.forEach((linkTag) => {
-        if (globalObject.linkPrefetchHandlerAdded.has(linkTag))
-            return;
-        globalObject.linkPrefetchHandlerAdded.set(linkTag, true);
-        const url = linkTag.getAttribute('href');
-        if (skipLink(linkTag))
-            return;
-        assert(url);
-        if (isAlreadyPrefetched(url))
-            return;
-        const { prefetchStaticAssets } = getPrefetchSettings(pageContext, linkTag);
-        if (!prefetchStaticAssets)
-            return;
-        if (prefetchStaticAssets === 'hover') {
-            linkTag.addEventListener('mouseover', () => {
-                prefetchIfPossible(url);
-            });
-            linkTag.addEventListener('touchstart', () => {
-                prefetchIfPossible(url);
-            }, { passive: true });
+// Lazy execution logic copied from: https://github.com/withastro/astro/blob/2594eb088d53a98181ac820243bcb1a765856ecf/packages/astro/src/runtime/client/dev-toolbar/apps/audit/index.ts#L53-L72
+function addLinkPrefetchHandlers() {
+    if (globalObject.addLinkPrefetchHandlers_debounce)
+        clearTimeout(globalObject.addLinkPrefetchHandlers_debounce);
+    globalObject.addLinkPrefetchHandlers_debounce = setTimeout(() => {
+        // Wait for the next idle period, as it is less likely to interfere with any other work the browser is doing post-mutation.
+        if ('requestIdleCallback' in window) {
+            requestIdleCallback(addLinkPrefetchHandlers_apply, { timeout: 300 });
         }
-        if (prefetchStaticAssets === 'viewport') {
-            const observer = new IntersectionObserver((entries) => {
-                entries.forEach((entry) => {
-                    if (entry.isIntersecting) {
-                        prefetchIfPossible(url);
-                        observer.disconnect();
-                    }
-                });
-            });
-            observer.observe(linkTag);
+        else {
+            // Fallback for old versions of Safari, we'll assume that things are less likely to be busy after 150ms.
+            setTimeout(addLinkPrefetchHandlers_apply, 150);
         }
+    }, 250);
+}
+function initLinkPrefetchHandlers() {
+    addLinkPrefetchHandlers();
+}
+function addLinkPrefetchHandlers_watch() {
+    // Notes about performance:
+    // - https://stackoverflow.com/questions/31659567/performance-of-mutationobserver-to-detect-nodes-in-entire-dom/39332340#39332340
+    // - https://news.ycombinator.com/item?id=15274211
+    //   - https://github.com/kubetail-org/sentineljs
+    // - https://stackoverflow.com/questions/55046093/listening-for-changes-in-htmlcollection-or-achieving-a-similar-effect
+    globalObject.mutationObserver.observe(document.body, {
+        childList: true,
+        subtree: true
     });
 }
-async function prefetchIfPossible(url) {
-    const pageContext = await createPageContext(url);
+function addLinkPrefetchHandlers_unwatch() {
+    globalObject.mutationObserver.disconnect();
+}
+function addLinkPrefetchHandlers_apply() {
+    for (let linkTag of globalObject.linkTags) {
+        if (globalObject.linkPrefetchHandlerAdded.has(linkTag))
+            continue;
+        globalObject.linkPrefetchHandlerAdded.add(linkTag);
+        if (skipLink(linkTag))
+            continue;
+        linkTag.addEventListener('mouseover', () => {
+            prefetchOnEvent(linkTag, 'hover');
+        }, { passive: true });
+        linkTag.addEventListener('touchstart', () => {
+            prefetchOnEvent(linkTag, 'hover');
+        }, { passive: true });
+        const observer = new IntersectionObserver((entries) => {
+            entries.forEach((entry) => {
+                if (entry.isIntersecting) {
+                    prefetchOnEvent(linkTag, 'viewport');
+                    observer.disconnect();
+                }
+            });
+        });
+        observer.observe(linkTag);
+    }
+}
+async function prefetchOnEvent(linkTag, event) {
+    let prefetchSettings;
+    const pageContextCurrent = getPageContextCurrent();
+    if (pageContextCurrent) {
+        prefetchSettings = getPrefetchSettings(pageContextCurrent, linkTag);
+    }
+    else {
+        // TODO/pageContext-prefetch: remove this dirty hack used by @brillout/docpress and, instead, use Vike's default if pageContextCurrent isn't defined yet.
+        prefetchSettings = { staticAssets: 'hover', pageContext: Infinity };
+    }
+    const urlOfLink = linkTag.getAttribute('href');
+    assert(urlOfLink);
+    const pageContextLink = await getPageContextLink(urlOfLink);
+    if (!pageContextLink?.pageId)
+        return;
+    assert(hasProp(pageContextLink, 'pageId', 'string')); // help TypeScript
+    if (!(await isClientSideRoutable(pageContextLink.pageId, pageContextLink)))
+        return;
+    await Promise.all([
+        (async () => {
+            if (prefetchSettings.staticAssets === event) {
+                await prefetchAssets(pageContextLink);
+            }
+        })(),
+        (async () => {
+            if (event !== 'viewport' && prefetchSettings.pageContext) {
+                const key = getCacheKey(urlOfLink);
+                const found = globalObject.prefetchedPageContexts[key];
+                if (!found || isExpired(found)) {
+                    // TODO/pageContext-prefetch: move this logic in getPrefetchSettings()
+                    const resultMaxAge = prefetchSettings.pageContext;
+                    await prefetchPageContextFromServerHooks(pageContextLink, resultMaxAge);
+                }
+            }
+        })()
+    ]);
+}
+function isExpired(found) {
+    return Date.now() - found.resultFetchedAt > found.resultMaxAge;
+}
+// TODO/next-major-release: make it sync
+async function getPageContextLink(urlOfLink) {
+    const pageContextLink = await createPageContext(urlOfLink);
     let pageContextFromRoute;
     try {
-        pageContextFromRoute = await route(pageContext);
+        pageContextFromRoute = await route(pageContextLink);
     }
     catch {
         // If a route() hook has a bug or `throw render()` / `throw redirect()`
-        return;
+        return null;
     }
-    if (!pageContextFromRoute?._pageId)
-        return;
-    if (!(await isClientSideRoutable(pageContextFromRoute._pageId, pageContext)))
-        return;
-    await prefetchAssets(pageContextFromRoute._pageId, pageContext);
+    objectAssign(pageContextLink, pageContextFromRoute);
+    return pageContextLink;
+}
+function getCacheKey(urlPathname) {
+    assert(urlPathname.startsWith('/'));
+    const key = urlPathname.split('#')[0];
+    return key;
 }

package/dist/esm/client/client-routing-runtime/renderPageClientSide.js

@@ -2,10 +2,10 @@ export { renderPageClientSide };
 export { getRenderCount };
 export { disableClientRouting };
 export { firstRenderStartPromise };
-import { assert, getCurrentUrl, isSameErrorMessage, objectAssign, redirectHard, getGlobalObject, executeHook, hasProp, augmentType, genPromise } from './utils.js';
-import { getPageContextFromHooks_isHydration, getPageContextFromHooks_isNotHydration, getPageContextFromHooks_serialized } from './getPageContextFromHooks.js';
+import { assert, getCurrentUrl, isSameErrorMessage, objectAssign, redirectHard, getGlobalObject, executeHook, hasProp, augmentType, genPromise, isCallable } from './utils.js';
+import { getPageContextFromClientHooks, getPageContextFromServerHooks, getPageContextFromHooks_isHydration, getPageContextFromHooks_serialized, setPageContextInitIsPassedToClient } from './getPageContextFromHooks.js';
 import { createPageContext } from './createPageContext.js';
-import { addLinkPrefetchHandlers } from './prefetch.js';
+import { addLinkPrefetchHandlers, addLinkPrefetchHandlers_unwatch, addLinkPrefetchHandlers_watch, getPageContextPrefetched, populatePageContextPrefetchCache } from './prefetch.js';
 import { assertInfo, assertWarning, isReact } from './utils.js';
 import { executeOnRenderClientHook } from '../shared/executeOnRenderClientHook.js';
 import { assertHook, getHook } from '../../shared/hooks/getHook.js';
@@ -18,6 +18,8 @@ import { setScrollPosition } from './setScrollPosition.js';
 import { updateState } from './onBrowserHistoryNavigation.js';
 import { browserNativeScrollRestoration_disable, setInitialRenderIsDone } from './scrollRestoration.js';
 import { getErrorPageId } from '../../shared/error-page.js';
+import { setPageContextCurrent } from './getPageContextCurrent.js';
+import { getRouteStringParameterList } from '../../shared/route/resolveRouteString.js';
 const globalObject = getGlobalObject('renderPageClientSide.ts', (() => {
     const { promise: firstRenderStartPromise, resolve: firstRenderStartPromiseResolve } = genPromise();
     return {
@@ -28,8 +30,10 @@ const globalObject = getGlobalObject('renderPageClientSide.ts', (() => {
 })());
 const { firstRenderStartPromise } = globalObject;
 async function renderPageClientSide(renderArgs) {
-    const { scrollTarget, urlOriginal = getCurrentUrl(), overwriteLastHistoryEntry = false, isBackwardNavigation, pageContextsFromRewrite = [], redirectCount = 0, isUserLandPushStateNavigation, isClientSideNavigation = true } = renderArgs;
+    const { urlOriginal = getCurrentUrl(), overwriteLastHistoryEntry = false, isBackwardNavigation, pageContextsFromRewrite = [], redirectCount = 0, isUserLandPushStateNavigation, isClientSideNavigation = true } = renderArgs;
+    let { scrollTarget } = renderArgs;
     const { previousPageContext } = globalObject;
+    addLinkPrefetchHandlers_unwatch();
     const { isRenderOutdated, setHydrationCanBeAborted, isFirstRender } = getIsRenderOutdated();
     // Note that pageContext.isHydration isn't equivalent to isFirstRender
     // - Thus pageContext.isHydration isn't equivalent to !pageContext.isClientSideNavigation
@@ -93,7 +97,7 @@ async function renderPageClientSide(renderArgs) {
             }
             if (isRenderOutdated())
                 return;
-            if (!pageContextFromRoute._pageId) {
+            if (!pageContextFromRoute.pageId) {
                 /*
                 // We don't use the client router to render the 404 page:
                 //  - So that the +redirects setting (https://vike.dev/redirects) can be applied.
@@ -106,17 +110,17 @@ async function renderPageClientSide(renderArgs) {
                 redirectHard(urlOriginal);
                 return;
             }
-            assert(hasProp(pageContextFromRoute, '_pageId', 'string')); // Help TS
-            const isClientRoutable = await isClientSideRoutable(pageContextFromRoute._pageId, pageContext);
+            assert(hasProp(pageContextFromRoute, 'pageId', 'string')); // Help TS
+            const isClientRoutable = await isClientSideRoutable(pageContextFromRoute.pageId, pageContext);
             if (isRenderOutdated())
                 return;
             if (!isClientRoutable) {
                 redirectHard(urlOriginal);
                 return;
             }
-            const isSamePage = pageContextFromRoute._pageId &&
-                previousPageContext?._pageId &&
-                pageContextFromRoute._pageId === previousPageContext._pageId;
+            const isSamePage = pageContextFromRoute.pageId &&
+                previousPageContext?.pageId &&
+                pageContextFromRoute.pageId === previousPageContext.pageId;
             if (isUserLandPushStateNavigation && isSamePage) {
                 // Skip's Vike's rendering; let the user handle the navigation
                 return;
@@ -126,7 +130,7 @@ async function renderPageClientSide(renderArgs) {
         assert(!('urlOriginal' in pageContextRouted));
         objectAssign(pageContext, pageContextRouted);
         try {
-            objectAssign(pageContext, await loadUserFilesClientSide(pageContext._pageId, pageContext._pageFilesAll, pageContext._pageConfigs));
+            objectAssign(pageContext, await loadUserFilesClientSide(pageContext.pageId, pageContext._pageFilesAll, pageContext._pageConfigs));
         }
         catch (err) {
             if (handleErrorFetchingStaticAssets(err, pageContext, isFirstRender)) {
@@ -140,6 +144,7 @@ async function renderPageClientSide(renderArgs) {
         }
         if (isRenderOutdated())
             return;
+        setPageContextCurrent(pageContext);
         // Set global hydrationCanBeAborted
         if (pageContext.exports.hydrationCanBeAborted) {
             setHydrationCanBeAborted();
@@ -147,7 +152,7 @@ async function renderPageClientSide(renderArgs) {
         else {
             assertWarning(!isReact(), 'You seem to be using React; we recommend setting hydrationCanBeAborted to true, see https://vike.dev/hydrationCanBeAborted', { onlyOnce: true });
         }
-        // There wasn't any `await` but result may change because we just called setHydrationCanBeAborted()
+        // There wasn't any `await` but the isRenderOutdated() return value may have changed because we called setHydrationCanBeAborted()
         if (isRenderOutdated())
             return;
         // Get pageContext from hooks (fetched from server, and/or directly called on the client-side)
@@ -168,9 +173,34 @@ async function renderPageClientSide(renderArgs) {
             await renderPageView(pageContext);
         }
         else {
-            let res;
+            // Fetch pageContext from server-side hooks
+            let pageContextFromServerHooks;
+            const pageContextPrefetched = getPageContextPrefetched(pageContext);
+            if (pageContextPrefetched) {
+                pageContextFromServerHooks = pageContextPrefetched;
+            }
+            else {
+                try {
+                    const result = await getPageContextFromServerHooks(pageContext, false);
+                    if (result.is404ServerSideRouted)
+                        return;
+                    pageContextFromServerHooks = result.pageContextFromServerHooks;
+                    populatePageContextPrefetchCache(pageContext, result);
+                }
+                catch (err) {
+                    await onError(err);
+                    return;
+                }
+            }
+            if (isRenderOutdated())
+                return;
+            // TODO/eventually: create helper assertPageContextFromHook()
+            assert(!('urlOriginal' in pageContextFromServerHooks));
+            objectAssign(pageContext, pageContextFromServerHooks);
+            // Get pageContext from client-side hooks
+            let pageContextFromClientHooks;
             try {
-                res = await getPageContextFromHooks_isNotHydration(pageContext, false);
+                pageContextFromClientHooks = await getPageContextFromClientHooks(pageContext, false);
             }
             catch (err) {
                 await onError(err);
@@ -178,10 +208,7 @@ async function renderPageClientSide(renderArgs) {
             }
             if (isRenderOutdated())
                 return;
-            if ('is404ServerSideRouted' in res)
-                return;
-            augmentType(pageContext, res.pageContextAugmented);
-            // Render page view
+            augmentType(pageContext, pageContextFromClientHooks);
             await renderPageView(pageContext);
         }
     }
@@ -284,9 +311,9 @@ async function renderPageClientSide(renderArgs) {
         if (!errorPageId)
             throw new Error('No error page defined.');
         objectAssign(pageContext, {
-            _pageId: errorPageId
+            pageId: errorPageId
         });
-        const isClientRoutable = await isClientSideRoutable(pageContext._pageId, pageContext);
+        const isClientRoutable = await isClientSideRoutable(pageContext.pageId, pageContext);
         if (isRenderOutdated())
             return;
         if (!isClientRoutable) {
@@ -294,7 +321,7 @@ async function renderPageClientSide(renderArgs) {
             return;
         }
         try {
-            objectAssign(pageContext, await loadUserFilesClientSide(pageContext._pageId, pageContext._pageFilesAll, pageContext._pageConfigs));
+            objectAssign(pageContext, await loadUserFilesClientSide(pageContext.pageId, pageContext._pageFilesAll, pageContext._pageConfigs));
         }
         catch (err) {
             if (handleErrorFetchingStaticAssets(err, pageContext, isFirstRender)) {
@@ -308,21 +335,35 @@ async function renderPageClientSide(renderArgs) {
         }
         if (isRenderOutdated())
             return;
-        let res;
+        setPageContextCurrent(pageContext);
+        let pageContextFromServerHooks;
         try {
-            res = await getPageContextFromHooks_isNotHydration(pageContext, true);
+            const result = await getPageContextFromServerHooks(pageContext, true);
+            if (result.is404ServerSideRouted)
+                return;
+            pageContextFromServerHooks = result.pageContextFromServerHooks;
         }
         catch (err) {
-            // - When user hasn't defined a `_error.page.js` file
-            // - Some Vike unpexected internal error
             onError(err);
             return;
         }
         if (isRenderOutdated())
             return;
-        if ('is404ServerSideRouted' in res)
+        // TODO/eventually: create helper assertPageContextFromHook()
+        assert(!('urlOriginal' in pageContextFromServerHooks));
+        objectAssign(pageContext, pageContextFromServerHooks);
+        let pageContextFromClientHooks;
+        try {
+            pageContextFromClientHooks = await getPageContextFromClientHooks(pageContext, true);
+        }
+        catch (err) {
+            onError(err);
             return;
-        augmentType(pageContext, res.pageContextAugmented);
+        }
+        if (isRenderOutdated())
+            return;
+        augmentType(pageContext, pageContextFromClientHooks);
+        objectAssign(pageContext, { routeParams: {} });
         await renderPageView(pageContext, args);
     }
     async function renderPageView(pageContext, isErrorPage) {
@@ -369,7 +410,6 @@ async function renderPageClientSide(renderArgs) {
         /* We don't abort in order to ensure that onHydrationEnd() is called: we abort only after onHydrationEnd() is called.
         if (isRenderOutdated(true)) return
         */
-        addLinkPrefetchHandlers(pageContext);
         // onHydrationEnd()
         if (isFirstRender && !onRenderClientError) {
             assertHook(pageContext, 'onHydrationEnd');
@@ -411,10 +451,24 @@ async function renderPageClientSide(renderArgs) {
                     return;
             }
         }
+        if (!scrollTarget && previousPageContext) {
+            const keepScrollPositionPrev = getKeepScrollPositionSetting(previousPageContext);
+            const keepScrollPositionNext = getKeepScrollPositionSetting(pageContext);
+            if (keepScrollPositionNext !== false &&
+                keepScrollPositionPrev !== false &&
+                areKeysEqual(keepScrollPositionNext, keepScrollPositionPrev)) {
+                scrollTarget = { preserveScroll: true };
+            }
+        }
         // Page scrolling
         setScrollPosition(scrollTarget);
         browserNativeScrollRestoration_disable();
         setInitialRenderIsDone();
+        if (pageContext._hasPageContextFromServer)
+            setPageContextInitIsPassedToClient(pageContext);
+        // Add link prefetch handlers
+        addLinkPrefetchHandlers_watch();
+        addLinkPrefetchHandlers();
     }
 }
 function changeUrl(url, overwriteLastHistoryEntry) {
@@ -486,3 +540,38 @@ function getIsRenderOutdated() {
 function getRenderCount() {
     return globalObject.renderCounter;
 }
+function getKeepScrollPositionSetting(pageContext) {
+    const c = pageContext.from.configsStandard.keepScrollPosition;
+    if (!c)
+        return false;
+    let val = c.value;
+    const configDefinedAt = c.definedAt;
+    assert(configDefinedAt);
+    const routeParameterList = getRouteStringParameterList(configDefinedAt);
+    if (isCallable(val))
+        val = val(pageContext, {
+            configDefinedAt: c.definedAt
+            /* We don't pass routeParameterList because it's useless: the user knows the parameter list.
+            routeParameterList
+            */
+        });
+    if (val === true) {
+        return [
+            configDefinedAt,
+            ...routeParameterList.map((param) => {
+                const val = pageContext.routeParams[param];
+                assert(val);
+                return val;
+            })
+        ];
+    }
+    // We skip validation and type-cast instead of assertUsage() in order to save client-side KBs
+    return val;
+}
+function areKeysEqual(key1, key2) {
+    if (key1 === key2)
+        return true;
+    if (!Array.isArray(key1) || !Array.isArray(key2))
+        return false;
+    return key1.length === key2.length && key1.every((_, i) => key1[i] === key2[i]);
+}

package/dist/esm/client/server-routing-runtime/getPageContext.d.ts

@@ -1,6 +1,6 @@
 export { getPageContext };
 declare function getPageContext(): Promise<{
-    _pageId: string;
+    pageId: string;
     routeParams: Record<string, string>;
 } & {
     isHydration: true;

package/dist/esm/client/server-routing-runtime/getPageContext.js

@@ -12,7 +12,7 @@ async function getPageContext() {
         _hasPageContextFromServer: true,
         _hasPageContextFromClient: false
     });
-    objectAssign(pageContext, await loadPageUserFiles(pageContext._pageId));
+    objectAssign(pageContext, await loadPageUserFiles(pageContext.pageId));
     assertPristineUrl();
     return pageContext;
 }

package/dist/esm/client/shared/executeOnRenderClientHook.d.ts

@@ -7,7 +7,7 @@ type PageContextBeforeRenderClient = {
     _pageFilesLoaded: PageFile[];
     urlOriginal?: string;
     urlPathname?: string;
-    _pageId: string;
+    pageId: string;
     _pageConfigs: PageConfigRuntime[];
 } & PageContextExports & PageContextForUserConsumptionClientSide;
 declare function executeOnRenderClientHook<PC extends PageContextBeforeRenderClient>(pageContext: PC, isClientRouting: boolean): Promise<void>;

package/dist/esm/client/shared/getPageContextSerializedInHtml.d.ts

@@ -1,5 +1,5 @@
 export { getPageContextSerializedInHtml };
 declare function getPageContextSerializedInHtml(): {
-    _pageId: string;
+    pageId: string;
     routeParams: Record<string, string>;
 };

package/dist/esm/client/shared/getPageContextSerializedInHtml.js

@@ -14,7 +14,7 @@ function getPageContextSerializedInHtml() {
     const pageContextJson = elem.textContent;
     assert(pageContextJson);
     const pageContextSerializedInHtml = parse(pageContextJson);
-    assert(hasProp(pageContextSerializedInHtml, '_pageId', 'string'));
+    assert(hasProp(pageContextSerializedInHtml, 'pageId', 'string'));
     assert(hasProp(pageContextSerializedInHtml, 'routeParams', 'string{}'));
     return pageContextSerializedInHtml;
 }

package/dist/esm/client/shared/preparePageContextForUserConsumptionClientSide.d.ts

@@ -4,7 +4,7 @@ import type { PageContextExports } from '../../shared/getPageFiles.js';
 import type { PageConfigRuntime } from '../../shared/page-configs/PageConfig.js';
 import { PageContextForPassToClientWarning } from './getPageContextProxyForUser.js';
 type PageContextForUserConsumptionClientSide = PageContextExports & PageContextForPassToClientWarning & {
-    _pageId: string;
+    pageId: string;
     _pageConfigs: PageConfigRuntime[];
 };
 declare function preparePageContextForUserConsumptionClientSide<T extends PageContextForUserConsumptionClientSide>(pageContext: T, isClientRouting: boolean): T & {