vike 0.4.199 → 0.4.200-commit-de0e6ef

package/dist/cjs/node/client/router.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.prefetch = exports.reload = exports.navigate = void 0;
+exports.onPopState = exports.prefetch = exports.reload = exports.navigate = void 0;
 const assert_js_1 = require("../../utils/assert.js");
 // `never` to ensure package.json#exports["./client/router"].types points to type defined by the client-side code
 const navigate = (() => warnNoEffect('navigate'));
@@ -9,6 +9,8 @@ const reload = (() => warnNoEffect('reload'));
 exports.reload = reload;
 const prefetch = (() => warnNoEffect('prefetch'));
 exports.prefetch = prefetch;
+const onPopState = (() => { });
+exports.onPopState = onPopState;
 function warnNoEffect(caller) {
     (0, assert_js_1.assertWarning)(false, `Calling ${caller}() on the server-side has no effect`, {
         showStackTrace: true,

package/dist/cjs/node/plugin/plugins/envVars.js

@@ -5,6 +5,7 @@ const vite_1 = require("vite");
 const utils_js_1 = require("../utils.js");
 const rollupSourceMap_js_1 = require("../shared/rollupSourceMap.js");
 const getFilePath_js_1 = require("../shared/getFilePath.js");
+const normalizeId_js_1 = require("../shared/normalizeId.js");
 // TODO/enventually: (after we implemented vike.config.js)
 // - Make import.meta.env work inside +config.js
 //   - For it to work, we'll probably need the user to define the settings (e.g. `envDir`) for loadEnv() inside vike.config.js instead of vite.config.js
@@ -27,9 +28,11 @@ function envVarsPlugin() {
             config.plugins.sort((0, utils_js_1.lowerFirst)((plugin) => (plugin.name === 'vite:define' ? 1 : 0)));
         },
         transform(code, id, options) {
+            id = (0, normalizeId_js_1.normalizeId)(id);
             (0, utils_js_1.assertPosixPath)(id);
             if (id.includes('/node_modules/'))
                 return;
+            (0, utils_js_1.assertPosixPath)(config.root);
             if (!id.startsWith(config.root))
                 return;
             if (!code.includes('import.meta.env.'))

package/dist/cjs/node/plugin/plugins/extractAssetsPlugin.js

@@ -17,6 +17,7 @@ const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const fixServerAssets_js_1 = require("./buildConfig/fixServerAssets.js");
 const getVikeConfig_js_1 = require("./importUserCode/v1-design/getVikeConfig.js");
 const assertV1Design_js_1 = require("../../shared/assertV1Design.js");
+const normalizeId_js_1 = require("../shared/normalizeId.js");
 const extractAssetsRE = /(\?|&)extractAssets(?:&|$)/;
 exports.extractAssetsRE = extractAssetsRE;
 const rawRE = /(\?|&)raw(?:&|$)/;
@@ -36,6 +37,7 @@ function extractAssetsPlugin() {
             apply: 'build',
             enforce: 'post',
             async transform(src, id, options) {
+                id = (0, normalizeId_js_1.normalizeId)(id);
                 if (!extractAssetsRE.test(id)) {
                     return;
                 }

package/dist/cjs/node/plugin/plugins/extractExportNamesPlugin.js

@@ -6,6 +6,7 @@ exports.isUsingClientRouter = isUsingClientRouter;
 const utils_js_1 = require("../utils.js");
 const parseEsModule_js_1 = require("../shared/parseEsModule.js");
 const rollupSourceMap_js_1 = require("../shared/rollupSourceMap.js");
+const normalizeId_js_1 = require("../shared/normalizeId.js");
 const extractExportNamesRE = /(\?|&)extractExportNames(?:&|$)/;
 exports.extractExportNamesRE = extractExportNamesRE;
 const debug = (0, utils_js_1.createDebugger)('vike:extractExportNames');
@@ -16,6 +17,7 @@ function extractExportNamesPlugin() {
         name: 'vike:extractExportNames',
         enforce: 'post',
         async transform(src, id, options) {
+            id = (0, normalizeId_js_1.normalizeId)(id);
             const isClientSide = !(0, utils_js_1.viteIsSSR_options)(options);
             if (extractExportNamesRE.test(id)) {
                 const code = await getExtractExportNamesCode(src, isClientSide, !isDev, id);

package/dist/cjs/node/plugin/plugins/fileEnv.js

@@ -11,6 +11,7 @@ const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const getFilePath_js_1 = require("../shared/getFilePath.js");
 const rollupSourceMap_js_1 = require("../shared/rollupSourceMap.js");
 const parseEsModule_js_1 = require("../shared/parseEsModule.js");
+const normalizeId_js_1 = require("../shared/normalizeId.js");
 function fileEnv() {
     let config;
     let viteDevServer;
@@ -36,6 +37,7 @@ function fileEnv() {
         },
         // In production, we have to use transform() to replace modules with a runtime error because generateBundle() doesn't work for dynamic imports. In production, dynamic imports can only be verified at runtime.
         async transform(code, id, options) {
+            id = (0, normalizeId_js_1.normalizeId)(id);
             // In dev, only using load() is enough as it also works for dynamic imports (see sibling comment).
             if (viteDevServer)
                 return;

package/dist/cjs/node/plugin/plugins/importBuild/index.js

@@ -29,15 +29,15 @@ function importBuild() {
                 configVike = await (0, getConfigVike_js_1.getConfigVike)(config);
             }
         },
-        ...(0, plugin_1.serverEntryPlugin)({
-            getImporterCode: () => {
-                return getEntryCode(config, configVike);
+        ...(0, plugin_1.serverProductionEntryPlugin)({
+            getServerProductionEntry: () => {
+                return getServerProductionEntryCode(config, configVike);
             },
             libraryName: 'Vike'
         })
     ];
 }
-function getEntryCode(config, configVike) {
+function getServerProductionEntryCode(config, configVike) {
     const importPath = getImportPath(config);
     const vikeManifest = (0, getVikeManifest_js_1.getVikeManifest)(configVike);
     const importerCode = [

package/dist/cjs/node/plugin/plugins/importUserCode/index.js

@@ -23,16 +23,17 @@ function importUserCode() {
         name: 'vike:importUserCode',
         config(_, env) {
             isDev = (0, utils_js_1.isDev3)(env);
-            return {
-                experimental: {
-                    // TODO/v1-release: remove
-                    importGlobRestoreExtension: true
-                }
-            };
         },
         async configResolved(config_) {
             configVike = await (0, getConfigVike_js_1.getConfigVike)(config_);
             config = config_;
+            // TODO/v1-release: remove
+            {
+                (0, utils_js_1.assert)(isDev !== undefined);
+                const isV1 = await (0, getVikeConfig_js_1.isV1Design)(config, isDev);
+                if (!isV1)
+                    config.experimental.importGlobRestoreExtension = true;
+            }
         },
         resolveId(id) {
             if ((0, utils_js_1.isVirtualFileId)(id)) {

package/dist/cjs/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/transpileAndExecuteFile.js

@@ -19,6 +19,8 @@ require("source-map-support/register.js");
 const getFilePath_js_1 = require("../../../../shared/getFilePath.js");
 (0, utils_js_1.assertIsNotProductionRuntime)();
 const debug = (0, utils_js_1.createDebugger)('vike:pointer-imports');
+console.log('esbuild version', esbuild_1.version);
+console.log('require.resolve("vike-react/config")', require.resolve('vike-react/config'));
 async function transpileAndExecuteFile(filePath, userRootDir, isConfigFile) {
     const { filePathAbsoluteFilesystem, filePathToShowToUserResolved } = filePath;
     const fileExtension = getFileExtension(filePathAbsoluteFilesystem);
@@ -88,7 +90,7 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports) {
         metafile: true,
         bundle: true
     };
-    let pointerImports = {};
+    const pointerImports = {};
     options.plugins = [
         // Determine whether an import should be:
         //  - A pointer import
@@ -98,6 +100,7 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports) {
             setup(build) {
                 // https://github.com/brillout/esbuild-playground
                 build.onResolve({ filter: /.*/ }, async (args) => {
+                    console.log('onResolve()', JSON.stringify(args, null, 2));
                     if (args.kind !== 'import-statement')
                         return;
                     // Avoid infinite loop: https://github.com/evanw/esbuild/issues/3095#issuecomment-1546916366
@@ -106,14 +109,23 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports) {
                         return;
                     const { path, ...opts } = args;
                     opts.pluginData = { [useEsbuildResolver]: true };
-                    const resolved = await build.resolve(path, opts);
+                    let resolved = await build.resolve(path, opts);
                     if (resolved.errors.length > 0) {
+                        let resolvedWithNode;
+                        try {
+                            resolvedWithNode = require.resolve(args.path, { paths: [args.resolveDir] });
+                        }
+                        catch { }
+                        if (resolvedWithNode)
+                            resolved = { path: resolvedWithNode };
+                    }
+                    if (resolved.errors && resolved.errors.length > 0) {
                         /* We could do the following to let Node.js throw the error, but we don't because the error shown by esbuild is prettier: the Node.js error refers to the transpiled [build-f7i251e0iwnw]+config.ts.mjs whereas esbuild refers to the source +config.ts file.
                         pointerImports[args.path] = false
                         return { external: true }
                         */
-                        cleanEsbuildErrors(resolved.errors);
                         // Let esbuild throw the error
+                        cleanEsbuildErrors(resolved.errors);
                         return resolved;
                     }
                     (0, utils_js_1.assert)(resolved.path);

package/dist/cjs/node/plugin/plugins/importUserCode/v1-design/getVirtualFilePageConfigValuesAll.js

@@ -23,7 +23,7 @@ async function getVirtualFilePageConfigValuesAll(id, isDev, config) {
     const { pageId, isForClientSide } = result;
     const { pageConfigs } = await (0, getVikeConfig_js_1.getVikeConfig)(config, isDev, { tolerateInvalidConfig: true });
     const pageConfig = pageConfigs.find((pageConfig) => pageConfig.pageId === pageId);
-    (0, utils_js_1.assert)(pageConfig);
+    (0, utils_js_1.assert)(pageConfig, { id, pageId });
     const configVike = await (0, getConfigVike_js_1.getConfigVike)(config);
     const code = getLoadConfigValuesAll(pageConfig, isForClientSide, pageId, configVike.includeAssetsImportedByServer, isDev);
     (0, debug_js_1.debug)(id, isForClientSide ? 'CLIENT-SIDE' : 'SERVER-SIDE', code);

package/dist/cjs/node/plugin/shared/normalizeId.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeId = normalizeId;
+const utils_js_1 = require("../utils.js");
+// In principle Vite/Rollup should always normalize the `id` in `transform(code, id)` but it seems to not always do it.
+// https://github.com/vikejs/vike/issues/1935
+function normalizeId(id) {
+    return (0, utils_js_1.toPosixPath)(id);
+}

package/dist/cjs/node/prerender/runPrerender.js

@@ -605,7 +605,9 @@ async function write(urlOriginal, pageContext, fileExtension, fileContent, root,
     (0, utils_js_1.assertPosixPath)(fileUrl);
     (0, utils_js_1.assert)(fileUrl.startsWith('/'));
     const filePathRelative = fileUrl.slice(1);
-    (0, utils_js_1.assert)(!filePathRelative.startsWith('/'));
+    (0, utils_js_1.assert)(!filePathRelative.startsWith('/'), 
+    // Let's remove this debug info after we add a assertUsage() avoiding https://github.com/vikejs/vike/issues/1929
+    { urlOriginal, fileUrl });
     (0, utils_js_1.assertPosixPath)(outDirClient);
     (0, utils_js_1.assertPosixPath)(filePathRelative);
     const filePath = path_1.default.posix.join(outDirClient, filePathRelative);

package/dist/cjs/node/runtime/globalContext/loadImportBuild.js

@@ -12,7 +12,7 @@ function setImportBuildGetters(getters) {
 }
 async function loadImportBuild(outDir) {
     if (!buildGetters.getters) {
-        await (0, runtime_1.importServerEntry)(outDir);
+        await (0, runtime_1.importServerProductionEntry)({ outDir });
         (0, utils_js_1.assert)(buildGetters.getters);
     }
     const [pageFiles, assetsManifest, pluginManifest] = await Promise.all([

package/dist/cjs/node/runtime/renderPage.js

@@ -380,19 +380,29 @@ function getPermanentRedirect(pageContextInit, httpRequestId) {
         urlTarget = urlTargetExternal;
     }
     else {
-        if (origin)
-            urlTarget = (0, utils_js_1.addUrlOrigin)(urlTarget, origin);
-        if (urlTarget === urlWithoutBase)
+        let originChanged = false;
+        if (origin) {
+            const urlModified = (0, utils_js_1.setUrlOrigin)(urlTarget, origin);
+            if (urlModified !== false) {
+                originChanged = true;
+                urlTarget = urlModified;
+            }
+        }
+        if (normalize(urlTarget) === normalize(urlWithoutBase))
             return null;
-        urlTarget = (0, utils_js_1.prependBase)(urlTarget, baseServer);
+        if (!originChanged)
+            urlTarget = (0, utils_js_1.prependBase)(urlTarget, baseServer);
         (0, utils_js_1.assert)(urlTarget !== pageContextInit.urlOriginal);
     }
-    (0, loggerRuntime_js_1.logRuntimeInfo)?.(`Permanent redirect defined by your config.redirects (https://vike.dev/redirects)`, httpRequestId, 'info');
+    (0, loggerRuntime_js_1.logRuntimeInfo)?.(`Permanent redirection defined by config.redirects (https://vike.dev/redirects)`, httpRequestId, 'info');
     const httpResponse = (0, createHttpResponse_js_1.createHttpResponseRedirect)({ url: urlTarget, statusCode: 301 }, urlWithoutBase);
     const pageContextHttpResponse = createPageContext(pageContextInit);
     (0, utils_js_1.objectAssign)(pageContextHttpResponse, { httpResponse });
     return pageContextHttpResponse;
 }
+function normalize(url) {
+    return url || '/';
+}
 async function handleAbortError(errAbort, pageContextsFromRewrite, pageContextInit, 
 // handleAbortError() creates a new pageContext object and we don't merge pageContextNominalPageInit to it: we only use some pageContextNominalPageInit information.
 pageContextNominalPageInit, httpRequestId, renderContext, pageContextErrorPageInit) {

package/dist/cjs/utils/PROJECT_VERSION.js

@@ -2,4 +2,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PROJECT_VERSION = void 0;
 // Automatically updated by @brillout/release-me
-exports.PROJECT_VERSION = '0.4.199';
+exports.PROJECT_VERSION = '0.4.200-commit-de0e6ef';

package/dist/cjs/utils/parseUrl-extras.js

@@ -6,7 +6,7 @@ exports.normalizeUrlPathname = normalizeUrlPathname;
 exports.removeBaseServer = removeBaseServer;
 exports.modifyUrlPathname = modifyUrlPathname;
 exports.removeUrlOrigin = removeUrlOrigin;
-exports.addUrlOrigin = addUrlOrigin;
+exports.setUrlOrigin = setUrlOrigin;
 exports.getUrlPretty = getUrlPretty;
 const parseUrl_js_1 = require("./parseUrl.js");
 const assert_js_1 = require("./assert.js");
@@ -96,9 +96,10 @@ function removeUrlOrigin(url) {
     const urlModified = (0, parseUrl_js_1.createUrlFromComponents)(null, pathnameOriginal, searchOriginal, hashOriginal);
     return { urlModified, origin };
 }
-function addUrlOrigin(url, origin) {
+function setUrlOrigin(url, origin) {
     const { origin: originCurrent, pathnameOriginal, searchOriginal, hashOriginal } = (0, parseUrl_js_1.parseUrl)(url, '/');
-    (0, assert_js_1.assert)(originCurrent === null);
+    if (origin === originCurrent)
+        return false;
     (0, assert_js_1.assert)(origin === null || origin.startsWith('http'));
     const urlModified = (0, parseUrl_js_1.createUrlFromComponents)(origin, pathnameOriginal, searchOriginal, hashOriginal);
     return urlModified;

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

@@ -1,16 +1,26 @@
-export { initHistoryState, getHistoryState, pushHistory, ScrollPosition, saveScrollPosition, monkeyPatchHistoryPushState };
-type HistoryState = {
-    timestamp?: number;
-    scrollPosition?: null | ScrollPosition;
-    triggeredBy?: 'user' | 'vike' | 'browser';
+export { pushHistoryState };
+export { onPopStateBegin };
+export { saveScrollPosition };
+export type { HistoryInfo };
+export type { ScrollPosition };
+type StateEnhanced = {
+    timestamp: number;
+    scrollPosition: null | ScrollPosition;
+    triggeredBy: 'user' | 'vike' | 'browser';
     _isVikeEnhanced: true;
 };
 type ScrollPosition = {
     x: number;
     y: number;
 };
-declare function initHistoryState(): void;
-declare function getHistoryState(): HistoryState;
 declare function saveScrollPosition(): void;
-declare function pushHistory(url: string, overwriteLastHistoryEntry: boolean): void;
-declare function monkeyPatchHistoryPushState(): void;
+declare function pushHistoryState(url: string, overwriteLastHistoryEntry: boolean): void;
+type HistoryInfo = {
+    url: `/${string}`;
+    state: StateEnhanced;
+};
+declare function onPopStateBegin(): {
+    isNewState: boolean;
+    previous: HistoryInfo;
+    current: HistoryInfo;
+};

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

@@ -1,37 +1,57 @@
-export { initHistoryState, getHistoryState, pushHistory, saveScrollPosition, monkeyPatchHistoryPushState };
-import { assert, assertUsage, hasProp, isObject } from './utils.js';
-// 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 `initOnLinkClick()` 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() {
-    // No way found to add TypeScript types to `window.history.state`: https://github.com/microsoft/TypeScript/issues/36178
-    let state = window.history.state;
-    if (!state) {
-        state = { _isVikeEnhanced: true };
-    }
-    let hasModifications = false;
-    if (!('timestamp' in state)) {
-        hasModifications = true;
-        state.timestamp = getTimestamp();
-    }
-    if (!('scrollPosition' in state)) {
-        hasModifications = true;
-        state.scrollPosition = getScrollPosition();
-    }
-    if (!('triggeredBy' in state)) {
-        state.triggeredBy = 'browser';
+export { pushHistoryState };
+export { onPopStateBegin };
+export { saveScrollPosition };
+import { assert, assertUsage, getCurrentUrl, getGlobalObject, hasProp, isObject } from './utils.js';
+init();
+const globalObject = getGlobalObject('history.ts', { previous: getHistoryInfo() });
+// `window.history.state === null` when:
+// - The very first render
+// - Click on `<a href="#some-hash" />`
+// - `location.hash = 'some-hash'`
+function enhanceHistoryState() {
+    const stateNotEnhanced = getStateNotEnhanced();
+    if (isVikeEnhanced(stateNotEnhanced))
+        return;
+    const stateVikeEnhanced = enhance(stateNotEnhanced);
+    replaceHistoryState(stateVikeEnhanced);
+}
+function enhance(stateNotEnhanced) {
+    const timestamp = getTimestamp();
+    const scrollPosition = getScrollPosition();
+    const triggeredBy = 'browser';
+    let stateVikeEnhanced;
+    if (!stateNotEnhanced) {
+        stateVikeEnhanced = {
+            timestamp,
+            scrollPosition,
+            triggeredBy,
+            _isVikeEnhanced: true
+        };
     }
-    assertState(state);
-    if (hasModifications) {
-        replaceHistoryState(state);
+    else {
+        // State information may be incomplete if `window.history.state` is set by an old Vike version. (E.g. `state.timestamp` was introduced for `pageContext.isBackwardNavigation` in `0.4.19`.)
+        stateVikeEnhanced = {
+            timestamp: stateNotEnhanced.timestamp ?? timestamp,
+            scrollPosition: stateNotEnhanced.scrollPosition ?? scrollPosition,
+            triggeredBy: stateNotEnhanced.triggeredBy ?? triggeredBy,
+            _isVikeEnhanced: true
+        };
     }
+    assert(isVikeEnhanced(stateVikeEnhanced));
+    return stateVikeEnhanced;
+}
+function getState() {
+    const state = getStateNotEnhanced();
+    // *Every* state added to the history needs to go through Vike.
+    // - Otherwise Vike's `popstate` listener won't work. (Because, for example, if globalObject.previous is outdated => isHashNavigation faulty => client-side navigation is wrongfully skipped.)
+    // - Therefore, we have to monkey patch history.pushState() and history.replaceState()
+    // - Therefore, we need the assert() below to ensure history.state has been enhanced by Vike
+    //   - If users stumble upon this assert() then let's make it a assertUsage()
+    assert(isVikeEnhanced(state));
+    return state;
 }
-function getHistoryState() {
-    const state = window.history.state || {};
-    assertState(state);
+function getStateNotEnhanced() {
+    const state = window.history.state;
     return state;
 }
 function getScrollPosition() {
@@ -43,55 +63,88 @@ function getTimestamp() {
 }
 function saveScrollPosition() {
     const scrollPosition = getScrollPosition();
-    const state = getHistoryState();
+    const state = getState();
     replaceHistoryState({ ...state, scrollPosition });
 }
-function pushHistory(url, overwriteLastHistoryEntry) {
+function pushHistoryState(url, overwriteLastHistoryEntry) {
     if (!overwriteLastHistoryEntry) {
-        const timestamp = getTimestamp();
-        pushHistoryState({ timestamp, scrollPosition: null, triggeredBy: 'vike', _isVikeEnhanced: true }, url);
+        const state = {
+            timestamp: getTimestamp(),
+            // I don't remember why I set it to `null`, maybe because setting it now would be too early? (Maybe there is a delay between renderPageClientSide() is finished and the browser updating the scroll position.) Anyways, it seems like autoSaveScrollPosition() is enough.
+            scrollPosition: null,
+            triggeredBy: 'vike',
+            _isVikeEnhanced: true
+        };
+        // Calling the monkey patched history.pushState() (and not the orignal) so that other tools (e.g. user tracking) can listen to Vike's pushState() calls.
+        // - https://github.com/vikejs/vike/issues/1582
+        window.history.pushState(state, '', url);
     }
     else {
-        replaceHistoryState(getHistoryState(), url);
-    }
-}
-function assertState(state) {
-    assert(isObject(state));
-    if ('timestamp' in state) {
-        const { timestamp } = state;
-        assert(typeof timestamp === 'number');
-    }
-    if ('scrollPosition' in state) {
-        const { scrollPosition } = state;
-        if (scrollPosition !== null) {
-            assert(hasProp(scrollPosition, 'x', 'number') && hasProp(scrollPosition, 'y', 'number'));
-        }
+        replaceHistoryState(getState(), url);
     }
 }
 function replaceHistoryState(state, url) {
     const url_ = url ?? null; // Passing `undefined` chokes older Edge versions.
     window.history.replaceState(state, '', url_);
 }
-function pushHistoryState(state, url) {
-    // Vike should call window.history.pushState() (and not the orignal `pushStateOriginal()`) so that other tools (e.g. user tracking) can listen to Vike's pushState() calls, see https://github.com/vikejs/vike/issues/1582.
-    window.history.pushState(state, '', url);
+// Monkey patch:
+// - history.pushState()
+// - history.replaceState()
+function monkeyPatchHistoryAPI() {
+    ;
+    ['pushState', 'replaceState'].forEach((funcName) => {
+        const funcOriginal = window.history[funcName].bind(window.history);
+        window.history[funcName] = (stateOriginal = {}, ...rest) => {
+            assertUsage(stateOriginal === undefined || stateOriginal === null || isObject(stateOriginal), `history.${funcName}(state) argument state must be an object`);
+            const stateEnhanced = isVikeEnhanced(stateOriginal)
+                ? stateOriginal
+                : {
+                    _isVikeEnhanced: true,
+                    scrollPosition: getScrollPosition(),
+                    timestamp: getTimestamp(),
+                    triggeredBy: 'user',
+                    ...stateOriginal
+                };
+            assert(isVikeEnhanced(stateEnhanced));
+            const ret = funcOriginal(stateEnhanced, ...rest);
+            globalObject.previous = getHistoryInfo();
+            return ret;
+        };
+    });
 }
-function monkeyPatchHistoryPushState() {
-    const pushStateOriginal = window.history.pushState.bind(window.history);
-    window.history.pushState = (stateOriginal = {}, ...rest) => {
-        assertUsage(stateOriginal === undefined || stateOriginal === null || isObject(stateOriginal), 'history.pushState(state) argument state must be an object');
-        const stateEnhanced = isVikeEnhanced(stateOriginal)
-            ? stateOriginal
-            : {
-                _isVikeEnhanced: true,
-                scrollPosition: getScrollPosition(),
-                timestamp: getTimestamp(),
-                triggeredBy: 'user',
-                ...stateOriginal
-            };
-        return pushStateOriginal(stateEnhanced, ...rest);
+function isVikeEnhanced(state) {
+    const yes = isObject(state) && '_isVikeEnhanced' in state;
+    if (yes)
+        assertStateVikeEnhanced(state);
+    return yes;
+}
+function assertStateVikeEnhanced(state) {
+    assert(isObject(state));
+    assert(hasProp(state, '_isVikeEnhanced', 'true'));
+    // TODO/eventually: remove assert() below to save client-side KBs
+    assert(hasProp(state, 'timestamp', 'number'));
+    assert(hasProp(state, 'scrollPosition'));
+    if (state.scrollPosition !== null) {
+        assert(hasProp(state, 'scrollPosition', 'object'));
+        assert(hasProp(state.scrollPosition, 'x', 'number') && hasProp(state.scrollPosition, 'y', 'number'));
+    }
+}
+function init() {
+    enhanceHistoryState();
+    monkeyPatchHistoryAPI();
+}
+function getHistoryInfo() {
+    return {
+        url: getCurrentUrl(),
+        state: getState()
     };
 }
-function isVikeEnhanced(state) {
-    return isObject(state) && '_isVikeEnhanced' in state;
+function onPopStateBegin() {
+    const { previous } = globalObject;
+    const isNewState = window.history.state === null;
+    if (isNewState)
+        enhanceHistoryState();
+    const current = getHistoryInfo();
+    globalObject.previous = current;
+    return { isNewState, previous, current };
 }

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

@@ -1,5 +1,6 @@
 export { navigate, reload } from './navigate.js';
 export { prefetch } from './prefetch.js';
+export { onPopState } from './initOnPopState.js';
 export { PROJECT_VERSION as version } from './utils.js';
 import type { PageContextBuiltInClientWithClientRouting } from '../../shared/types.js';
 /** @deprecated

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

@@ -5,4 +5,5 @@
 // Use package.json#exports to make the imports isomorphic.
 export { navigate, reload } from './navigate.js';
 export { prefetch } from './prefetch.js';
+export { onPopState } from './initOnPopState.js';
 export { PROJECT_VERSION as version } from './utils.js';

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

@@ -1,8 +1,7 @@
 export { initClientRouter };
 import { assert } from './utils.js';
-import { initHistoryState, monkeyPatchHistoryPushState } from './history.js';
 import { getRenderCount, renderPageClientSide } from './renderPageClientSide.js';
-import { onBrowserHistoryNavigation } from './onBrowserHistoryNavigation.js';
+import { initOnPopState } from './initOnPopState.js';
 import { initOnLinkClick } from './initOnLinkClick.js';
 import { setupNativeScrollRestoration } from './scrollRestoration.js';
 import { autoSaveScrollPosition } from './setScrollPosition.js';
@@ -29,9 +28,7 @@ async function renderFirstPage() {
 }
 function initHistoryAndScroll() {
     setupNativeScrollRestoration();
-    initHistoryState();
     autoSaveScrollPosition();
-    monkeyPatchHistoryPushState();
     // Handle back-/forward navigation
-    onBrowserHistoryNavigation();
+    initOnPopState();
 }

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

@@ -0,0 +1,12 @@
+export { initOnPopState };
+export { onPopState };
+import { type HistoryInfo } from './history.js';
+declare function initOnPopState(): void;
+type Listener = (arg: {
+    previous: HistoryInfo;
+}) => void | boolean;
+/** Control back-/forward navigation.
+ *
+ * https://vike.dev/onPopState
+ */
+declare function onPopState(listener: Listener): void;