vike 0.4.247-commit-14351e3 → 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/api/dev.d.ts

@@ -6,7 +6,10 @@ import type { ApiOptions } from './types.js';
  *
  * https://vike.dev/api#dev
  */
-declare function dev(options?: ApiOptions): Promise<{
+declare function dev(options?: ApiOptions & {
+    startupLog?: boolean;
+}): Promise<{
     viteServer: ViteDevServer;
     viteConfig: ResolvedConfig;
+    viteVersion: string;
 }>;

package/dist/node/api/dev.js

@@ -1,16 +1,68 @@
 export { dev };
 import { prepareViteApiCall } from './prepareViteApiCall.js';
-import { createServer } from 'vite';
+import { createServer, version as viteVersionVike } from 'vite';
+import { viteVersionUser } from '../vite/plugins/pluginCommon.js';
+import { colorVike, colorVite, PROJECT_VERSION } from './utils.js';
+import pc from '@brillout/picocolors';
+import { processStartupLog } from '../vite/shared/loggerVite.js';
 /**
  * Programmatically trigger `$ vike dev`
  *
  * 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;
+    if (viteServer.httpServer)
+        await viteServer.listen();
+    if (options.startupLog)
+        printStartupLog(viteServer, viteConfig, viteVersion, startTime);
     return {
-        viteServer: server,
-        viteConfig: server.config,
+        viteServer,
+        viteConfig,
+        viteVersion,
     };
 }
+async function printStartupLog(viteServer, viteConfig, viteVersion, startTime) {
+    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`;
+    const ret = processStartupLog(firstLine, viteConfig);
+    console.log(ret.firstLine);
+    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);
+    viteServer.bindCLIShortcuts({ print: true });
+    if (!isCompact)
+        console.log();
+}
+// Copied & adapted from Vite
+// https://github.com/vitejs/vite/blob/df5a30d2690a2ebc4824a79becdcef30538dc602/packages/vite/src/node/logger.ts#L168-L188
+function printServerUrls(urls, optionsHost) {
+    // [Begin] interop
+    const colors = pc;
+    const info = (msg) => console.log(msg);
+    // [End] interop
+    const colorUrl = (url) => colors.underline(removeTrailingSlash(url));
+    for (const url of urls.local) {
+        info(`  ${colors.green('➜')}  ${colors.bold('Local')}:   ${colorUrl(url)}`);
+    }
+    for (const url of urls.network) {
+        info(`  ${colors.green('➜')}  ${colors.bold('Network')}: ${colorUrl(url)}`);
+    }
+    if (urls.network.length === 0 && optionsHost === undefined) {
+        info(colors.dim(`  ${colors.green('➜')}  ${colors.bold('Network')}: use `) +
+            colors.bold('--host') +
+            colors.dim(' to expose'));
+    }
+}
+function removeTrailingSlash(url) {
+    if (url.endsWith('/'))
+        return url.slice(0, -1); // remove trailing slash
+    return url;
+}

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

@@ -6,3 +6,6 @@ export * from '../../utils/assertVersion.js';
 export * from '../../utils/pick.js';
 export * from '../../utils/assertSetup.js';
 export * from '../../utils/isCallable.js';
+export * from '../../utils/colors.js';
+export * from '../../utils/colorVike.js';
+export * from '../../utils/PROJECT_VERSION.js';

package/dist/node/api/utils.js

@@ -10,3 +10,6 @@ export * from '../../utils/assertVersion.js';
 export * from '../../utils/pick.js';
 export * from '../../utils/assertSetup.js';
 export * from '../../utils/isCallable.js';
+export * from '../../utils/colors.js';
+export * from '../../utils/colorVike.js';
+export * from '../../utils/PROJECT_VERSION.js';

package/dist/node/cli/entry.js

@@ -1,4 +1,3 @@
-import { PROJECT_VERSION } from './utils.js';
 import { dev, build, preview } from '../api/index.js';
 import pc from '@brillout/picocolors';
 import { parseCli } from './parseCli.js';
@@ -21,23 +20,8 @@ async function cli() {
     }
 }
 async function cmdDev() {
-    const startTime = performance.now();
     try {
-        const { viteServer } = await dev();
-        if (viteServer.httpServer) {
-            await viteServer.listen();
-            const info = viteServer.config.logger.info;
-            const startupDurationString = pc.dim(`ready in ${pc.reset(pc.bold(String(Math.ceil(performance.now() - startTime))))} ms`);
-            const hasExistingLogs = process.stdout.bytesWritten > 0 || process.stderr.bytesWritten > 0;
-            info(`  ${pc.yellow(`${pc.bold('Vike')} v${PROJECT_VERSION}`)}  ${startupDurationString}\n`, {
-                clear: !hasExistingLogs,
-            });
-            viteServer.printUrls();
-        }
-        else {
-            // vike-server => middleware mode => `viteServer.httpServer === null`
-        }
-        viteServer.bindCLIShortcuts({ print: true });
+        await dev({ startupLog: true });
     }
     catch (err) {
         console.error(pc.red(`Error while starting dev server:`));

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 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/pluginCommon.d.ts

@@ -1,4 +1,5 @@
 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' {

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

@@ -1,4 +1,5 @@
 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';
@@ -19,6 +20,7 @@ function pluginCommon(vikeVitePluginOptions) {
             config: {
                 order: 'pre',
                 async handler(configFromUser, env) {
+                    viteVersionUser = this?.meta?.viteVersion; // is `undefined` on old Vite versions
                     const isDev = isDevCheck(env);
                     const isBuild = env.command === 'build';
                     const isPreview = env.isPreview;

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

@@ -4,11 +4,9 @@ import { determineOptimizeDeps } from './pluginDev/determineOptimizeDeps.js';
 import { determineFsAllowList } from './pluginDev/determineFsAllowList.js';
 import { addSsrMiddleware } from '../shared/addSsrMiddleware.js';
 import { applyDev, assertWarning, isDocker, isDebugError } from '../utils.js';
-import { improveViteLogs } from '../shared/loggerVite.js';
+import { interceptViteLogs } from '../shared/loggerVite.js';
 import pc from '@brillout/picocolors';
-if (isDebugError()) {
-    Error.stackTraceLimit = Infinity;
-}
+import { swallowViteLogConnected, swallowViteLogConnected_clean } from '../shared/loggerVite.js';
 function pluginDev() {
     let config;
     return [
@@ -44,21 +42,20 @@ function pluginDev() {
                     config = config_;
                     await determineOptimizeDeps(config);
                     await determineFsAllowList(config);
-                    if (!isDebugError()) {
-                        improveViteLogs(config);
-                    }
+                    interceptViteLogs(config);
                     logDockerHint(config.server.host);
                 },
             },
         },
         {
-            name: 'vike:pluginDev:addSsrMiddleware',
+            name: 'vike:pluginDev:post',
             apply: applyDev,
             // The SSR middleware should be last middleware
             enforce: 'post',
             configureServer: {
                 order: 'post',
                 handler(server) {
+                    swallowViteLogConnected_clean(); // If inside a configureServer() `pre` hook => too early
                     const hasHonoViteDevServer = !!config.plugins.find((p) => p.name === '@hono/vite-dev-server');
                     if (config.server.middlewareMode || hasHonoViteDevServer)
                         return;
@@ -76,6 +73,12 @@ function pluginDev() {
                     }
                 },
             },
+            configResolved: {
+                order: 'post',
+                handler() {
+                    swallowViteLogConnected();
+                },
+            },
         },
     ];
 }

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/node/vite/shared/loggerDev/errorWithCodeSnippet.d.ts

@@ -10,6 +10,7 @@ type ErrorWithCodeSnippet = {
     plugin?: string;
 };
 declare function isErrorWithCodeSnippet(err: unknown): err is ErrorWithCodeSnippet;
-declare function getPrettyErrorWithCodeSnippet(err: ErrorWithCodeSnippet, userRootDir: string): string;
+declare function getPrettyErrorWithCodeSnippet(err: ErrorWithCodeSnippet, userRootDir: string): `Failed to transpile ${string} because:
+${string}`;
 declare function getPrettyErrMessage(err: ErrorWithCodeSnippet): string | null;
 declare function isEquivalentErrorWithCodeSnippet(err1: unknown, err2: unknown): boolean;

package/dist/node/vite/shared/loggerDev/errorWithCodeSnippet.js

@@ -45,11 +45,7 @@ function getPrettyErrorWithCodeSnippet(err, userRootDir) {
     //*/
     assert(isErrorWithCodeSnippet(err));
     let { id, frame } = err;
-    const msgFirstLine = [
-        pc.red('Failed to transpile'),
-        pc.bold(pc.red(getFilePathToShowToUserUnknown(id, userRootDir))),
-        pc.red('because:'),
-    ].join(' ');
+    const msgFirstLine = `${pc.red('Failed to transpile')} ${pc.bold(pc.red(getFilePathToShowToUserUnknown(id, userRootDir)))} ${pc.red('because:')}`;
     const errMsg = getPrettyErrMessage(err);
     if (errMsg && containsCodeSnippet(errMsg)) {
         // Conditionally swallowing frame is a risky move but worth it thanks to logErrorDebugNote()
@@ -65,15 +61,16 @@ function getPrettyErrorWithCodeSnippet(err, userRootDir) {
         assert(frame);
         frame = pc.yellow(frame);
     }
-    let msg = [msgFirstLine, errMsg, frame].filter(Boolean).join('\n');
-    msg = removeEmptyLines(msg);
+    let errMsgCodeSnippet = [errMsg, frame].filter(Boolean).join('\n');
+    errMsgCodeSnippet = removeEmptyLines(errMsgCodeSnippet);
+    const errMsgFormatted = `${msgFirstLine}\n${errMsgCodeSnippet}`;
     /* Vite already does a fairly good job at showing a concise error in the layover
     server.ws.send({
       type: 'error',
       err: msg
     })
     */
-    return msg;
+    return errMsgFormatted;
 }
 function getPrettyErrMessage(err) {
     const { id, frame } = err;