vike 0.4.247-commit-c3d567b → 0.4.247-commit-9b74d50

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

@@ -5,11 +5,14 @@ export { saveScrollPosition };
 export { initHistory };
 export type { HistoryInfo };
 export type { ScrollPosition };
-type StateEnhanced = {
+type VikeHistoryData = {
     timestamp: number;
     scrollPosition: null | ScrollPosition;
     triggeredBy: 'user' | 'vike' | 'browser';
-    _isVikeEnhanced: true;
+};
+type StateEnhanced = {
+    _isVikeEnhanced: VikeHistoryData;
+    [key: string]: unknown;
 };
 type ScrollPosition = {
     x: number;

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

@@ -4,7 +4,7 @@ export { onPopStateBegin };
 export { saveScrollPosition };
 export { initHistory };
 import { getCurrentUrl } from '../shared/getCurrentUrl.js';
-import { assert, assertUsage, getGlobalObject, isObject, deepEqual, cast, redirectHard } from './utils.js';
+import { assert, assertUsage, getGlobalObject, isObject, deepEqual, redirectHard } from './utils.js';
 const globalObject = getGlobalObject('history.ts', {
     monkeyPatched: false,
     previous: undefined,
@@ -28,20 +28,36 @@ function enhance(stateNotEnhanced) {
     let stateVikeEnhanced;
     if (!stateNotEnhanced) {
         stateVikeEnhanced = {
-            timestamp,
-            scrollPosition,
-            triggeredBy,
-            _isVikeEnhanced: true,
+            _isVikeEnhanced: {
+                timestamp,
+                scrollPosition,
+                triggeredBy,
+            },
         };
     }
     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`.)
-        cast(stateNotEnhanced);
+        let oldVikeData;
+        if (isObject(stateNotEnhanced) && '_isVikeEnhanced' in stateNotEnhanced) {
+            if (isObject(stateNotEnhanced._isVikeEnhanced)) {
+                // New format: _isVikeEnhanced is an object with nested properties
+                oldVikeData = stateNotEnhanced._isVikeEnhanced;
+            }
+            else {
+                // Old format: _isVikeEnhanced is true, properties are on state root
+                oldVikeData = stateNotEnhanced;
+            }
+        }
+        else {
+            oldVikeData = {};
+        }
         stateVikeEnhanced = {
-            timestamp: stateNotEnhanced.timestamp ?? timestamp,
-            scrollPosition: stateNotEnhanced.scrollPosition ?? scrollPosition,
-            triggeredBy: stateNotEnhanced.triggeredBy ?? triggeredBy,
-            _isVikeEnhanced: true,
+            ...stateNotEnhanced,
+            _isVikeEnhanced: {
+                timestamp: oldVikeData.timestamp ?? timestamp,
+                scrollPosition: oldVikeData.scrollPosition ?? scrollPosition,
+                triggeredBy: oldVikeData.triggeredBy ?? triggeredBy,
+            },
         };
     }
     assertIsVikeEnhanced(stateVikeEnhanced);
@@ -71,16 +87,17 @@ function saveScrollPosition() {
     if (!isVikeEnhanced(window.history.state))
         return;
     const state = getState();
-    replaceHistoryState({ ...state, scrollPosition });
+    replaceHistoryState({ ...state, _isVikeEnhanced: { ...state._isVikeEnhanced, scrollPosition } });
 }
 function pushHistoryState(url, overwriteLastHistoryEntry) {
     if (!overwriteLastHistoryEntry) {
         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 renderPageClient() is finished and the browser updating the scroll position.) Anyways, it seems like autoSaveScrollPosition() is enough.
-            scrollPosition: null,
-            triggeredBy: 'vike',
-            _isVikeEnhanced: true,
+            _isVikeEnhanced: {
+                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 renderPageClient() is finished and the browser updating the scroll position.) Anyways, it seems like autoSaveScrollPosition() is enough.
+                scrollPosition: null,
+                triggeredBy: 'vike',
+            },
         };
         // Calling the monkey patched history.pushState() (and not the original) so that other tools (e.g. user tracking) can listen to Vike's pushState() calls.
         // - https://github.com/vikejs/vike/issues/1582
@@ -114,37 +131,43 @@ function monkeyPatchHistoryAPI() {
             const stateEnhanced = isVikeEnhanced(stateOriginal)
                 ? stateOriginal
                 : {
-                    _isVikeEnhanced: true,
-                    scrollPosition: getScrollPosition(),
-                    timestamp: getTimestamp(),
-                    triggeredBy: 'user',
                     ...stateOriginal,
+                    _isVikeEnhanced: {
+                        scrollPosition: getScrollPosition(),
+                        timestamp: getTimestamp(),
+                        triggeredBy: 'user',
+                        ...stateOriginal?._isVikeEnhanced,
+                    },
                 };
             assertIsVikeEnhanced(stateEnhanced);
             funcOriginal(stateEnhanced, ...rest);
-            assert(deepEqual(stateEnhanced, window.history.state));
+            assert(isEqual(stateEnhanced, window.history.state));
             globalObject.previous = getHistoryInfo();
             // Workaround https://github.com/vikejs/vike/issues/2504#issuecomment-3149764736
             queueMicrotask(() => {
-                if (deepEqual(stateEnhanced, window.history.state))
+                if (isEqual(stateEnhanced, window.history.state))
                     return;
                 Object.assign(stateEnhanced, window.history.state);
                 assertIsVikeEnhanced(stateEnhanced);
                 replaceHistoryStateOriginal(stateEnhanced, rest[1]);
-                assert(deepEqual(stateEnhanced, window.history.state));
+                assert(isEqual(stateEnhanced, window.history.state));
             });
         };
     });
 }
+function isEqual(state1, state2) {
+    return isObject(state1) && isObject(state2) && deepEqual(state1._isVikeEnhanced, state2._isVikeEnhanced);
+}
 function isVikeEnhanced(state) {
     if (isObject(state) && '_isVikeEnhanced' in state) {
         /* We don't use the assert() below to save client-side KBs.
-        assert(hasProp(state, '_isVikeEnhanced', 'true'))
-        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'))
+        const vikeData = state._isVikeEnhanced
+        assert(isObject(vikeData))
+        assert(hasProp(vikeData, 'timestamp', 'number'))
+        assert(hasProp(vikeData, 'scrollPosition'))
+        if (vikeData.scrollPosition !== null) {
+          assert(hasProp(vikeData, 'scrollPosition', 'object'))
+          assert(hasProp(vikeData.scrollPosition, 'x', 'number') && hasProp(vikeData.scrollPosition, 'y', 'number'))
         }
         //*/
         return true;

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

@@ -37,16 +37,18 @@ async function onPopState() {
     await handleHistoryNavigation(previous, current);
 }
 async function handleHistoryNavigation(previous, current) {
-    const scrollTarget = current.state.scrollPosition || undefined;
+    const scrollTarget = current.state._isVikeEnhanced.scrollPosition || undefined;
     const isHashNavigation = removeHash(current.url) === removeHash(previous.url) && current.url !== previous.url;
     if (isHashNavigation) {
         // We have to scroll ourselves because we have set `window.history.scrollRestoration = 'manual'`
         setScrollPosition(scrollTarget);
         return;
     }
-    const isUserPushStateNavigation = current.state.triggeredBy === 'user' || previous.state.triggeredBy === 'user';
+    const isUserPushStateNavigation = current.state._isVikeEnhanced.triggeredBy === 'user' || previous.state._isVikeEnhanced.triggeredBy === 'user';
     const doNotRenderIfSamePage = isUserPushStateNavigation;
-    const isBackwardNavigation = !current.state.timestamp || !previous.state.timestamp ? null : current.state.timestamp < previous.state.timestamp;
+    const isBackwardNavigation = !current.state._isVikeEnhanced.timestamp || !previous.state._isVikeEnhanced.timestamp
+        ? null
+        : current.state._isVikeEnhanced.timestamp < previous.state._isVikeEnhanced.timestamp;
     await renderPageClient({ scrollTarget, isBackwardNavigation, doNotRenderIfSamePage, isHistoryNavigation: true });
 }
 function removeHash(url) {

package/dist/node/vite/plugins/build/pluginModuleBanner.js

@@ -5,29 +5,31 @@ import { getMagicString } from '../../shared/getMagicString.js';
 // But, anyways, we want to prepend the banner at the beginning of each module, not at the beginning of each file (I believe that's what Rollup's banner feature does).
 function pluginModuleBanner() {
     let config;
+    let isEnabled = false;
     return [
         {
             name: 'vike:build:pluginModuleBanner',
             enforce: 'post',
             apply: 'build',
             applyToEnvironment(environment) {
-                const { config } = environment;
-                const { consumer } = config;
-                const { minify } = config.build;
-                assert(minify === false || minify, { minify, consumer });
-                return !minify;
+                return checkIsEnabled(environment.config);
             },
             configResolved: {
                 handler(config_) {
                     config = config_;
+                    isEnabled = checkIsEnabled(config);
                 },
             },
             transform: {
                 order: 'post',
-                /* Using a Rolldown hook filter doesn't make sense here: we apply this transformer to each module. But we use applyToEnvironment() to conditionally apply this plugin.
-                filter: {},
-                */
+                filter: {
+                    get id() {
+                        return isEnabled ? undefined : 'this-module-id-does-not-exist-and-never-matches-any-module';
+                    },
+                },
                 handler(code, id) {
+                    if (!isEnabled)
+                        return undefined;
                     const { minify } = this.environment.config.build;
                     assert(minify === false, { minify });
                     if (id.startsWith('\0'))
@@ -47,3 +49,13 @@ function pluginModuleBanner() {
         },
     ];
 }
+function checkIsEnabled(config) {
+    const { minify } = config.build;
+    assert(minify === false || minify, { minify });
+    const isEnabled = !minify;
+    // Avoid the legal comments inserted in the transform() hook to be removed.
+    // https://github.com/vitejs/vite/issues/21085#issuecomment-3502781005
+    if (isEnabled && config.esbuild)
+        config.esbuild.legalComments = 'inline';
+    return isEnabled;
+}

package/dist/node/vite/plugins/pluginReplaceConstantsGlobalThis.d.ts

@@ -1,4 +1,5 @@
 export { pluginReplaceConstantsGlobalThis };
+export { VIRTUAL_FILE_ID_constantsGlobalThis };
 export type _LoadDeclareGlobal__VIKE__IS = never;
 import type { Plugin } from 'vite';
 declare global {
@@ -8,4 +9,5 @@ declare global {
     var __VIKE__IS_CLIENT: boolean;
     var __VIKE__IS_DEBUG: boolean;
 }
+declare const VIRTUAL_FILE_ID_constantsGlobalThis = "virtual:vike:server:constantsGlobalThis";
 declare function pluginReplaceConstantsGlobalThis(): Plugin[];

package/dist/node/vite/plugins/pluginReplaceConstantsGlobalThis.js

@@ -1,16 +1,17 @@
 export { pluginReplaceConstantsGlobalThis };
+export { VIRTUAL_FILE_ID_constantsGlobalThis };
 import { assert, isDebug, addVirtualFileIdPrefix, escapeRegex } from '../utils.js';
 import { isViteServerSide_applyToEnvironment, isViteServerSide_configEnvironment, isViteServerSide_extraSafe, } from '../shared/isViteServerSide.js';
 const isDebugVal = isDebug();
 globalThis.__VIKE__IS_CLIENT = false;
 globalThis.__VIKE__IS_DEBUG = isDebugVal;
-const VIRTUAL_FILE_ID = 'virtual:vike:server:globalThis-constants';
+const VIRTUAL_FILE_ID_constantsGlobalThis = 'virtual:vike:server:constantsGlobalThis';
 const filterRolldown = {
     id: {
-        include: new RegExp(escapeRegex(VIRTUAL_FILE_ID)),
+        include: new RegExp(escapeRegex(VIRTUAL_FILE_ID_constantsGlobalThis)),
     },
 };
-const filterFunction = (id) => id === VIRTUAL_FILE_ID || id === addVirtualFileIdPrefix(VIRTUAL_FILE_ID);
+const filterFunction = (id) => id === VIRTUAL_FILE_ID_constantsGlobalThis || id === addVirtualFileIdPrefix(VIRTUAL_FILE_ID_constantsGlobalThis);
 function pluginReplaceConstantsGlobalThis() {
     let config;
     let isDev;
@@ -54,7 +55,7 @@ function pluginReplaceConstantsGlobalThis() {
                 filter: filterRolldown,
                 handler(id) {
                     assert(filterFunction(id));
-                    assert(id === VIRTUAL_FILE_ID);
+                    assert(id === VIRTUAL_FILE_ID_constantsGlobalThis);
                     return addVirtualFileIdPrefix(id);
                 },
             },

package/dist/node/vite/plugins/pluginVirtualFiles/generateVirtualFileGlobalEntry.js

@@ -3,6 +3,7 @@ import { generateVirtualFileId } from '../../../../shared-server-node/virtualFil
 import { debug } from './debug.js';
 import { getVikeConfigInternal } from '../../shared/resolveVikeConfigInternal.js';
 import { serializeConfigValues, } from '../../../../shared-server-client/page-configs/serialize/serializeConfigValues.js';
+import { VIRTUAL_FILE_ID_constantsGlobalThis } from '../pluginReplaceConstantsGlobalThis.js';
 async function generateVirtualFileGlobalEntry(isForClientSide, isDev, id, isClientRouting) {
     const vikeConfig = await getVikeConfigInternal(true);
     const { _pageConfigs: pageConfigs, _pageConfigGlobal: pageConfigGlobal } = vikeConfig;
@@ -13,7 +14,7 @@ function getCode(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, isCl
     const importStatements = [];
     const filesEnv = new Map();
     if (!isForClientSide) {
-        importStatements.push("import 'virtual:vike:server:globalThis-constants';");
+        importStatements.push(`import '${VIRTUAL_FILE_ID_constantsGlobalThis}';`);
     }
     lines.push('export const pageConfigsSerialized = [');
     lines.push(getCodePageConfigsSerialized(pageConfigs, isForClientSide, isClientRouting, isDev, importStatements, filesEnv));
@@ -27,7 +28,7 @@ function getCode(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, isCl
     }
     let code = [...importStatements, ...lines].join('\n');
     if (!isForClientSide) {
-        code = "import 'virtual:vike:server:globalThis-constants';\n" + code;
+        code = `import '${VIRTUAL_FILE_ID_constantsGlobalThis}';\n` + code;
     }
     debug(id, isForClientSide ? 'CLIENT-SIDE' : 'SERVER-SIDE', code);
     return code;

package/dist/node/vite/plugins/pluginVirtualFiles/generateVirtualFileGlobalEntryWithOldDesign.js

@@ -9,6 +9,7 @@ import { getVikeConfigInternal, isV1Design as isV1Design_ } from '../../shared/r
 import { getOutDirs } from '../../shared/getOutDirs.js';
 import { isViteServerSide_extraSafe } from '../../shared/isViteServerSide.js';
 import { resolveIncludeAssetsImportedByServer } from '../../../../server/runtime/renderPageServer/getPageAssets/retrievePageAssetsProd.js';
+import { VIRTUAL_FILE_ID_constantsGlobalThis } from '../pluginReplaceConstantsGlobalThis.js';
 async function generateVirtualFileGlobalEntryWithOldDesign(id, options, config, env, isDev) {
     const idParsed = parseVirtualFileId(id);
     assert(idParsed && idParsed.type === 'global-entry');
@@ -24,7 +25,7 @@ async function getCode(config, isForClientSide, isClientRouting, isDev, id) {
     assert(isDev === !isBuild);
     let content = '';
     if (!isForClientSide) {
-        content += "import 'virtual:vike:server:globalThis-constants';\n";
+        content += `import '${VIRTUAL_FILE_ID_constantsGlobalThis}';\n`;
     }
     {
         const globRoots = getGlobRoots(config);

package/dist/utils/PROJECT_VERSION.d.ts

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.247-commit-c3d567b";
+export declare const PROJECT_VERSION: "0.4.247-commit-9b74d50";

package/dist/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.247-commit-c3d567b';
+export const PROJECT_VERSION = '0.4.247-commit-9b74d50';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.247-commit-c3d567b",
+  "version": "0.4.247-commit-9b74d50",
   "repository": "https://github.com/vikejs/vike",
   "exports": {
     "./server": {