vike 0.4.247-commit-dbcfa58 → 0.4.247-commit-87e5f2f

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

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

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

@@ -15,53 +15,17 @@ globalObject.previous = getHistoryInfo();
 // - The very first render
 // - Click on `<a href="#some-hash" />`
 // - `location.hash = 'some-hash'`
-function enhanceHistoryState() {
-    if (isVikeEnhanced(window.history.state))
+function enhance() {
+    if (isEnhanced(window.history.state))
         return;
-    const stateVikeEnhanced = enhance(window.history.state);
-    replaceHistoryState(stateVikeEnhanced);
-}
-function enhance(stateNotEnhanced) {
-    const timestamp = getTimestamp();
-    const scrollPosition = getScrollPosition();
-    const triggeredBy = 'browser';
-    let stateVikeEnhanced;
-    if (!stateNotEnhanced) {
-        stateVikeEnhanced = {
-            _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`.)
-        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 = {
-            ...stateNotEnhanced,
-            _isVikeEnhanced: {
-                timestamp: oldVikeData.timestamp ?? timestamp,
-                scrollPosition: oldVikeData.scrollPosition ?? scrollPosition,
-                triggeredBy: oldVikeData.triggeredBy ?? triggeredBy,
-            },
-        };
-    }
-    assertIsVikeEnhanced(stateVikeEnhanced);
-    return stateVikeEnhanced;
+    const stateEnhanced = {
+        vike: {
+            timestamp: getTimestamp(),
+            scrollPosition: getScrollPosition(),
+            triggeredBy: 'browser',
+        },
+    };
+    replaceHistoryState(stateEnhanced);
 }
 function getState() {
     const state = window.history.state;
@@ -70,7 +34,7 @@ function getState() {
     // - 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()
-    assertIsVikeEnhanced(state);
+    assertIsEnhanced(state);
     return state;
 }
 function getScrollPosition() {
@@ -84,15 +48,15 @@ function saveScrollPosition() {
     const scrollPosition = getScrollPosition();
     // Don't overwrite history.state if it was set by a non-Vike history.pushState() call.
     // https://github.com/vikejs/vike/issues/2801#issuecomment-3490431479
-    if (!isVikeEnhanced(window.history.state))
+    if (!isEnhanced(window.history.state))
         return;
     const state = getState();
-    replaceHistoryState({ ...state, _isVikeEnhanced: { ...state._isVikeEnhanced, scrollPosition } });
+    replaceHistoryState({ ...state, vike: { ...state.vike, scrollPosition } });
 }
 function pushHistoryState(url, overwriteLastHistoryEntry) {
     if (!overwriteLastHistoryEntry) {
         const state = {
-            _isVikeEnhanced: {
+            vike: {
                 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,
@@ -110,7 +74,7 @@ function pushHistoryState(url, overwriteLastHistoryEntry) {
 function replaceHistoryState(state, url) {
     const url_ = url ?? null; // Passing `undefined` chokes older Edge versions.
     window.history.replaceState(state, '', url_);
-    assertIsVikeEnhanced(window.history.state);
+    assertIsEnhanced(window.history.state);
 }
 function replaceHistoryStateOriginal(state, url) {
     // Bypass all monkey patches.
@@ -126,42 +90,42 @@ function monkeyPatchHistoryAPI() {
     globalObject.monkeyPatched = true;
     ['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
+        window.history[funcName] = (stateFromUser = {}, ...rest) => {
+            assertUsage(stateFromUser === undefined || stateFromUser === null || isObject(stateFromUser), `history.${funcName}(state) argument state must be an object`);
+            const state = isEnhanced(stateFromUser)
+                ? stateFromUser
                 : {
-                    ...stateOriginal,
-                    _isVikeEnhanced: {
+                    ...stateFromUser,
+                    vike: {
                         scrollPosition: getScrollPosition(),
                         timestamp: getTimestamp(),
                         triggeredBy: 'user',
-                        ...stateOriginal?._isVikeEnhanced,
                     },
                 };
-            assertIsVikeEnhanced(stateEnhanced);
-            funcOriginal(stateEnhanced, ...rest);
-            assert(isEqual(stateEnhanced, window.history.state));
+            assertIsEnhanced(state);
+            funcOriginal(state, ...rest);
+            // TO-DO/eventually remove excessive assertions to save client-side KBs
+            assert(isEqual(state, window.history.state));
             globalObject.previous = getHistoryInfo();
             // Workaround https://github.com/vikejs/vike/issues/2504#issuecomment-3149764736
             queueMicrotask(() => {
-                if (isEqual(stateEnhanced, window.history.state))
+                if (isEqual(state, window.history.state))
                     return;
-                Object.assign(stateEnhanced, window.history.state);
-                assertIsVikeEnhanced(stateEnhanced);
-                replaceHistoryStateOriginal(stateEnhanced, rest[1]);
-                assert(isEqual(stateEnhanced, window.history.state));
+                Object.assign(state, window.history.state);
+                assertIsEnhanced(state);
+                replaceHistoryStateOriginal(state, rest[1]);
+                assert(isEqual(state, window.history.state));
             });
         };
     });
 }
 function isEqual(state1, state2) {
-    return deepEqual(state1?._isVikeEnhanced, state2?._isVikeEnhanced);
+    return deepEqual(state1?.vike, state2?.vike);
 }
-function isVikeEnhanced(state) {
-    if (state?._isVikeEnhanced) {
+function isEnhanced(state) {
+    if (state?.vike) {
         /* We don't use the assert() below to save client-side KBs.
-        const vikeData = state._isVikeEnhanced
+        const vikeData = state.vike
         assert(isObject(vikeData))
         assert(hasProp(vikeData, 'timestamp', 'number'))
         assert(hasProp(vikeData, 'scrollPosition'))
@@ -174,8 +138,8 @@ function isVikeEnhanced(state) {
     }
     return false;
 }
-function assertIsVikeEnhanced(state) {
-    if (isVikeEnhanced(state))
+function assertIsEnhanced(state) {
+    if (isEnhanced(state))
         return;
     assert(false, { state });
 }
@@ -187,33 +151,32 @@ function getHistoryInfo() {
 }
 function onPopStateBegin() {
     const { previous } = globalObject;
-    const isHistoryStateEnhanced = isVikeEnhanced(window.history.state);
+    const isStateEnhanced = isEnhanced(window.history.state);
     // Either:
     // - `window.history.pushState(null, '', '/some-path')` , or
     // - hash navigation
     //   - Click on `<a href="#some-hash">`
     //   - Using the `location` API (only hash navigation)
     // See comments a the top of the ./initOnPopState.ts file.
-    const isHistoryStatePristine = window.history.state === null;
-    if (!isHistoryStateEnhanced && !isHistoryStatePristine) {
+    const isStatePristine = window.history.state === null;
+    if (!isStateEnhanced && !isStatePristine) {
         // Going to a history entry not created by Vike — entering another "SPA realm" => hard reload
         // https://github.com/vikejs/vike/issues/2801#issuecomment-3490431479
         redirectHard(getCurrentUrl());
         return { skip: true };
     }
-    if (!isHistoryStateEnhanced)
-        enhanceHistoryState();
-    assertIsVikeEnhanced(window.history.state);
+    if (!isStateEnhanced)
+        enhance();
     const current = getHistoryInfo();
     globalObject.previous = current;
     // Let the browser handle hash navigations.
     // - Upon hash navigation: `isHistoryStatePristine===true` (see comment above).
-    if (isHistoryStatePristine) {
+    if (isStatePristine) {
         return { skip: true };
     }
     return { previous, current };
 }
 function initHistory() {
     monkeyPatchHistoryAPI(); // the earlier we call it the better (Vike can workaround erroneous library monkey patches if Vike is the last one in the monkey patch chain)
-    enhanceHistoryState(); // enhance very first window.history.state which is `null`
+    enhance(); // enhance very first window.history.state which is `null`
 }

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

@@ -37,18 +37,18 @@ async function onPopState() {
     await handleHistoryNavigation(previous, current);
 }
 async function handleHistoryNavigation(previous, current) {
-    const scrollTarget = current.state._isVikeEnhanced.scrollPosition || undefined;
+    const scrollTarget = current.state.vike.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._isVikeEnhanced.triggeredBy === 'user' || previous.state._isVikeEnhanced.triggeredBy === 'user';
+    const isUserPushStateNavigation = current.state.vike.triggeredBy === 'user' || previous.state.vike.triggeredBy === 'user';
     const doNotRenderIfSamePage = isUserPushStateNavigation;
-    const isBackwardNavigation = !current.state._isVikeEnhanced.timestamp || !previous.state._isVikeEnhanced.timestamp
+    const isBackwardNavigation = !current.state.vike.timestamp || !previous.state.vike.timestamp
         ? null
-        : current.state._isVikeEnhanced.timestamp < previous.state._isVikeEnhanced.timestamp;
+        : current.state.vike.timestamp < previous.state.vike.timestamp;
     await renderPageClient({ scrollTarget, isBackwardNavigation, doNotRenderIfSamePage, isHistoryNavigation: true });
 }
 function removeHash(url) {

package/dist/node/api/dev.d.ts

@@ -1,4 +1,5 @@
 export { dev };
+export { startupLog };
 import { type ResolvedConfig, type ViteDevServer } from 'vite';
 import type { ApiOptions } from './types.js';
 /**
@@ -13,3 +14,8 @@ declare function dev(options?: ApiOptions & {
     viteConfig: ResolvedConfig;
     viteVersion: string;
 }>;
+declare function startupLog(resolvedUrls: ResolvedServerUrls, viteServer: ViteDevServer): Promise<void>;
+interface ResolvedServerUrls {
+    local: string[];
+    network: string[];
+}

package/dist/node/api/dev.js

@@ -1,8 +1,9 @@
 export { dev };
+// TO-DO/eventually: remove if it doesn't end up being used
+export { startupLog };
 import { prepareViteApiCall } from './prepareViteApiCall.js';
-import { createServer, version as viteVersionVike } from 'vite';
-import { viteVersionUser } from '../vite/plugins/pluginCommon.js';
-import { colorVike, colorVite, PROJECT_VERSION } from './utils.js';
+import { createServer } from 'vite';
+import { assert, colorVike, colorVite, PROJECT_VERSION } from './utils.js';
 import pc from '@brillout/picocolors';
 import { processStartupLog } from '../vite/shared/loggerVite.js';
 /**
@@ -11,23 +12,35 @@ import { processStartupLog } from '../vite/shared/loggerVite.js';
  * https://vike.dev/api#dev
  */
 async function dev(options = {}) {
-    const startTime = performance.now();
     const { viteConfigFromUserResolved } = await prepareViteApiCall(options, 'dev');
     const server = await createServer(viteConfigFromUserResolved);
-    const viteVersion = viteVersionUser ?? viteVersionVike;
     const viteServer = server;
     const viteConfig = server.config;
+    const viteVersion = viteConfig._viteVersionResolved;
+    assert(viteVersion);
     if (viteServer.httpServer)
         await viteServer.listen();
-    if (options.startupLog)
-        printStartupLog(viteServer, viteConfig, viteVersion, startTime);
+    if (options.startupLog) {
+        if (viteServer.resolvedUrls) {
+            startupLog(viteServer.resolvedUrls, viteServer);
+        }
+        else {
+            // TO-DO/eventually: remove if it doesn't end up being used
+            ;
+            viteConfig.server.startupLog = (resolvedUrls) => startupLog(resolvedUrls, viteServer);
+        }
+    }
     return {
         viteServer,
         viteConfig,
         viteVersion,
     };
 }
-async function printStartupLog(viteServer, viteConfig, viteVersion, startTime) {
+const startTime = performance.now();
+async function startupLog(resolvedUrls, viteServer) {
+    const viteConfig = viteServer.config;
+    const viteVersion = viteConfig._viteVersionResolved;
+    assert(viteVersion);
     const startupDurationString = pc.dim(`ready in ${pc.reset(pc.bold(String(Math.ceil(performance.now() - startTime))))} ms`);
     const sep = pc.dim('·');
     const firstLine = `\n  ${colorVike('Vike')} ${pc.yellow(`v${PROJECT_VERSION}`)} ${sep} ${colorVite('Vite')} ${pc.cyan(`v${viteVersion}`)} ${sep} ${startupDurationString}\n`;
@@ -36,7 +49,7 @@ async function printStartupLog(viteServer, viteConfig, viteVersion, startTime) {
     const { isCompact } = ret;
     // We don't call viteServer.printUrls() because Vite throws an error if `resolvedUrls` is missing:
     // https://github.com/vitejs/vite/blob/df5a30d2690a2ebc4824a79becdcef30538dc602/packages/vite/src/node/server/index.ts#L745
-    printServerUrls(viteServer.resolvedUrls || { local: ['http://localhost:3000'], network: [] }, viteConfig.server.host);
+    printServerUrls(resolvedUrls, viteConfig.server.host);
     viteServer.bindCLIShortcuts({ print: true });
     if (!isCompact)
         console.log();

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

@@ -1,8 +1,12 @@
 export { pluginModuleBanner };
 import { assert, removeVirtualFileIdPrefix } from '../../utils.js';
 import { getMagicString } from '../../shared/getMagicString.js';
-// Rollup's banner feature doesn't work with Vite: https://github.com/vitejs/vite/issues/8412
-// 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).
+// Misusing legal comments so that esbuild doesn't remove them.
+// - Legal comments: https://esbuild.github.io/api/#legal-comments
+// - Terser removes legal comments, but I guess users use terser to minify JavaScript so I guess it's a good thing that comment is removed.
+// - Rollup's banner feature doesn't work with Vite: https://github.com/vitejs/vite/issues/8412
+//   - 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).
+// - Potential alternative: https://github.com/vitejs/vite/issues/21228#issuecomment-3627899741
 function pluginModuleBanner() {
     let config;
     let isEnabled = false;
@@ -39,9 +43,6 @@ function pluginModuleBanner() {
                         id = id.slice(config.root.length + 1);
                     id = id.replaceAll('*/', '*\\/'); // https://github.com/vikejs/vike/issues/2377
                     const { magicString, getMagicStringResult } = getMagicString(code, id);
-                    // Use legal comment so that esbuild doesn't remove it.
-                    // - Terser still removes the comment, but I guess users use terser to minify JavaScript so I guess it's a good thing that comment is removed.
-                    // - https://esbuild.github.io/api/#legal-comments
                     magicString.prepend(`/*! ${id} [vike:pluginModuleBanner] */\n`);
                     return getMagicStringResult();
                 },

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

@@ -1,5 +1,4 @@
 export { pluginCommon };
-export declare let viteVersionUser: string | null | undefined;
 import { type InlineConfig, type Plugin } from 'vite';
 import type { VitePluginServerEntryOptions } from '@brillout/vite-plugin-server-entry/plugin';
 declare module 'vite' {
@@ -9,6 +8,7 @@ declare module 'vite' {
         _rootResolvedEarly?: string;
         _baseViteOriginal?: string;
         _viteConfigFromUserResolved?: InlineConfig;
+        _viteVersionResolved?: string;
     }
 }
 declare global {

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

@@ -1,5 +1,4 @@
 export { pluginCommon };
-export let viteVersionUser = null;
 import { assert, assertUsage, assertWarning, hasProp, isDevCheck, isDocker, isExactlyOneTruthy, isObject, isVitest, } from '../utils.js';
 import { assertRollupInput } from './build/pluginBuildConfig.js';
 import { installRequireShim_setUserRootDir } from '@brillout/require-shim';
@@ -10,6 +9,7 @@ import { isVikeCliOrApi } from '../../../shared-server-node/api-context.js';
 import { getVikeConfigInternal, setVikeConfigContext } from '../shared/resolveVikeConfigInternal.js';
 import { assertViteRoot, getViteRoot, normalizeViteRoot } from '../../api/resolveViteConfigFromUser.js';
 import { temp_disablePrerenderAutoRun } from '../../prerender/context.js';
+import { version as viteVersionVike } from 'vite';
 const pluginName = 'vike:pluginCommon';
 globalThis.__VIKE__IS_PROCESS_SHARED_WITH_VITE = true;
 function pluginCommon(vikeVitePluginOptions) {
@@ -20,7 +20,7 @@ function pluginCommon(vikeVitePluginOptions) {
             config: {
                 order: 'pre',
                 async handler(configFromUser, env) {
-                    viteVersionUser = this?.meta?.viteVersion; // is `undefined` on old Vite versions
+                    const viteVersionUser = this?.meta?.viteVersion; // is `undefined` on old Vite versions
                     const isDev = isDevCheck(env);
                     const isBuild = env.command === 'build';
                     const isPreview = env.isPreview;
@@ -34,6 +34,7 @@ function pluginCommon(vikeVitePluginOptions) {
                     const vikeConfig = await getVikeConfigInternal();
                     return {
                         _isDev: isDev,
+                        _viteVersionResolved: viteVersionUser || viteVersionVike,
                         _rootResolvedEarly: rootResolvedEarly,
                         // TO-DO/next-major-release: remove https://github.com/vikejs/vike/issues/2122
                         configVikePromise: Promise.resolve({

package/dist/server/__internal/vite.d.ts

@@ -0,0 +1 @@
+export { startupLog } from '../../node/api/dev.js';

package/dist/server/__internal/vite.js

@@ -0,0 +1 @@
+export { startupLog } from '../../node/api/dev.js';

package/dist/server/runtime/renderPageServer.js

@@ -220,6 +220,10 @@ function logHttpRequest(urlOriginal, pageContextInit, requestId) {
     logRuntimeInfo?.(getRequestInfoMessage(urlOriginal), pageContext_logRuntime, 'info');
 }
 /*
+const arrowRight = pc.dim('→')
+const arrowLeft = pc.dim('←')
+*/
+/*
 const arrowRight = pc.dim('>>')
 const arrowLeft = pc.dim('<<')
 /*/

package/dist/utils/PROJECT_VERSION.d.ts

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.247-commit-dbcfa58";
+export declare const PROJECT_VERSION: "0.4.247-commit-87e5f2f";

package/dist/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.247-commit-dbcfa58';
+export const PROJECT_VERSION = '0.4.247-commit-87e5f2f';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.247-commit-dbcfa58",
+  "version": "0.4.247-commit-87e5f2f",
   "repository": "https://github.com/vikejs/vike",
   "exports": {
     "./server": {
@@ -104,6 +104,10 @@
       "types": "./dist/server/runtime/page-files/setup.d.ts",
       "default": "./dist/server/runtime/page-files/setup.js"
     },
+    "./__internal/vite": {
+      "types": "./dist/server/__internal/vite.d.ts",
+      "default": "./dist/server/__internal/vite.js"
+    },
     ".": {
       "worker": "./dist/server/runtime/index.js",
       "workerd": "./dist/server/runtime/index.js",