vike 0.4.240-commit-8ce2cbd → 0.4.240-commit-95fc969

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

@@ -241,7 +241,7 @@ async function renderPageClientSide(renderArgs) {
             // We don't swallow 404 errors:
             //  - On the server-side, Vike swallows / doesn't show any 404 error log because it's expected that a user may go to some random non-existent URL. (We don't want to flood the app's error tracking with 404 logs.)
             //  - On the client-side, if the user navigates to a 404 then it means that the UI has a broken link. (It isn't expected that users can go to some random URL using the client-side router, as it would require, for example, the user to manually change the URL of a link by manually manipulating the DOM which highly unlikely.)
-            logError(err);
+            logErrorClient(err);
         }
         else {
             // We swallow throw redirect()/render() called by client-side hooks onBeforeRender()/data()/guard()
@@ -272,7 +272,7 @@ async function renderPageClientSide(renderArgs) {
                - An infinite reloading page is a even worse UX than a blank page.
             redirectHard(urlOriginal)
             */
-            logError(err);
+            logErrorClient(err);
         };
         const errorPageId = getErrorPageId(pageContext._pageFilesAll, pageContext._globalContext._pageConfigs);
         if (!errorPageId)
@@ -384,7 +384,7 @@ async function renderPageClientSide(renderArgs) {
                 await handleError({ err });
             }
             else {
-                logError(err);
+                logErrorClient(err);
             }
         };
         // We use globalObject.onRenderClientPreviousPromise in order to ensure that there is never two concurrent onRenderClient() calls
@@ -665,9 +665,10 @@ if (import.meta.env.DEV && import.meta.hot)
             });
         }
     });
-function logError(err) {
+function logErrorClient(err) {
     if (isObject(err) &&
         // Set by vike-react
+        // https://github.com/vikejs/vike-react/blob/195a208c6b77e7f34496e1f637278a36c60fbe07/packages/vike-react/src/integration/onRenderClient.tsx#L109
         err.isAlreadyLogged) {
         return;
     }

package/dist/esm/node/cli/parseCli.js

@@ -5,7 +5,7 @@ import { parseJson5 } from '../vite/shared/getEnvVarObject.js';
 const commands = [
     { name: 'dev', desc: 'Start development server' },
     { name: 'build', desc: 'Build for production' },
-    { name: 'preview', desc: 'Start preview server using production build (only works for SSG apps)' },
+    { name: 'preview', desc: 'Start preview server using production build' },
     { name: 'prerender', desc: 'Pre-render pages (only needed when prerender.disableAutoRun is true)' },
 ];
 function parseCli() {

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

@@ -690,6 +690,7 @@ function preparePrerenderContextForPublicUsage(prerenderContext) {
                 });
                 return prerenderContext.pageContexts;
             },
+            configurable: true,
         });
     }
     // Required because of https://vike.dev/i18n#pre-rendering

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

@@ -556,7 +556,8 @@ function isProdOptional() {
     const yes5 = globalObject.isProductionAccordingToUser === true;
     // vite-plugin-vercel
     const yes6 = globalObject.isProductionAccordingToPhotonVercel === true;
-    const yes = yes1 || yes2 || yes3 || yes4 || yes5 || yes6;
+    const yes7 = globalThis.__VIKE__IS_DEV === false;
+    const yes = yes1 || yes2 || yes3 || yes4 || yes5 || yes6 || yes7;
     const no1 = !!globalObject.viteDevServer;
     // Vike CLI & Vike API
     const no2 = vikeApiOperation === 'dev';
@@ -566,8 +567,9 @@ function isProdOptional() {
     const no4 = globalObject.isProductionAccordingToUser === false;
     // @cloudflare/vite-plugin
     const no5 = isNonRunnableDev();
-    const no = no1 || no2 || no3 || no4 || no5;
-    const debug = { yes1, yes2, yes3, yes4, yes5, yes6, no1, no2, no3, no4, no5 };
+    const no6 = globalThis.__VIKE__IS_DEV === true;
+    const no = no1 || no2 || no3 || no4 || no5 || no6;
+    const debug = { yes1, yes2, yes3, yes4, yes5, yes6, yes7, no1, no2, no3, no4, no5, no6 };
     assert(typeof yes === 'boolean', debug);
     assert(typeof no === 'boolean', debug);
     if (yes) {

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

@@ -64,11 +64,12 @@ async function renderPagePrepare(pageContextInit, httpRequestId) {
         await initGlobalContext_renderPage();
     }
     catch (err) {
-        // Errors are expected since assertUsage() is used in initGlobalContext_renderPage() such as:
-        // ```bash
-        // Re-build your app (you're using 1.2.3 but your app was built with 1.2.2)
-        // ```
-        // initGlobalContext_renderPage() doesn't call any user hook => err isn't thrown from user code.
+        // Errors are expected:
+        // - assertUsage() such as:
+        //   ```bash
+        //   Re-build your app (you're using 1.2.3 but your app was built with 1.2.2)
+        //   ```
+        // - initGlobalContext_renderPage() depends on +onCreateGlobalContext hooks
         assert(!isAbortError(err));
         logRuntimeError(err, httpRequestId);
         const pageContextWithError = getPageContextHttpResponseErrorWithoutGlobalContext(err, pageContextInit);

package/dist/esm/node/vite/plugins/build/handleAssetsManifest.js

@@ -310,7 +310,6 @@ async function handleAssetsManifest_getBuildConfig() {
 async function handleAssetsManifest(config, viteEnv, options, bundle) {
     const isSsrEnv = isViteServerSide_onlySsrEnv(config, viteEnv);
     if (isSsrEnv) {
-        assert(!globalObject.assetsJsonFilePath);
         const outDirs = getOutDirs(config, viteEnv);
         globalObject.assetsJsonFilePath = path.posix.join(outDirs.outDirRoot, 'assets.json');
         await writeAssetsManifestFile(globalObject.assetsJsonFilePath, config);

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

@@ -131,10 +131,16 @@ function assertVikeCliOrApi(config) {
         assert(!isVitest());
         return;
     }
+    /* This warning is always shown: Vitest loads Vite *before* any Vike JavaScript API can be invoked.
     if (isVitest()) {
-        assertWarning(false, `Unexpected Vitest setup: you seem to be using Vitest together with Vike's Vite plugin but without using Vike's JavaScript API which is unexpected, see ${pc.underline('https://vike.dev/vitest')}`, { onlyOnce: true });
-        return;
+      assertWarning(
+        false,
+        `Unexpected Vitest setup: you seem to be using Vitest together with Vike's Vite plugin but without using Vike's JavaScript API which is unexpected, see ${pc.underline('https://vike.dev/vitest')}`,
+        { onlyOnce: true },
+      )
+      return
     }
+    */
     if (config.server.middlewareMode) {
         assertWarning(false, `${pc.cyan('vite.createServer()')} is deprecated ${pc.underline('https://vike.dev/migration/cli#api')}`, {
             onlyOnce: true,

package/dist/esm/node/vite/plugins/pluginFileEnv.js

@@ -42,8 +42,10 @@ function pluginFileEnv() {
                     if (id.endsWith('?direct'))
                         id = id.slice(0, -1 * '?direct'.length);
                     const moduleInfo = viteDevServer.moduleGraph.getModuleById(id);
-                    assert(moduleInfo);
-                    const importers = Array.from(moduleInfo.importers)
+                    /* It can fail, no clue why — https://github.com/vikejs/vike/issues/2740
+                    assert(moduleInfo, { moduleId })
+                    */
+                    const importers = (!moduleInfo ? [] : Array.from(moduleInfo.importers))
                         .map((m) => m.id)
                         .filter((id) => id !== null);
                     assertFileEnv(id, isViteServerSide_extraSafe(config, this.environment, options), importers, 

package/dist/esm/node/vite/plugins/pluginReplaceConstantsEnvVars.js

@@ -61,8 +61,10 @@ function pluginReplaceConstantsEnvVars() {
                     const { magicString, getMagicStringResult } = getMagicString(code, id);
                     // Get regex operations
                     const replacements = Object.entries(envVarsAll)
-                        // Skip env vars that start with [`config.envPrefix`](https://vite.dev/config/shared-options.html#envprefix) => they are already handled by Vite
+                        // Skip env vars that start with [`config.envPrefix`](https://vite.dev/config/shared-options.html#envprefix) — they are already handled by Vite
                         .filter(([envName]) => !envPrefix.some((prefix) => envName.startsWith(prefix)))
+                        // Skip constants like import.meta.env.DEV which are already handled by Vite
+                        .filter(([envName]) => !['DEV', 'PROD', 'SSR', 'MODE', 'BASE_URL'].includes(envName))
                         .map(([envName, envVal]) => {
                         const envStatement = `import.meta.env.${envName}`;
                         const envStatementRegExpStr = escapeRegex(envStatement) + '\\b';

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

@@ -1,17 +1,10 @@
 export { pluginReplaceConstantsGlobalThis };
 import type { Plugin } from 'vite';
 declare global {
-    /** Like `import.meta.env.DEV` but works inside `node_modules/` (even if package is `ssr.external`). The value `undefined` is to be interpreted as `false`. */
-    var __VIKE__IS_DEV: boolean | undefined;
-    /** Like `import.meta.env.SSR` but works inside `node_modules/` (even if package is `ssr.external`). The value `undefined` is to be interpreted as `false`. */
-    var __VIKE__IS_CLIENT: boolean | undefined;
-    /**
-     * Whether a debug flag is enabled (either the global flag `DEBUG=vike` or a specific flag `DEBUG=vike:some-flag`).
-     *
-     * WARNING: must be used ONLY on the client-side. (The value is always `undefined` on the server-side.)
-     *
-     * In isomorhpic code, use `globalThis.__VIKE__IS_CLIENT` to make sure it's only used on the client-side.
-     */
-    var __VIKE__IS_DEBUG: boolean | undefined;
+    /** Like `import.meta.env.DEV` but works for `node_modules/` packages with `ssr.external` */
+    var __VIKE__IS_DEV: boolean;
+    /** Like `import.meta.env.SSR` but works for `node_modules/` packages with `ssr.external` */
+    var __VIKE__IS_CLIENT: boolean;
+    var __VIKE__IS_DEBUG: boolean;
 }
 declare function pluginReplaceConstantsGlobalThis(): Plugin[];

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

@@ -1,52 +1,77 @@
 export { pluginReplaceConstantsGlobalThis };
-import { assert, isDebug } from '../utils.js';
-// === Explanation: globalThis.__VIKE__IS_DEV
-// If client-side => always noExternal => globalThis.__VIKE__IS_DEV is set by the `define` config below.
-// If server-side:
-//   If ssr.noExternal => globalThis.__VIKE__IS_DEV is set by the `define` config below.
-//   If `ssr.external`:
-//     If not RunnableDevEnvironment (e.g. `@cloudflare/vite-plugin`) => always ssr.noExternal => globalThis.__VIKE__IS_DEV is set by the `define` config below.
-//     If RunnableDevEnvironment (the default setup):
-//       If dev/preview/pre-rendering => Vite is loaded, and server and Vite run inside the same process (because RunnableDevEnvironment) => globalThis.__VIKE__IS_DEV is set by the assignment below.
-//       If production => Vite isn't loaded => globalThis.__VIKE__IS_DEV is `undefined` (it's never set) => value `undefined` is to be interpreted as `false`.
-// === Explanation: globalThis.__VIKE__IS_CLIENT
-// If client-side => always noExternal => globalThis.__VIKE__IS_CLIENT is set to `true` by the `define` config below.
-// If server-side => globalThis.__VIKE__IS_CLIENT is either `false` or `undefined` (the value `undefined` is to be interpreted as `false`).
+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 filterRolldown = {
+    id: {
+        include: new RegExp(escapeRegex(VIRTUAL_FILE_ID)),
+    },
+};
+const filterFunction = (id) => id === VIRTUAL_FILE_ID || id === addVirtualFileIdPrefix(VIRTUAL_FILE_ID);
 function pluginReplaceConstantsGlobalThis() {
+    let config;
+    let isDev;
     return [
         {
-            name: 'vike:pluginReplaceConstantsGlobalThis',
+            name: 'vike:pluginReplaceConstantsGlobalThis:define',
             config: {
                 handler(config) {
-                    const isDev = config._isDev;
-                    assert(typeof isDev === 'boolean');
+                    assert(typeof config._isDev === 'boolean');
+                    isDev = config._isDev;
                     globalThis.__VIKE__IS_DEV = isDev;
                     return {
                         define: {
                             'globalThis.__VIKE__IS_DEV': JSON.stringify(isDev),
+                            'globalThis.__VIKE__IS_DEBUG': JSON.stringify(isDebugVal),
                         },
                     };
                 },
             },
             configEnvironment: {
                 handler(name, config) {
-                    const consumer = config.consumer ?? (name === 'client' ? 'client' : 'server');
-                    const isClientSide = consumer === 'client';
-                    const defineIsDebug = !isClientSide
-                        ? {}
-                        : {
-                            // We purposely only define it on the client-side, because we cannot know the value in server-side ssr.external production.
-                            'globalThis.__VIKE__IS_DEBUG': JSON.stringify(isDebug()),
-                        };
+                    const isClientSide = !isViteServerSide_configEnvironment(name, config);
                     return {
                         define: {
                             'globalThis.__VIKE__IS_CLIENT': JSON.stringify(isClientSide),
-                            ...defineIsDebug,
                         },
                     };
                 },
             },
+            configResolved(config_) {
+                config = config_;
+            },
+        },
+        {
+            name: 'vike:pluginReplaceConstantsGlobalThis:virtual-file',
+            // We only need the virtual file for the server-side (for node_modules/ packages with ssr.external) — the `define` values above always apply to the client-side.
+            applyToEnvironment(env) {
+                return isViteServerSide_applyToEnvironment(env);
+            },
+            resolveId: {
+                filter: filterRolldown,
+                handler(id) {
+                    assert(filterFunction(id));
+                    assert(id === VIRTUAL_FILE_ID);
+                    return addVirtualFileIdPrefix(id);
+                },
+            },
+            load: {
+                filter: filterRolldown,
+                handler(id, options) {
+                    assert(filterFunction(id));
+                    assert(isViteServerSide_extraSafe(config, this.environment, options));
+                    assert(typeof isDev === 'boolean');
+                    const code = [
+                        `globalThis.__VIKE__IS_DEV = ${JSON.stringify(isDev)};`,
+                        `globalThis.__VIKE__IS_CLIENT = false;`,
+                        `globalThis.__VIKE__IS_DEBUG = ${JSON.stringify(isDebugVal)};`,
+                    ].join('\n');
+                    return code;
+                },
+            },
         },
     ];
 }

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

@@ -12,6 +12,9 @@ function getCode(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, isCl
     const lines = [];
     const importStatements = [];
     const filesEnv = new Map();
+    if (!isForClientSide) {
+        importStatements.push("import 'virtual:vike:server:globalThis-constants';");
+    }
     lines.push('export const pageConfigsSerialized = [');
     lines.push(getCodePageConfigsSerialized(pageConfigs, isForClientSide, isClientRouting, isDev, importStatements, filesEnv));
     lines.push('];');
@@ -22,7 +25,10 @@ function getCode(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, isCl
         // https://vite.dev/guide/api-environment-frameworks.html
         lines.push('if (import.meta.hot) import.meta.hot.accept();');
     }
-    const code = [...importStatements, ...lines].join('\n');
+    let code = [...importStatements, ...lines].join('\n');
+    if (!isForClientSide) {
+        code = "import 'virtual:vike:server:globalThis-constants';\n" + code;
+    }
     debug(id, isForClientSide ? 'CLIENT-SIDE' : 'SERVER-SIDE', code);
     return code;
 }

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

@@ -23,6 +23,9 @@ async function getCode(config, isForClientSide, isClientRouting, isDev, id) {
     const isBuild = command === 'build';
     assert(isDev === !isBuild);
     let content = '';
+    if (!isForClientSide) {
+        content += "import 'virtual:vike:server:globalThis-constants';\n";
+    }
     {
         const globRoots = getGlobRoots(config);
         debugGlob('Glob roots: ', globRoots);

package/dist/esm/node/vite/shared/isViteServerSide.d.ts

@@ -1,18 +1,21 @@
 export { isViteServerSide };
-export { isViteClientSide };
 export { isViteServerSide_viteEnvOptional };
 export { isViteServerSide_onlySsrEnv };
 export { isViteServerSide_extraSafe };
+export { isViteServerSide_applyToEnvironment };
+export { isViteServerSide_configEnvironment };
 export type { ViteEnv };
-import type { Environment, EnvironmentOptions, ResolvedConfig, UserConfig } from 'vite';
+import type { Environment, EnvironmentOptions, ResolvedConfig, UserConfig, Plugin } from 'vite';
 type ViteEnv = {
     name?: string;
     config: EnvironmentOptions | Environment['config'];
 };
 declare function isViteServerSide(configGlobal: ResolvedConfig | UserConfig, viteEnv: ViteEnv): boolean;
 declare function isViteServerSide_viteEnvOptional(configGlobal: ResolvedConfig | UserConfig, viteEnv?: ViteEnv | undefined): boolean;
-declare function isViteClientSide(configGlobal: ResolvedConfig, viteEnv: ViteEnv): boolean;
 declare function isViteServerSide_onlySsrEnv(configGlobal: ResolvedConfig, viteEnv: ViteEnv): boolean;
 declare function isViteServerSide_extraSafe(config: ResolvedConfig, viteEnv: ViteEnv, options: {
     ssr?: boolean;
 } | undefined): boolean;
+type PartialEnvironment = Parameters<NonNullable<Plugin['applyToEnvironment']>>[0];
+declare function isViteServerSide_applyToEnvironment(env: PartialEnvironment): boolean;
+declare function isViteServerSide_configEnvironment(name: string, config: EnvironmentOptions): boolean;

package/dist/esm/node/vite/shared/isViteServerSide.js

@@ -1,8 +1,9 @@
 export { isViteServerSide };
-export { isViteClientSide };
 export { isViteServerSide_viteEnvOptional };
 export { isViteServerSide_onlySsrEnv };
 export { isViteServerSide_extraSafe };
+export { isViteServerSide_applyToEnvironment };
+export { isViteServerSide_configEnvironment };
 import { assert } from '../../../utils/assert.js';
 function isViteServerSide_impl(configGlobal, viteEnv) {
     assert(!('consumer' in configGlobal)); // make sure configGlobal isn't viteEnv.config
@@ -42,9 +43,6 @@ function isViteServerSide(configGlobal, viteEnv) {
 function isViteServerSide_viteEnvOptional(configGlobal, viteEnv) {
     return isViteServerSide_impl(configGlobal, viteEnv);
 }
-function isViteClientSide(configGlobal, viteEnv) {
-    return !isViteServerSide(configGlobal, viteEnv);
-}
 // Only `ssr` env: for example don't include `vercel_edge` nor `vercel_node`.
 function isViteServerSide_onlySsrEnv(configGlobal, viteEnv) {
     return viteEnv.name ? viteEnv.name === 'ssr' : isViteServerSide(configGlobal, viteEnv);
@@ -64,3 +62,14 @@ function isViteServerSide_extraSafe(config, viteEnv, options) {
     assert(options.ssr === isServerSide, debug);
     return isServerSide;
 }
+function isViteServerSide_applyToEnvironment(env) {
+    const { consumer } = env.config;
+    return isViteServerSide_consumer(consumer);
+}
+function isViteServerSide_configEnvironment(name, config) {
+    const consumer = config.consumer ?? (name === 'client' ? 'client' : 'server');
+    return isViteServerSide_consumer(consumer);
+}
+function isViteServerSide_consumer(consumer) {
+    return consumer !== 'client';
+}

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

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.240-commit-8ce2cbd";
+export declare const PROJECT_VERSION: "0.4.240-commit-95fc969";

package/dist/esm/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.240-commit-8ce2cbd';
+export const PROJECT_VERSION = '0.4.240-commit-95fc969';

package/dist/esm/utils/isVikeReactApp.js

@@ -1,5 +1,6 @@
 export function isVikeReactApp() {
     const g = globalThis;
-    // Set by vike-react https://github.com/vikejs/vike-react/blob/23e92434424f10e7e742b6bf587edee5aa8832df/packages/vike-react/src/renderer/onRenderHtml.tsx#L75
+    // Set by vike-react
+    // https://github.com/vikejs/vike-react/blob/23e92434424f10e7e742b6bf587edee5aa8832df/packages/vike-react/src/renderer/onRenderHtml.tsx#L75
     return !!g._isVikeReactApp;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.240-commit-8ce2cbd",
+  "version": "0.4.240-commit-95fc969",
   "repository": "https://github.com/vikejs/vike",
   "exports": {
     "./server": {