vike 0.4.199 → 0.4.200

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

@@ -88,7 +88,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

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';

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;

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

@@ -0,0 +1,72 @@
+export { initOnPopState };
+export { onPopState };
+import { assertWarning, getGlobalObject } from './utils.js';
+import { onPopStateBegin } from './history.js';
+import { renderPageClientSide } from './renderPageClientSide.js';
+import { setScrollPosition } from './setScrollPosition.js';
+const globalObject = getGlobalObject('initOnPopState.ts', { listeners: [] });
+function initOnPopState() {
+    // - 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.
+    //     - Click on `<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)
+    //     - `location.hash = 'some-hash'`
+    // - The `event` argument 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', async () => {
+        const { isNewState, previous, current } = onPopStateBegin();
+        const scrollTarget = current.state.scrollPosition || undefined;
+        const isUserPushStateNavigation = current.state.triggeredBy === 'user' || previous.state.triggeredBy === 'user';
+        const isHashNavigation = removeHash(current.url) === removeHash(previous.url) && current.url !== previous.url;
+        // - `isNewState === true` when:
+        //   - Click on `<a href="#some-hash" />` (note that Vike's `initOnLinkClick()` handler skips hash links)
+        //   - `location.hash = 'some-hash'`
+        // - `isNewState === false` when `popstate` was triggered by the user clicking on his browser's forward/backward history button.
+        const isHashNavigationNew = isHashNavigation && isNewState;
+        const isBackwardNavigation = !current.state.timestamp || !previous.state.timestamp ? null : current.state.timestamp < previous.state.timestamp;
+        // We have to scroll ourselves because we use `window.history.scrollRestoration = 'manual'`. So far this seems to work. Alternatives in case it doesn't work:
+        // - Alternative: we use `window.history.scrollRestoration = 'auto'`
+        //   - Problem: I don't think it's possbible to set `window.history.scrollRestoration = 'auto'` only for hash navigation and not for non-hash navigations?
+        //   - Problem: inconsistencies between browsers? For example specification says that setting `window.history.scrollRestoration` only affects the current entry in the session history but this contradicts what people are experiencing in practice.
+        //     - Specification: https://html.spec.whatwg.org/multipage/history.html#the-history-interface
+        //     - Practice: https://stackoverflow.com/questions/70188241/history-scrollrestoration-manual-doesnt-prevent-safari-from-restoring-scrol
+        // - Alternative: we completely take over hash navigation and reproduce the browser's native behavior upon hash navigation.
+        //   - By using the `hashchange` event.
+        //   - Problem: conflict if 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.
+        if (isHashNavigation) {
+            if (!isHashNavigationNew) {
+                setScrollPosition(scrollTarget);
+            }
+            else {
+                // The browser already scrolled to `#${hash}` => the current scroll position is the right one => we saved it with `enhanceHistoryState()`.
+            }
+            return;
+        }
+        let doNotRenderIfSamePage = isUserPushStateNavigation;
+        let abort;
+        globalObject.listeners.forEach((listener) => {
+            abort || (abort = listener({ previous }));
+        });
+        if (abort) {
+            return;
+        }
+        if (abort === false) {
+            doNotRenderIfSamePage = false;
+        }
+        await renderPageClientSide({ scrollTarget, isBackwardNavigation, doNotRenderIfSamePage });
+    });
+}
+// TODO/eventually: deprecate this onPopState(listener) function and let the user define +onPopState.js instead?
+/** Control back-/forward navigation.
+ *
+ * https://vike.dev/onPopState
+ */
+function onPopState(listener) {
+    assertWarning(false, 'onPopState() is experimental', { onlyOnce: true });
+    globalObject.listeners.push(listener);
+}
+function removeHash(url) {
+    return url.split('#')[0];
+}

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

@@ -12,8 +12,7 @@ type RenderArgs = {
     overwriteLastHistoryEntry?: boolean;
     pageContextsFromRewrite?: PageContextFromRewrite[];
     redirectCount?: number;
-    /** Whether the navigation was triggered by the user land calling `history.pushState()` */
-    isUserLandPushStateNavigation?: boolean;
+    doNotRenderIfSamePage?: boolean;
     isClientSideNavigation?: boolean;
 };
 declare function renderPageClientSide(renderArgs: RenderArgs): Promise<void>;

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

@@ -10,12 +10,11 @@ import { assertInfo, assertWarning, isReact } from './utils.js';
 import { executeOnRenderClientHook } from '../shared/executeOnRenderClientHook.js';
 import { assertHook, getHook } from '../../shared/hooks/getHook.js';
 import { isErrorFetchingStaticAssets, loadUserFilesClientSide } from '../shared/loadUserFilesClientSide.js';
-import { pushHistory } from './history.js';
+import { pushHistoryState } from './history.js';
 import { assertNoInfiniteAbortLoop, getPageContextFromAllRewrites, isAbortError, logAbortErrorHandled } from '../../shared/route/abort.js';
 import { route } from '../../shared/route/index.js';
 import { isClientSideRoutable } from './isClientSideRoutable.js';
 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';
@@ -30,7 +29,7 @@ const globalObject = getGlobalObject('renderPageClientSide.ts', (() => {
 })());
 const { firstRenderStartPromise } = globalObject;
 async function renderPageClientSide(renderArgs) {
-    const { urlOriginal = getCurrentUrl(), overwriteLastHistoryEntry = false, isBackwardNavigation, pageContextsFromRewrite = [], redirectCount = 0, isUserLandPushStateNavigation, isClientSideNavigation = true } = renderArgs;
+    const { urlOriginal = getCurrentUrl(), overwriteLastHistoryEntry = false, isBackwardNavigation, pageContextsFromRewrite = [], redirectCount = 0, doNotRenderIfSamePage, isClientSideNavigation = true } = renderArgs;
     let { scrollTarget } = renderArgs;
     const { previousPageContext } = globalObject;
     addLinkPrefetchHandlers_unwatch();
@@ -120,7 +119,7 @@ async function renderPageClientSide(renderArgs) {
             const isSamePage = pageContextFromRoute.pageId &&
                 previousPageContext?.pageId &&
                 pageContextFromRoute.pageId === previousPageContext.pageId;
-            if (isUserLandPushStateNavigation && isSamePage) {
+            if (doNotRenderIfSamePage && isSamePage) {
                 // Skip's Vike's rendering; let the user handle the navigation
                 return;
             }
@@ -476,8 +475,7 @@ function changeUrl(url, overwriteLastHistoryEntry) {
     if (getCurrentUrl() === url)
         return;
     browserNativeScrollRestoration_disable();
-    pushHistory(url, overwriteLastHistoryEntry);
-    updateState();
+    pushHistoryState(url, overwriteLastHistoryEntry);
 }
 function handleErrorFetchingStaticAssets(err, pageContext, isFirstRender) {
     if (!isErrorFetchingStaticAssets(err)) {

package/dist/esm/node/client/router.d.ts

@@ -1,6 +1,8 @@
 export { navigate };
 export { reload };
 export { prefetch };
+export { onPopState };
 declare const navigate: never;
 declare const reload: never;
 declare const prefetch: never;
+declare const onPopState: never;

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

@@ -1,11 +1,13 @@
 export { navigate };
 export { reload };
 export { prefetch };
+export { onPopState };
 import { assertWarning } from '../../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'));
 const reload = (() => warnNoEffect('reload'));
 const prefetch = (() => warnNoEffect('prefetch'));
+const onPopState = (() => { });
 function warnNoEffect(caller) {
     assertWarning(false, `Calling ${caller}() on the server-side has no effect`, {
         showStackTrace: true,

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

@@ -3,6 +3,7 @@ import { loadEnv } from 'vite';
 import { assert, assertPosixPath, assertUsage, assertWarning, escapeRegex, isArray, lowerFirst } from '../utils.js';
 import { sourceMapPassthrough } from '../shared/rollupSourceMap.js';
 import { getModuleFilePathAbsolute } from '../shared/getFilePath.js';
+import { normalizeId } from '../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
@@ -25,9 +26,11 @@ function envVarsPlugin() {
             config.plugins.sort(lowerFirst((plugin) => (plugin.name === 'vite:define' ? 1 : 0)));
         },
         transform(code, id, options) {
+            id = normalizeId(id);
             assertPosixPath(id);
             if (id.includes('/node_modules/'))
                 return;
+            assertPosixPath(config.root);
             if (!id.startsWith(config.root))
                 return;
             if (!code.includes('import.meta.env.'))

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

@@ -16,6 +16,7 @@ import pc from '@brillout/picocolors';
 import { fixServerAssets_isEnabled } from './buildConfig/fixServerAssets.js';
 import { getVikeConfig, isV1Design } from './importUserCode/v1-design/getVikeConfig.js';
 import { assertV1Design } from '../../shared/assertV1Design.js';
+import { normalizeId } from '../shared/normalizeId.js';
 const extractAssetsRE = /(\?|&)extractAssets(?:&|$)/;
 const rawRE = /(\?|&)raw(?:&|$)/;
 const urlRE = /(\?|&)url(?:&|$)/;
@@ -34,6 +35,7 @@ function extractAssetsPlugin() {
             apply: 'build',
             enforce: 'post',
             async transform(src, id, options) {
+                id = normalizeId(id);
                 if (!extractAssetsRE.test(id)) {
                     return;
                 }

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

@@ -4,6 +4,7 @@ export { extractExportNamesRE };
 import { assert, getFileExtension, viteIsSSR_options, createDebugger, getGlobalObject, assertUsage } from '../utils.js';
 import { getExportNames } from '../shared/parseEsModule.js';
 import { sourceMapRemove } from '../shared/rollupSourceMap.js';
+import { normalizeId } from '../shared/normalizeId.js';
 const extractExportNamesRE = /(\?|&)extractExportNames(?:&|$)/;
 const debug = createDebugger('vike:extractExportNames');
 const globalObject = getGlobalObject('extractExportNamesPlugin.ts', {});
@@ -13,6 +14,7 @@ function extractExportNamesPlugin() {
         name: 'vike:extractExportNames',
         enforce: 'post',
         async transform(src, id, options) {
+            id = normalizeId(id);
             const isClientSide = !viteIsSSR_options(options);
             if (extractExportNamesRE.test(id)) {
                 const code = await getExtractExportNamesCode(src, isClientSide, !isDev, id);

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

@@ -6,6 +6,7 @@ import pc from '@brillout/picocolors';
 import { getModuleFilePathAbsolute } from '../shared/getFilePath.js';
 import { sourceMapRemove } from '../shared/rollupSourceMap.js';
 import { getExportNames } from '../shared/parseEsModule.js';
+import { normalizeId } from '../shared/normalizeId.js';
 function fileEnv() {
     let config;
     let viteDevServer;
@@ -31,6 +32,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 = normalizeId(id);
             // In dev, only using load() is enough as it also works for dynamic imports (see sibling comment).
             if (viteDevServer)
                 return;

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

@@ -1,6 +1,6 @@
 export { importBuild };
 export { set_ASSETS_MAP };
-import { serverEntryPlugin } from '@brillout/vite-plugin-server-entry/plugin';
+import { serverProductionEntryPlugin } from '@brillout/vite-plugin-server-entry/plugin';
 import { assert, getOutDirs, toPosixPath } from '../../utils.js';
 import path from 'path';
 import { createRequire } from 'module';
@@ -24,15 +24,15 @@ function importBuild() {
                 configVike = await getConfigVike(config);
             }
         },
-        ...serverEntryPlugin({
-            getImporterCode: () => {
-                return getEntryCode(config, configVike);
+        ...serverProductionEntryPlugin({
+            getServerProductionEntry: () => {
+                return getServerProductionEntryCode(config, configVike);
             },
             libraryName: 'Vike'
         })
     ];
 }
-function getEntryCode(config, configVike) {
+function getServerProductionEntryCode(config, configVike) {
     const importPath = getImportPath(config);
     const vikeManifest = getVikeManifest(configVike);
     const importerCode = [

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

@@ -6,7 +6,7 @@ import { getVirtualFileImportUserCode } from './getVirtualFileImportUserCode.js'
 import { assert, assertPosixPath, getOutDirs, getVirtualFileId, isDev3, isVirtualFileId, resolveVirtualFileId } from '../../utils.js';
 import { isVirtualFileIdPageConfigValuesAll } from '../../../shared/virtual-files/virtualFilePageConfigValuesAll.js';
 import { isVirtualFileIdImportUserCode } from '../../../shared/virtual-files/virtualFileImportUserCode.js';
-import { vikeConfigDependencies, reloadVikeConfig, isVikeConfigFile } from './v1-design/getVikeConfig.js';
+import { vikeConfigDependencies, reloadVikeConfig, isVikeConfigFile, isV1Design } from './v1-design/getVikeConfig.js';
 import pc from '@brillout/picocolors';
 import { logConfigInfo } from '../../shared/loggerNotProd.js';
 import { getModuleFilePathAbsolute } from '../../shared/getFilePath.js';
@@ -18,16 +18,17 @@ function importUserCode() {
         name: 'vike:importUserCode',
         config(_, env) {
             isDev = isDev3(env);
-            return {
-                experimental: {
-                    // TODO/v1-release: remove
-                    importGlobRestoreExtension: true
-                }
-            };
         },
         async configResolved(config_) {
             configVike = await getConfigVike(config_);
             config = config_;
+            // TODO/v1-release: remove
+            {
+                assert(isDev !== undefined);
+                const isV1 = await isV1Design(config, isDev);
+                if (!isV1)
+                    config.experimental.importGlobRestoreExtension = true;
+            }
         },
         resolveId(id) {
             if (isVirtualFileId(id)) {

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

@@ -83,7 +83,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

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

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

package/dist/esm/node/plugin/shared/normalizeId.d.ts

@@ -0,0 +1,2 @@
+export { normalizeId };
+declare function normalizeId(id: string): string;

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

@@ -0,0 +1,7 @@
+export { normalizeId };
+import { toPosixPath } from '../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 toPosixPath(id);
+}

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

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

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

@@ -1,6 +1,6 @@
 export { loadImportBuild };
 export { setImportBuildGetters };
-import { importServerEntry } from '@brillout/vite-plugin-server-entry/runtime';
+import { importServerProductionEntry } from '@brillout/vite-plugin-server-entry/runtime';
 import { assert } from '../utils.js';
 const buildGetters = (globalThis.__vike_buildGetters = globalThis.__vike_buildGetters || {
     getters: null
@@ -10,7 +10,7 @@ function setImportBuildGetters(getters) {
 }
 async function loadImportBuild(outDir) {
     if (!buildGetters.getters) {
-        await importServerEntry(outDir);
+        await importServerProductionEntry({ outDir });
         assert(buildGetters.getters);
     }
     const [pageFiles, assetsManifest, pluginManifest] = await Promise.all([

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

@@ -2,7 +2,7 @@ export { renderPage };
 export { renderPage_addWrapper };
 import { getRenderContext, getPageContextInitEnhanced, renderPageAlreadyRouted } from './renderPage/renderPageAlreadyRouted.js';
 import { route } from '../../shared/route/index.js';
-import { assert, hasProp, objectAssign, isUrl, parseUrl, assertEnv, assertWarning, getGlobalObject, checkType, assertUsage, normalizeUrlPathname, removeBaseServer, modifyUrlPathname, prependBase, removeUrlOrigin, addUrlOrigin, createUrlFromComponents, isUri, getUrlPretty } from './utils.js';
+import { assert, hasProp, objectAssign, isUrl, parseUrl, assertEnv, assertWarning, getGlobalObject, checkType, assertUsage, normalizeUrlPathname, removeBaseServer, modifyUrlPathname, prependBase, removeUrlOrigin, setUrlOrigin, createUrlFromComponents, isUri, getUrlPretty } from './utils.js';
 import { assertNoInfiniteAbortLoop, getPageContextFromAllRewrites, isAbortError, logAbortErrorHandled } from '../../shared/route/abort.js';
 import { getGlobalContext, initGlobalContext_renderPage } from './globalContext.js';
 import { handlePageContextRequestUrl } from './renderPage/handlePageContextRequestUrl.js';
@@ -374,19 +374,29 @@ function getPermanentRedirect(pageContextInit, httpRequestId) {
         urlTarget = urlTargetExternal;
     }
     else {
-        if (origin)
-            urlTarget = addUrlOrigin(urlTarget, origin);
-        if (urlTarget === urlWithoutBase)
+        let originChanged = false;
+        if (origin) {
+            const urlModified = setUrlOrigin(urlTarget, origin);
+            if (urlModified !== false) {
+                originChanged = true;
+                urlTarget = urlModified;
+            }
+        }
+        if (normalize(urlTarget) === normalize(urlWithoutBase))
             return null;
-        urlTarget = prependBase(urlTarget, baseServer);
+        if (!originChanged)
+            urlTarget = prependBase(urlTarget, baseServer);
         assert(urlTarget !== pageContextInit.urlOriginal);
     }
-    logRuntimeInfo?.(`Permanent redirect defined by your config.redirects (https://vike.dev/redirects)`, httpRequestId, 'info');
+    logRuntimeInfo?.(`Permanent redirection defined by config.redirects (https://vike.dev/redirects)`, httpRequestId, 'info');
     const httpResponse = createHttpResponseRedirect({ url: urlTarget, statusCode: 301 }, urlWithoutBase);
     const pageContextHttpResponse = createPageContext(pageContextInit);
     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/esm/utils/PROJECT_VERSION.d.ts

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.199";
+export declare const PROJECT_VERSION: "0.4.200";

package/dist/esm/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.199';
+export const PROJECT_VERSION = '0.4.200';

package/dist/esm/utils/getCurrentUrl.d.ts

@@ -1,4 +1,4 @@
 export { getCurrentUrl };
 declare function getCurrentUrl(options?: {
     withoutHash: true;
-}): string;
+}): `/${string}`;

package/dist/esm/utils/parseUrl-extras.d.ts

@@ -4,7 +4,7 @@ export { normalizeUrlPathname };
 export { removeBaseServer };
 export { modifyUrlPathname };
 export { removeUrlOrigin };
-export { addUrlOrigin };
+export { setUrlOrigin };
 export { getUrlPretty };
 declare function prependBase(url: string, baseServer: string): string;
 declare function removeBaseServer(url: string, baseServer: string): string;
@@ -15,5 +15,5 @@ declare function removeUrlOrigin(url: string): {
     urlModified: string;
     origin: string | null;
 };
-declare function addUrlOrigin(url: string, origin: string | null): string;
+declare function setUrlOrigin(url: string, origin: string | null): false | string;
 declare function getUrlPretty(url: string): string;

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

@@ -4,7 +4,7 @@ export { normalizeUrlPathname };
 export { removeBaseServer };
 export { modifyUrlPathname };
 export { removeUrlOrigin };
-export { addUrlOrigin };
+export { setUrlOrigin };
 export { getUrlPretty };
 import { assertUrlComponents, createUrlFromComponents, isBaseServer, parseUrl } from './parseUrl.js';
 import { assert } from './assert.js';
@@ -94,9 +94,10 @@ function removeUrlOrigin(url) {
     const urlModified = createUrlFromComponents(null, pathnameOriginal, searchOriginal, hashOriginal);
     return { urlModified, origin };
 }
-function addUrlOrigin(url, origin) {
+function setUrlOrigin(url, origin) {
     const { origin: originCurrent, pathnameOriginal, searchOriginal, hashOriginal } = parseUrl(url, '/');
-    assert(originCurrent === null);
+    if (origin === originCurrent)
+        return false;
     assert(origin === null || origin.startsWith('http'));
     const urlModified = createUrlFromComponents(origin, pathnameOriginal, searchOriginal, hashOriginal);
     return urlModified;

package/dist/esm/utils/projectInfo.d.ts

@@ -1,4 +1,4 @@
 export declare const projectInfo: {
     projectName: "Vike";
-    projectVersion: "0.4.199";
+    projectVersion: "0.4.200";
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.199",
+  "version": "0.4.200",
   "repository": "https://github.com/vikejs/vike",
   "exports": {
     "./server": {
@@ -125,14 +125,13 @@
     "@brillout/json-serializer": "^0.5.13",
     "@brillout/picocolors": "^1.0.15",
     "@brillout/require-shim": "^0.1.2",
-    "@brillout/vite-plugin-server-entry": "^0.4.11",
+    "@brillout/vite-plugin-server-entry": "^0.5.0",
     "acorn": "^8.0.0",
     "cac": "^6.0.0",
     "es-module-lexer": "^1.0.0",
     "esbuild": "^0.19.0 || ^0.20.0 || ^0.21.0 || ^0.22.0 || ^0.23.0",
     "fast-glob": "^3.0.0",
     "semver": "^7.0.0",
-    "sirv": "^2.0.0",
     "source-map-support": "^0.5.0"
   },
   "peerDependencies": {
@@ -232,16 +231,8 @@
     "@types/resolve": "^1.20.6",
     "@types/semver": "^7.5.8",
     "@types/source-map-support": "^0.5.10",
-    "acorn": "^8.11.2",
-    "cac": "^6.7.14",
-    "es-module-lexer": "^1.4.1",
-    "esbuild": "^0.23.0",
-    "fast-glob": "^3.3.2",
     "react-streaming": "^0.3.43",
     "rimraf": "^5.0.5",
-    "semver": "^7.6.3",
-    "sirv": "^2.0.4",
-    "source-map-support": "^0.5.21",
     "typescript": "^5.6.2",
     "vite": "^5.4.0"
   },

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

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

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

@@ -1,63 +0,0 @@
-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` argument 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', async () => {
-        const currentState = getState();
-        const scrollTarget = currentState.historyState.scrollPosition || undefined;
-        const isUserLandPushStateNavigation = currentState.historyState.triggeredBy === '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 `initOnLinkClick()` 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 {
-            await renderPageClientSide({ scrollTarget, isBackwardNavigation, isUserLandPushStateNavigation });
-        }
-    });
-}
-function getState() {
-    return {
-        urlWithoutHash: getCurrentUrl({ withoutHash: true }),
-        historyState: getHistoryState()
-    };
-}
-function updateState() {
-    globalObject.previousState = getState();
-}