vike 0.4.144 → 0.4.145-commit-2520555

package/dist/esm/client/client-routing-runtime/{getPageContext.js → getPageContextFromHooks.js}

@@ -1,105 +1,91 @@
-export { getPageContext };
-export { getPageContextErrorPage };
-export { checkIf404 };
+export { getPageContextFromHooks_firstRender };
+export { getPageContextFromHooks_uponNavigation };
+export { getPageContextFromHooks_errorPage };
 export { isAlreadyServerSideRouted };
-import { navigationState } from './navigationState.js';
 import { assert, assertUsage, hasProp, objectAssign, getProjectError, serverSideRouteTo, executeHook, isObject, getGlobalObject } from './utils.js';
 import { parse } from '@brillout/json-serializer/parse';
 import { getPageContextSerializedInHtml } from '../shared/getPageContextSerializedInHtml.js';
 import { analyzePageServerSide } from '../../shared/getPageFiles/analyzePageServerSide.js';
-import { route } from '../../shared/route/index.js';
 import { getErrorPageId } from '../../shared/error-page.js';
 import { getHook } from '../../shared/hooks/getHook.js';
 import { preparePageContextForUserConsumptionClientSide } from '../shared/preparePageContextForUserConsumptionClientSide.js';
 import { loadPageFilesClientSide } from '../shared/loadPageFilesClientSide.js';
 import { removeBuiltInOverrides } from './getPageContext/removeBuiltInOverrides.js';
 import { getPageContextRequestUrl } from '../../shared/getPageContextRequestUrl.js';
-import { getConfigValue, getPageConfig } from '../../shared/page-configs/utils.js';
+import { getConfigValue, getPageConfig } from '../../shared/page-configs/helpers.js';
 import { assertOnBeforeRenderHookReturn } from '../../shared/assertOnBeforeRenderHookReturn.js';
 import { executeGuardHook } from '../../shared/route/executeGuardHook.js';
 import { AbortRender, isAbortPageContext } from '../../shared/route/abort.js';
 const globalObject = getGlobalObject('router/getPageContext.ts', {});
-async function getPageContext(pageContext) {
-    if (pageContext._isFirstRenderAttempt && navigationState.isFirstUrl(pageContext.urlOriginal)) {
-        assert(hasProp(pageContext, '_isFirstRenderAttempt', 'true'));
-        const pageContextAddendum = await getPageContextFirstRender(pageContext);
-        setPageContextInitHasClientData(pageContextAddendum);
-        return pageContextAddendum;
-    }
-    else {
-        assert(hasProp(pageContext, '_isFirstRenderAttempt', 'false'));
-        const pageContextAddendum = await getPageContextUponNavigation(pageContext);
-        setPageContextInitHasClientData(pageContextAddendum);
-        return pageContextAddendum;
-    }
-}
-async function getPageContextFirstRender(pageContext) {
-    const pageContextAddendum = getPageContextSerializedInHtml();
-    removeBuiltInOverrides(pageContextAddendum);
-    objectAssign(pageContextAddendum, {
+async function getPageContextFromHooks_firstRender(pageContext) {
+    const pageContextFromHooks = getPageContextSerializedInHtml();
+    removeBuiltInOverrides(pageContextFromHooks);
+    objectAssign(pageContextFromHooks, {
         isHydration: true,
         _hasPageContextFromClient: false
     });
-    objectAssign(pageContextAddendum, await loadPageFilesClientSide(pageContext._pageFilesAll, pageContext._pageConfigs, pageContextAddendum._pageId));
+    objectAssign(pageContextFromHooks, await loadPageFilesClientSide(pageContextFromHooks._pageId, pageContext));
     {
-        const pageContextForHook = { ...pageContext, ...pageContextAddendum };
+        const pageContextForHook = { ...pageContext, ...pageContextFromHooks };
         if (await onBeforeRenderClientOnlyExists(pageContextForHook)) {
             const pageContextFromHook = await executeOnBeforeRenderHookClientSide(pageContextForHook);
-            objectAssign(pageContextAddendum, pageContextFromHook);
+            objectAssign(pageContextFromHooks, pageContextFromHook);
         }
     }
-    return pageContextAddendum;
+    setPageContextInitHasClientData(pageContextFromHooks);
+    return pageContextFromHooks;
 }
-async function getPageContextErrorPage(pageContext) {
+async function getPageContextFromHooks_errorPage(pageContext) {
     const errorPageId = getErrorPageId(pageContext._pageFilesAll, pageContext._pageConfigs);
     if (!errorPageId)
         throw new Error('No error page defined.');
-    const pageContextAddendum = {
+    const pageContextFromHooks = {
         isHydration: false,
         _pageId: errorPageId
     };
-    objectAssign(pageContextAddendum, await getPageContextAlreadyRouted({ ...pageContext, ...pageContextAddendum }, true));
-    return pageContextAddendum;
+    objectAssign(pageContextFromHooks, await getPageContextAlreadyRouted({ ...pageContext, ...pageContextFromHooks }, true));
+    return pageContextFromHooks;
 }
-async function getPageContextUponNavigation(pageContext) {
-    const pageContextAddendum = {
-        isHydration: false
+async function getPageContextFromHooks_uponNavigation(pageContext) {
+    const pageContextFromHooks = {
+        isHydration: false,
+        _pageId: pageContext._pageId
     };
-    objectAssign(pageContextAddendum, await getPageContextFromRoute(pageContext));
-    objectAssign(pageContextAddendum, await getPageContextAlreadyRouted({ ...pageContext, ...pageContextAddendum }, false));
-    return pageContextAddendum;
+    objectAssign(pageContextFromHooks, await getPageContextAlreadyRouted({ ...pageContext, ...pageContextFromHooks }, false));
+    setPageContextInitHasClientData(pageContextFromHooks);
+    return pageContextFromHooks;
 }
 async function getPageContextAlreadyRouted(pageContext, isErrorPage) {
-    let pageContextAddendum = {};
-    objectAssign(pageContextAddendum, await loadPageFilesClientSide(pageContext._pageFilesAll, pageContext._pageConfigs, pageContext._pageId));
+    let pageContextFromHooks = {};
+    objectAssign(pageContextFromHooks, await loadPageFilesClientSide(pageContext._pageId, pageContext));
     // Needs to be called before any client-side hook, because it may contain pageContextInit.user which is needed for guard() and onBeforeRender()
     if (
     // For the error page, we cannot fetch pageContext from the server because the pageContext JSON request is based on the URL
     !isErrorPage &&
-        (await hasPageContextServer({ ...pageContext, ...pageContextAddendum }))) {
+        (await hasPageContextServer({ ...pageContext, ...pageContextFromHooks }))) {
         const pageContextFromServer = await fetchPageContextFromServer(pageContext);
         if (!pageContextFromServer['_isError']) {
-            objectAssign(pageContextAddendum, pageContextFromServer);
+            objectAssign(pageContextFromHooks, pageContextFromServer);
         }
         else {
             const errorPageId = getErrorPageId(pageContext._pageFilesAll, pageContext._pageConfigs);
             assert(errorPageId);
-            pageContextAddendum = {};
-            objectAssign(pageContextAddendum, {
+            pageContextFromHooks = {};
+            objectAssign(pageContextFromHooks, {
                 isHydration: false,
                 _pageId: errorPageId
             });
-            objectAssign(pageContextAddendum, await loadPageFilesClientSide(pageContext._pageFilesAll, pageContext._pageConfigs, pageContextAddendum._pageId));
+            objectAssign(pageContextFromHooks, await loadPageFilesClientSide(pageContextFromHooks._pageId, pageContext));
             assert(hasProp(pageContextFromServer, 'is404', 'boolean'));
             assert(hasProp(pageContextFromServer, 'pageProps', 'object'));
             assert(hasProp(pageContextFromServer.pageProps, 'is404', 'boolean'));
             // When the user hasn't define a `_error.page.js` file: the mechanism with `serverSideError: true` is used instead
             assert(!('serverSideError' in pageContextFromServer));
-            objectAssign(pageContextAddendum, pageContextFromServer);
+            objectAssign(pageContextFromHooks, pageContextFromServer);
         }
     }
     else {
-        objectAssign(pageContextAddendum, { _hasPageContextFromServer: false });
+        objectAssign(pageContextFromHooks, { _hasPageContextFromServer: false });
         // We don't need to call guard() on the client-side if we fetch pageContext from the server side. (Because the `${url}.pageContext.json` HTTP request will already trigger the routing and guard() hook on the serve-side.)
         // We cannot call guard() before retrieving pageContext from server, since the server-side may define pageContextInit.user which is paramount for guard() hooks
         if (!isErrorPage) {
@@ -107,41 +93,41 @@ async function getPageContextAlreadyRouted(pageContext, isErrorPage) {
             await executeGuardHook({
                 _hasPageContextFromClient: false,
                 ...pageContext,
-                ...pageContextAddendum
+                ...pageContextFromHooks
             }, (pageContext) => preparePageContextForUserConsumptionClientSide(pageContext, true));
         }
     }
     {
         // For the error page, we also execute the client-side onBeforeRender() hook, but maybe we shouldn't? The server-side does it as well (but maybe it shouldn't).
-        const pageContextFromHook = await executeOnBeforeRenderHookClientSide({ ...pageContext, ...pageContextAddendum });
-        objectAssign(pageContextAddendum, pageContextFromHook);
+        const pageContextFromOnBeforeRender = await executeOnBeforeRenderHookClientSide({
+            ...pageContext,
+            ...pageContextFromHooks
+        });
+        objectAssign(pageContextFromHooks, pageContextFromOnBeforeRender);
     }
-    return pageContextAddendum;
+    return pageContextFromHooks;
 }
 async function executeOnBeforeRenderHookClientSide(pageContext) {
     const hook = getHook(pageContext, 'onBeforeRender');
     if (!hook) {
-        const pageContextAddendum = {
+        const pageContextFromOnBeforeRender = {
             _hasPageContextFromClient: false
         };
-        return pageContextAddendum;
+        return pageContextFromOnBeforeRender;
     }
     const onBeforeRender = hook.hookFn;
-    const pageContextAddendum = {
+    const pageContextFromOnBeforeRender = {
         _hasPageContextFromClient: true
     };
     const pageContextForUserConsumption = preparePageContextForUserConsumptionClientSide({
         ...pageContext,
-        ...pageContextAddendum
+        ...pageContextFromOnBeforeRender
     }, true);
     const hookResult = await executeHook(() => onBeforeRender(pageContextForUserConsumption), 'onBeforeRender', hook.hookFilePath);
     assertOnBeforeRenderHookReturn(hookResult, hook.hookFilePath);
     const pageContextFromHook = hookResult?.pageContext;
-    objectAssign(pageContextAddendum, pageContextFromHook);
-    return pageContextAddendum;
-}
-async function hasPageContextServer(pageContext) {
-    return !!globalObject.pageContextInitHasClientData || (await onBeforeRenderServerOnlyExists(pageContext));
+    objectAssign(pageContextFromOnBeforeRender, pageContextFromHook);
+    return pageContextFromOnBeforeRender;
 }
 // Workaround for the fact that the client-side cannot known whether a pageContext JSON request is needed in order to fetch pageContextInit data passed to the client.
 //  - The workaround is reliable as long as the user sets additional pageContextInit to undefined instead of not defining the property:
@@ -160,6 +146,9 @@ function setPageContextInitHasClientData(pageContext) {
         globalObject.pageContextInitHasClientData = true;
     }
 }
+async function hasPageContextServer(pageContext) {
+    return !!globalObject.pageContextInitHasClientData || (await onBeforeRenderServerOnlyExists(pageContext));
+}
 async function onBeforeRenderServerOnlyExists(pageContext) {
     if (pageContext._pageConfigs.length > 0) {
         // V1
@@ -184,26 +173,8 @@ async function onBeforeRenderClientOnlyExists(pageContext) {
         return false;
     }
 }
-async function getPageContextFromRoute(pageContext) {
-    const routeResult = await route(pageContext);
-    const pageContextFromRoute = routeResult.pageContextAddendum;
-    if (!pageContextFromRoute._pageId) {
-        const err = new Error('No routing match');
-        markIs404(err);
-        throw err;
-    }
-    assert(hasProp(pageContextFromRoute, '_pageId', 'string'));
-    return pageContextFromRoute;
-}
-function markIs404(err) {
-    objectAssign(err, { _is404: true });
-}
-function checkIf404(err) {
-    return isObject(err) && err._is404 === true;
-}
 async function fetchPageContextFromServer(pageContext) {
-    const urlLogical = pageContext._urlRewrite ?? pageContext._urlOriginalPristine ?? pageContext.urlOriginal;
-    const pageContextUrl = getPageContextRequestUrl(urlLogical);
+    const pageContextUrl = getPageContextRequestUrl(pageContext._urlRewrite ?? pageContext.urlOriginal);
     const response = await fetch(pageContextUrl);
     {
         const contentType = response.headers.get('content-type');

package/dist/esm/client/client-routing-runtime/history.d.ts

@@ -1,7 +1,8 @@
-export { initHistoryState, getHistoryState, pushHistory, ScrollPosition, saveScrollPosition };
+export { initHistoryState, getHistoryState, pushHistory, ScrollPosition, saveScrollPosition, monkeyPatchHistoryPushState };
 type HistoryState = {
     timestamp?: number;
     scrollPosition?: null | ScrollPosition;
+    triggedBy?: 'user' | 'vike' | 'browser';
 };
 type ScrollPosition = {
     x: number;
@@ -11,3 +12,4 @@ declare function initHistoryState(): void;
 declare function getHistoryState(): HistoryState;
 declare function saveScrollPosition(): void;
 declare function pushHistory(url: string, overwriteLastHistoryEntry: boolean): void;
+declare function monkeyPatchHistoryPushState(): void;

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

@@ -1,10 +1,12 @@
-export { initHistoryState, getHistoryState, pushHistory, saveScrollPosition };
-import { assert, hasProp, isObject } from './utils.js';
-// Fill missing state information.
-//  - The very first render => `history.state` is uninitialized (`null`).
-//  - The vike app runs `location.hash = '#section'` => `history.state` is uninitialized (`null`).
-//  - The user clicks on an anchor link `<a href="#section">Section</a>` => `history.state` is uninitialized (`null`).
-//  - `history.state` set by an old vike version => state information may be incomplete. (E.g. `state.timestamp` was introduced for `pageContext.isBackwardNavigation` in `0.4.19`.)
+export { initHistoryState, getHistoryState, pushHistory, saveScrollPosition, monkeyPatchHistoryPushState };
+import { assert, assertUsage, getGlobalObject, hasProp, isObject } from './utils.js';
+const globalObject = getGlobalObject('history.ts', {});
+// Fill missing state information:
+//  - `history.state` can uninitialized (i.e. `null`):
+//    - The very first render
+//    - The user's code runs `location.hash = '#section'`
+//    - The user clicks on an anchor link `<a href="#section">Section</a>` (Vike's `onLinkClick()` handler skips hash links).
+//  - State information may be incomplete if `history.state` is set by an old Vike version. (E.g. `state.timestamp` was introduced for `pageContext.isBackwardNavigation` in `0.4.19`.)
 function initHistoryState() {
     let state = window.history.state;
     if (!state) {
@@ -19,6 +21,9 @@ function initHistoryState() {
         hasModifications = true;
         state.scrollPosition = getScrollPosition();
     }
+    if (!('triggedBy' in state)) {
+        state.triggedBy = 'browser';
+    }
     assertState(state);
     if (hasModifications) {
         replaceHistoryState(state);
@@ -44,7 +49,7 @@ function saveScrollPosition() {
 function pushHistory(url, overwriteLastHistoryEntry) {
     if (!overwriteLastHistoryEntry) {
         const timestamp = getTimestamp();
-        pushHistoryState({ timestamp, scrollPosition: null }, url);
+        pushHistoryState({ timestamp, scrollPosition: null, triggedBy: 'vike' }, url);
     }
     else {
         replaceHistoryState(getHistoryState(), url);
@@ -67,5 +72,22 @@ function replaceHistoryState(state, url) {
     window.history.replaceState(state, '', url ?? /* Passing `undefined` chokes older Edge versions */ null);
 }
 function pushHistoryState(state, url) {
-    window.history.pushState(state, '', url);
+    pushStateOriginal(state, '', url);
+}
+function monkeyPatchHistoryPushState() {
+    globalObject.pushStateOriginal = globalObject.pushStateOriginal ?? window.history.pushState;
+    window.history.pushState = (stateFromUser = {}, ...rest) => {
+        assertUsage(null === stateFromUser || undefined === stateFromUser || isObject(stateFromUser), 'history.pushState(state) argument state must be an object');
+        const state = {
+            scrollPosition: getScrollPosition(),
+            timestamp: getTimestamp(),
+            ...stateFromUser,
+            // Don't allow user to overwrite triggedBy as it would break Vike's handling of the 'popstate' event
+            triggedBy: 'user'
+        };
+        return pushStateOriginal(state, ...rest);
+    };
+}
+function pushStateOriginal(...args) {
+    globalObject.pushStateOriginal.apply(history, args);
 }

package/dist/esm/client/client-routing-runtime/installClientRouter.d.ts

@@ -0,0 +1,2 @@
+export { installClientRouter };
+declare function installClientRouter(): void;

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

@@ -0,0 +1,22 @@
+export { installClientRouter };
+import { assert } from './utils.js';
+import { initHistoryState, monkeyPatchHistoryPushState } from './history.js';
+import { getRenderCount, renderPageClientSide } from './renderPageClientSide.js';
+import { onBrowserHistoryNavigation } from './onBrowserHistoryNavigation.js';
+import { onLinkClick } from './onLinkClick.js';
+import { setupNativeScrollRestoration } from './scrollRestoration.js';
+import { autoSaveScrollPosition } from './setScrollPosition.js';
+function installClientRouter() {
+    setupNativeScrollRestoration();
+    initHistoryState();
+    autoSaveScrollPosition();
+    monkeyPatchHistoryPushState();
+    // First initial render
+    assert(getRenderCount() === 0);
+    renderPageClientSide({ scrollTarget: 'preserve-scroll', isBackwardNavigation: null, isClientSideNavigation: false });
+    assert(getRenderCount() === 1);
+    // Intercept <a> links
+    onLinkClick();
+    // Handle back-/forward navigation
+    onBrowserHistoryNavigation();
+}

package/dist/esm/client/client-routing-runtime/isClientSideRoutable.d.ts

@@ -0,0 +1,8 @@
+export { isClientSideRoutable };
+import type { PageFile } from '../../shared/getPageFiles.js';
+import type { PageConfigRuntime } from '../../shared/page-configs/PageConfig.js';
+type PageContextPageFiles = {
+    _pageFilesAll: PageFile[];
+    _pageConfigs: PageConfigRuntime[];
+};
+declare function isClientSideRoutable(pageId: string, pageContext: PageContextPageFiles): Promise<boolean>;

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

@@ -0,0 +1,12 @@
+export { isClientSideRoutable };
+import { analyzePageClientSideInit } from '../../shared/getPageFiles/analyzePageClientSide.js';
+import { findPageConfig } from '../../shared/page-configs/findPageConfig.js';
+import { analyzeClientSide } from '../../shared/getPageFiles/analyzeClientSide.js';
+async function isClientSideRoutable(pageId, pageContext) {
+    await analyzePageClientSideInit(pageContext._pageFilesAll, pageId, {
+        sharedPageFilesAlreadyLoaded: false
+    });
+    const pageConfig = findPageConfig(pageContext._pageConfigs, pageId);
+    const { isClientSideRenderable, isClientRouting } = analyzeClientSide(pageConfig, pageContext._pageFilesAll, pageId);
+    return isClientSideRenderable && isClientRouting;
+}

package/dist/esm/client/client-routing-runtime/navigate.d.ts

@@ -1,6 +1,5 @@
 export { navigate };
 export { reload };
-export { defineNavigate };
 /** Programmatically navigate to a new page.
  *
  * https://vike.dev/navigate
@@ -13,5 +12,4 @@ declare function navigate(url: string, { keepScrollPosition, overwriteLastHistor
     keepScrollPosition?: boolean | undefined;
     overwriteLastHistoryEntry?: boolean | undefined;
 }): Promise<void>;
-declare function defineNavigate(navigate_: typeof navigate): void;
 declare function reload(): Promise<void>;

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

@@ -1,9 +1,8 @@
 export { navigate };
 export { reload };
-export { defineNavigate };
-import { assertUsage, isBrowser, getGlobalObject, assertClientRouting, checkIfClientRouting, getCurrentUrl } from './utils.js';
+import { renderPageClientSide } from './renderPageClientSide.js';
+import { assertUsage, isBrowser, assertClientRouting, checkIfClientRouting, getCurrentUrl } from './utils.js';
 assertClientRouting();
-const globalObject = getGlobalObject('navigate.ts', {});
 /** Programmatically navigate to a new page.
  *
  * https://vike.dev/navigate
@@ -15,7 +14,6 @@ const globalObject = getGlobalObject('navigate.ts', {});
 async function navigate(url, { keepScrollPosition = false, overwriteLastHistoryEntry = false } = {}) {
     assertUsage(isBrowser(), 'The navigate() function can be called only on the client-side', { showStackTrace: true });
     const errMsg = 'navigate() works only with Client Routing, see https://vike.dev/navigate';
-    assertUsage(globalObject.navigate, errMsg, { showStackTrace: true });
     assertUsage(checkIfClientRouting(), errMsg, { showStackTrace: true });
     assertUsage(url, '[navigate(url)] Missing argument url', { showStackTrace: true });
     assertUsage(typeof url === 'string', '[navigate(url)] Argument url should be a string', { showStackTrace: true });
@@ -24,10 +22,13 @@ async function navigate(url, { keepScrollPosition = false, overwriteLastHistoryE
     assertUsage(url.startsWith('/'), '[navigate(url)] Argument url should start with a leading /', {
         showStackTrace: true
     });
-    await globalObject.navigate(url, { keepScrollPosition, overwriteLastHistoryEntry });
-}
-function defineNavigate(navigate_) {
-    globalObject.navigate = navigate_;
+    const scrollTarget = keepScrollPosition ? 'preserve-scroll' : 'scroll-to-top-or-hash';
+    await renderPageClientSide({
+        scrollTarget,
+        urlOriginal: url,
+        overwriteLastHistoryEntry,
+        isBackwardNavigation: false
+    });
 }
 async function reload() {
     await navigate(getCurrentUrl());

package/dist/esm/client/client-routing-runtime/onBrowserHistoryNavigation.d.ts

@@ -0,0 +1,4 @@
+export { onBrowserHistoryNavigation };
+export { updateState };
+declare function onBrowserHistoryNavigation(): void;
+declare function updateState(): void;

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

@@ -0,0 +1,63 @@
+export { onBrowserHistoryNavigation };
+export { updateState };
+import { getCurrentUrl, getGlobalObject } from './utils.js';
+import { initHistoryState, getHistoryState } from './history.js';
+import { renderPageClientSide } from './renderPageClientSide.js';
+import { setScrollPosition } from './setScrollPosition.js';
+const globalObject = getGlobalObject('onBrowserHistoryNavigation.ts', { previousState: getState() });
+function onBrowserHistoryNavigation() {
+    // - The popstate event is trigged upon:
+    //   - Back-/forward navigation.
+    //     - By user clicking on his browser's back-/forward navigation (or using a shortcut)
+    //     - By JavaScript: `history.back()` / `history.forward()`
+    //   - URL hash change.
+    //     - By user clicking on a hash link `<a href="#some-hash" />`
+    //       - The popstate event is *only* triggered if `href` starts with '#' (even if `href` is '/#some-hash' while the current URL's pathname is '/' then the popstate still isn't triggered)
+    //     - By JavaScript: `location.hash = 'some-hash'`
+    // - The `event` of `window.addEventListener('popstate', (event) => /*...*/)` is useless: the History API doesn't provide the previous state (the popped state), see https://stackoverflow.com/questions/48055323/is-history-state-always-the-same-as-popstate-event-state
+    window.addEventListener('popstate', () => {
+        const currentState = getState();
+        const scrollTarget = currentState.historyState.scrollPosition || 'scroll-to-top-or-hash';
+        const isUserLandPushStateNavigation = currentState.historyState.triggedBy === 'user';
+        const isHashNavigation = currentState.urlWithoutHash === globalObject.previousState.urlWithoutHash;
+        const isBackwardNavigation = !currentState.historyState.timestamp || !globalObject.previousState.historyState.timestamp
+            ? null
+            : currentState.historyState.timestamp < globalObject.previousState.historyState.timestamp;
+        globalObject.previousState = currentState;
+        if (isHashNavigation && !isUserLandPushStateNavigation) {
+            // - `history.state` is uninitialized (`null`) when:
+            //   - The user's code runs `window.location.hash = '#section'`.
+            //   - The user clicks on an anchor link `<a href="#section">Section</a>` (because Vike's `onLinkClick()` handler skips hash links).
+            // - `history.state` is `null` when uninitialized: https://developer.mozilla.org/en-US/docs/Web/API/History/state
+            // - Alternatively, we completely take over hash navigation and reproduce the browser's native behavior upon hash navigation.
+            //   - Problem: we cannot intercept `window.location.hash = '#section'`. (Or maybe we can with the `hashchange` event?)
+            //   - Other potential problem: would there be a conflict when the user wants to override the browser's default behavior? E.g. for smooth scrolling, or when using hashes for saving states of some fancy animations.
+            // - Another alternative: we use the browser's scroll restoration mechanism (see `browserNativeScrollRestoration_enable()` below).
+            //   - Problem: not clear when to call `browserNativeScrollRestoration_disable()`/`browserNativeScrollRestoration_enable()`
+            //   - Other potential problem are inconsistencies between browsers: specification says that setting `window.history.scrollRestoration` only affects the current entry in the session history. But this seems to contradict what folks saying.
+            //     - Specification: https://html.spec.whatwg.org/multipage/history.html#the-history-interface
+            //     - https://stackoverflow.com/questions/70188241/history-scrollrestoration-manual-doesnt-prevent-safari-from-restoring-scrol
+            if (window.history.state === null) {
+                // The browser already scrolled to `#${hash}` => the current scroll position is the right one => we save it with `initHistoryState()`.
+                initHistoryState();
+                globalObject.previousState = getState();
+            }
+            else {
+                // If `history.state !== null` then it means that `popstate` was triggered by the user clicking on his browser's forward/backward history button.
+                setScrollPosition(scrollTarget);
+            }
+        }
+        else {
+            renderPageClientSide({ scrollTarget, isBackwardNavigation, isUserLandPushStateNavigation });
+        }
+    });
+}
+function getState() {
+    return {
+        urlWithoutHash: getCurrentUrl({ withoutHash: true }),
+        historyState: getHistoryState()
+    };
+}
+function updateState() {
+    globalObject.previousState = getState();
+}

package/dist/esm/client/client-routing-runtime/onLinkClick.d.ts

@@ -0,0 +1,2 @@
+export { onLinkClick };
+declare function onLinkClick(): void;

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

@@ -0,0 +1,40 @@
+// Code adapted from https://github.com/HenrikJoreteg/internal-nav-helper/blob/5199ec5448d0b0db7ec63cf76d88fa6cad878b7d/src/index.js#L11-L29
+export { onLinkClick };
+import { assert } from './utils.js';
+import { skipLink } from './skipLink.js';
+import { renderPageClientSide } from './renderPageClientSide.js';
+function onLinkClick() {
+    document.addEventListener('click', handler);
+}
+function handler(ev) {
+    if (!isNormalLeftClick(ev))
+        return;
+    const linkTag = findLinkTag(ev.target);
+    if (!linkTag)
+        return;
+    const url = linkTag.getAttribute('href');
+    if (skipLink(linkTag))
+        return;
+    assert(url);
+    ev.preventDefault();
+    const keepScrollPosition = ![null, 'false'].includes(linkTag.getAttribute('keep-scroll-position'));
+    const scrollTarget = keepScrollPosition ? 'preserve-scroll' : 'scroll-to-top-or-hash';
+    renderPageClientSide({
+        scrollTarget,
+        urlOriginal: url,
+        isBackwardNavigation: false
+    });
+}
+function isNormalLeftClick(ev) {
+    return ev.button === 0 && !ev.ctrlKey && !ev.shiftKey && !ev.altKey && !ev.metaKey;
+}
+function findLinkTag(target) {
+    while (target.tagName !== 'A') {
+        const { parentNode } = target;
+        if (!parentNode) {
+            return null;
+        }
+        target = parentNode;
+    }
+    return target;
+}