vike 0.4.239 → 0.4.240-commit-bac5dee

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

@@ -8,75 +8,104 @@ import { getExportNames } from '../shared/parseEsModule.js';
 import { normalizeId } from '../shared/normalizeId.js';
 import { isV1Design } from '../shared/resolveVikeConfigInternal.js';
 import { isViteServerSide, isViteServerSide_extraSafe } from '../shared/isViteServerSide.js';
+const skipNodeModules = '/node_modules/'; // Only apply `.server.js` and `.client.js` to user files
+const filterRolldown = {
+    id: {
+        include: ['client', 'server'].map((env) => `**/*${getSuffix(env)}*`),
+        exclude: [`**${skipNodeModules}**`],
+    },
+};
+const filterFunction = (id) => {
+    if (id.includes(skipNodeModules))
+        return false;
+    if (!id.includes(getSuffix('client')) && !id.includes(getSuffix('server')))
+        return false;
+    return true;
+};
 function pluginFileEnv() {
     let config;
     let viteDevServer;
-    return {
-        name: 'vike:pluginFileEnv',
-        load(id, options) {
-            // In build, we use generateBundle() instead of the load() hook. Using load() works for dynamic imports in dev thanks to Vite's lazy transpiling, but it doesn't work in build because Rollup transpiles any dynamically imported module even if it's never actually imported.
-            if (!viteDevServer)
-                return;
-            if (!isV1Design())
-                return;
-            if (skip(id))
-                return;
-            // For `.vue` files: https://github.com/vikejs/vike/issues/1912#issuecomment-2394981475
-            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)
-                .map((m) => m.id)
-                .filter((id) => id !== null);
-            assertFileEnv(id, isViteServerSide_extraSafe(config, this.environment, options), importers, 
-            // In dev, we only show a warning because we don't want to disrupt when the user plays with settings such as [ssr](https://vike.dev/ssr).
-            true);
-        },
-        // 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;
-            if (skip(id))
-                return;
-            const isServerSide = isViteServerSide_extraSafe(config, this.environment, options);
-            if (!isWrongEnv(id, isServerSide))
-                return;
-            const { importers } = this.getModuleInfo(id);
-            // Throwing a verbose error doesn't waste client-side KBs as dynamic imports are code split.
-            const errMsg = getErrorMessage(id, isServerSide, importers, false, true);
-            // We have to inject empty exports to avoid Rollup complaining about missing exports, see https://gist.github.com/brillout/5ea45776e65bd65100a52ecd7bfda3ff
-            const { exportNames } = await getExportNames(code);
-            return rollupSourceMapRemove([
-                `throw new Error(${JSON.stringify(errMsg)});`,
-                ...exportNames.map((name) => name === 'default' ? 'export default undefined;' : `export const ${name} = undefined;`),
-            ].join('\n'));
-        },
-        generateBundle() {
-            Array.from(this.getModuleIds())
-                .filter((id) => !skip(id))
-                .forEach((moduleId) => {
-                const mod = this.getModuleInfo(moduleId);
-                const { importers } = mod;
-                if (importers.length === 0) {
-                    // Dynamic imports can only be verified at runtime
-                    /* This assertion can fail: https://github.com/vikejs/vike/issues/2227
-                    assert(dynamicImporters.length > 0)
-                    */
-                    return;
-                }
-                assertFileEnv(moduleId, isViteServerSide(config, this.environment), importers, false);
-            });
-        },
-        configResolved(config_) {
-            config = config_;
-        },
-        configureServer(viteDevServer_) {
-            viteDevServer = viteDevServer_;
+    return [
+        {
+            name: 'vike:pluginFileEnv',
+            load: {
+                filter: filterRolldown,
+                handler(id, options) {
+                    // In build, we use generateBundle() instead of the load() hook. Using load() works for dynamic imports in dev thanks to Vite's lazy transpiling, but it doesn't work in build because Rollup transpiles any dynamically imported module even if it's never actually imported.
+                    if (!viteDevServer)
+                        return;
+                    if (!isV1Design())
+                        return;
+                    if (skip(id, config.root))
+                        return;
+                    // For `.vue` files: https://github.com/vikejs/vike/issues/1912#issuecomment-2394981475
+                    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)
+                        .map((m) => m.id)
+                        .filter((id) => id !== null);
+                    assertFileEnv(id, isViteServerSide_extraSafe(config, this.environment, options), importers, 
+                    // In dev, we only show a warning because we don't want to disrupt when the user plays with settings such as [ssr](https://vike.dev/ssr).
+                    true);
+                },
+            },
+            // 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.
+            transform: {
+                filter: filterRolldown,
+                async handler(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;
+                    if (skip(id, config.root))
+                        return;
+                    const isServerSide = isViteServerSide_extraSafe(config, this.environment, options);
+                    if (!isWrongEnv(id, isServerSide))
+                        return;
+                    const { importers } = this.getModuleInfo(id);
+                    // Throwing a verbose error doesn't waste client-side KBs as dynamic imports are code split.
+                    const errMsg = getErrorMessage(id, isServerSide, importers, false, true);
+                    // We have to inject empty exports to avoid Rollup complaining about missing exports, see https://gist.github.com/brillout/5ea45776e65bd65100a52ecd7bfda3ff
+                    const { exportNames } = await getExportNames(code);
+                    return rollupSourceMapRemove([
+                        `throw new Error(${JSON.stringify(errMsg)});`,
+                        ...exportNames.map((name) => name === 'default' ? 'export default undefined;' : `export const ${name} = undefined;`),
+                    ].join('\n'));
+                },
+            },
+            generateBundle: {
+                handler() {
+                    Array.from(this.getModuleIds())
+                        .filter(filterFunction)
+                        .filter((id) => !skip(id, config.root))
+                        .forEach((moduleId) => {
+                        const mod = this.getModuleInfo(moduleId);
+                        const { importers } = mod;
+                        if (importers.length === 0) {
+                            // Dynamic imports can only be verified at runtime
+                            /* This assertion can fail: https://github.com/vikejs/vike/issues/2227
+                        assert(dynamicImporters.length > 0)
+                        */
+                            return;
+                        }
+                        assertFileEnv(moduleId, isViteServerSide(config, this.environment), importers, false);
+                    });
+                },
+            },
+            configResolved: {
+                handler(config_) {
+                    config = config_;
+                },
+            },
+            configureServer: {
+                handler(viteDevServer_) {
+                    viteDevServer = viteDevServer_;
+                },
+            },
         },
-    };
+    ];
     function assertFileEnv(moduleId, isServerSide, importers, onlyWarn) {
         if (!isWrongEnv(moduleId, isServerSide))
             return;
@@ -114,31 +143,27 @@ function pluginFileEnv() {
         }
         return errMsg;
     }
-    function isWrongEnv(moduleId, isServerSide) {
-        const modulePath = getModulePath(moduleId);
-        const suffixWrong = getSuffix(isServerSide ? 'client' : 'server');
-        return modulePath.includes(suffixWrong);
-    }
-    function skip(id) {
-        // TO-DO/next-major-release: remove
-        if (extractAssetsRE.test(id) || extractExportNamesRE.test(id))
-            return true;
-        if (!id.includes(getSuffix('client')) && !id.includes(getSuffix('server')))
-            return true;
-        if (getModulePath(id).endsWith('.css'))
-            return true;
-        // Apply `.server.js` and `.client.js` only to user files
-        if (id.includes('/node_modules/'))
-            return true;
-        // Only user files
-        if (!id.startsWith(config.root))
-            return true;
-        return false;
-    }
-    function getSuffix(env) {
-        return `.${env}.`;
-    }
-    function getModulePath(moduleId) {
-        return moduleId.split('?')[0];
-    }
+}
+function isWrongEnv(moduleId, isServerSide) {
+    const modulePath = getModulePath(moduleId);
+    const suffixWrong = getSuffix(isServerSide ? 'client' : 'server');
+    return modulePath.includes(suffixWrong);
+}
+function skip(id, userRootDir) {
+    assert(filterFunction(id));
+    // TO-DO/next-major-release: remove
+    if (extractAssetsRE.test(id) || extractExportNamesRE.test(id))
+        return true;
+    if (getModulePath(id).endsWith('.css'))
+        return true;
+    // Skip linked dependencies
+    if (!id.startsWith(userRootDir))
+        return true;
+    return false;
+}
+function getSuffix(env) {
+    return `.${env}.`;
+}
+function getModulePath(moduleId) {
+    return moduleId.split('?')[0];
 }

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

@@ -1,3 +1,3 @@
 export { pluginPreview };
 import type { Plugin } from 'vite';
-declare function pluginPreview(): Plugin;
+declare function pluginPreview(): Plugin[];

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

@@ -11,37 +11,45 @@ import { getVikeConfigInternal } from '../shared/resolveVikeConfigInternal.js';
 function pluginPreview() {
     let config;
     let vikeConfig;
-    return {
-        name: 'vike:pluginPreview',
-        apply: applyPreview,
-        config() {
-            return {
-                appType: 'custom',
-            };
+    return [
+        {
+            name: 'vike:pluginPreview',
+            apply: applyPreview,
+            config: {
+                handler() {
+                    return {
+                        appType: 'custom',
+                    };
+                },
+            },
+            configResolved: {
+                async handler(config_) {
+                    config = config_;
+                    vikeConfig = await getVikeConfigInternal();
+                    logDockerHint(config.preview.host);
+                    // vikeConfig = await getVikeConfig(config)
+                },
+            },
+            configurePreviewServer: {
+                handler(server) {
+                    /* - Couldn't make `appType: 'mpa'` work as of npm:@brillout/vite@5.0.0-beta.14.0426910c
+                   - This ugly hack to set appType for preview won't be need once https://github.com/vitejs/vite/pull/14855 is merged.
+                config.appType = 'mpa'
+                */
+                    return () => {
+                        const { isPrerenderingEnabledForAllPages, isPrerenderingEnabled } = vikeConfig.prerenderContext;
+                        assertDist(isPrerenderingEnabledForAllPages);
+                        // We cannot re-use Vite's static middleware: https://github.com/vitejs/vite/pull/14836#issuecomment-1788540300
+                        addStaticAssetsMiddleware(server.middlewares);
+                        if (!isPrerenderingEnabledForAllPages) {
+                            addSsrMiddleware(server.middlewares, config, true, isPrerenderingEnabled);
+                        }
+                        addStatic404Middleware(server.middlewares);
+                    };
+                },
+            },
         },
-        async configResolved(config_) {
-            config = config_;
-            vikeConfig = await getVikeConfigInternal();
-            logDockerHint(config.preview.host);
-            // vikeConfig = await getVikeConfig(config)
-        },
-        configurePreviewServer(server) {
-            /* - Couldn't make `appType: 'mpa'` work as of npm:@brillout/vite@5.0.0-beta.14.0426910c
-               - This ugly hack to set appType for preview won't be need once https://github.com/vitejs/vite/pull/14855 is merged.
-            config.appType = 'mpa'
-            */
-            return () => {
-                const { isPrerenderingEnabledForAllPages, isPrerenderingEnabled } = vikeConfig.prerenderContext;
-                assertDist(isPrerenderingEnabledForAllPages);
-                // We cannot re-use Vite's static middleware: https://github.com/vitejs/vite/pull/14836#issuecomment-1788540300
-                addStaticAssetsMiddleware(server.middlewares);
-                if (!isPrerenderingEnabledForAllPages) {
-                    addSsrMiddleware(server.middlewares, config, true, isPrerenderingEnabled);
-                }
-                addStatic404Middleware(server.middlewares);
-            };
-        },
-    };
+    ];
     function assertDist(isPrerenderingEnabledForAllPages) {
         const { outDirRoot, outDirClient, outDirServer } = getOutDirs(config, undefined);
         const dirS = [outDirRoot, outDirClient];

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

@@ -0,0 +1,3 @@
+export { pluginReplaceConstantsEnvVars };
+import type { Plugin } from 'vite';
+declare function pluginReplaceConstantsEnvVars(): Plugin[];

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

@@ -0,0 +1,127 @@
+export { pluginReplaceConstantsEnvVars };
+import { loadEnv } from 'vite';
+import { assert, assertPosixPath, assertUsage, assertWarning, escapeRegex, isArray, isNotNullish, lowerFirst, } from '../utils.js';
+import { getModuleFilePathAbsolute } from '../shared/getFilePath.js';
+import { normalizeId } from '../shared/normalizeId.js';
+import { isViteServerSide_extraSafe } from '../shared/isViteServerSide.js';
+import { getMagicString } from '../shared/getMagicString.js';
+const PUBLIC_ENV_PREFIX = 'PUBLIC_ENV__';
+const PUBLIC_ENV_ALLOWLIST = [
+    // https://github.com/vikejs/vike/issues/1724
+    'STORYBOOK',
+];
+// TO-DO/eventually:
+// - 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
+//   - Or stop using Vite's `mode` implementation and have Vike implement its own `mode` feature? (So that the only dependencies are `$ vike build --mode staging` and `$ MODE=staging vike build`.)
+const skipNodeModules = '/node_modules/';
+const skipIrrelevant = 'import.meta.env.';
+const filterRolldown = {
+    id: {
+        exclude: `**${skipNodeModules}**`,
+    },
+    code: {
+        include: skipIrrelevant,
+    },
+};
+const filterFunction = (id, code) => {
+    if (id.includes(skipNodeModules))
+        return false;
+    if (!code.includes(skipIrrelevant))
+        return false;
+    return true;
+};
+function pluginReplaceConstantsEnvVars() {
+    let envVarsAll;
+    let envPrefix;
+    let config;
+    return [
+        {
+            name: 'vike:pluginReplaceConstantsEnvVars',
+            enforce: 'post',
+            configResolved: {
+                handler(config_) {
+                    config = config_;
+                    envVarsAll = loadEnv(config.mode, config.envDir || config.root, '');
+                    envPrefix = getEnvPrefix(config);
+                    config.plugins.sort(lowerFirst((plugin) => (plugin.name === 'vite:define' ? 1 : 0)));
+                },
+            },
+            transform: {
+                filter: filterRolldown,
+                handler(code, id, options) {
+                    id = normalizeId(id);
+                    assertPosixPath(id);
+                    assertPosixPath(config.root);
+                    if (!id.startsWith(config.root))
+                        return; // skip linked dependencies
+                    assert(filterFunction(id, code));
+                    const isBuild = config.command === 'build';
+                    const isClientSide = !isViteServerSide_extraSafe(config, this.environment, options);
+                    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
+                        .filter(([envName]) => !envPrefix.some((prefix) => envName.startsWith(prefix)))
+                        .map(([envName, envVal]) => {
+                        const envStatement = `import.meta.env.${envName}`;
+                        const envStatementRegExpStr = escapeRegex(envStatement) + '\\b';
+                        // Show error (warning in dev) if client code contains a private environment variable (one that doesn't start with PUBLIC_ENV__ and that isn't included in `PUBLIC_ENV_ALLOWLIST`).
+                        if (isClientSide) {
+                            const skip = assertNoClientSideLeak({
+                                envName,
+                                envStatement,
+                                envStatementRegExpStr,
+                                code,
+                                id,
+                                config,
+                                isBuild,
+                            });
+                            if (skip)
+                                return null;
+                        }
+                        return { regExpStr: envStatementRegExpStr, replacement: envVal };
+                    })
+                        .filter(isNotNullish);
+                    // Apply regex operations
+                    replacements.forEach(({ regExpStr, replacement }) => {
+                        magicString.replaceAll(new RegExp(regExpStr, 'g'), JSON.stringify(replacement));
+                    });
+                    return getMagicStringResult();
+                },
+            },
+        },
+    ];
+}
+function getEnvPrefix(config) {
+    const { envPrefix } = config;
+    if (!envPrefix)
+        return [];
+    if (!isArray(envPrefix))
+        return [envPrefix];
+    return envPrefix;
+}
+function assertNoClientSideLeak({ envName, envStatement, envStatementRegExpStr, code, id, config, isBuild, }) {
+    const isPrivate = !envName.startsWith(PUBLIC_ENV_PREFIX) && !PUBLIC_ENV_ALLOWLIST.includes(envName);
+    // ✅ All good
+    if (!isPrivate)
+        return;
+    if (!new RegExp(envStatementRegExpStr).test(code))
+        return true;
+    // ❌ Security leak!
+    // - Warning in dev
+    // - assertUsage() and abort when building for production
+    const modulePath = getModuleFilePathAbsolute(id, config);
+    const errMsgAddendum = isBuild ? '' : ' (Vike will prevent your app from building for production)';
+    const envNameFixed = `${PUBLIC_ENV_PREFIX}${envName}`;
+    const errMsg = `${envStatement} is used in client-side file ${modulePath} which means that the environment variable ${envName} will be included in client-side bundles and, therefore, ${envName} will be publicly exposed which can be a security leak${errMsgAddendum}. Use ${envStatement} only in server-side files, or rename ${envName} to ${envNameFixed}, see https://vike.dev/env`;
+    if (isBuild) {
+        assertUsage(false, errMsg);
+    }
+    else {
+        // - Only a warning for faster development DX (e.g. when user toggles `ssr: boolean` or `onBeforeRenderIsomorph: boolean`).
+        // - Although only showing a warning can be confusing: https://github.com/vikejs/vike/issues/1641
+        assertWarning(false, errMsg, { onlyOnce: true });
+    }
+    assert(!isBuild); // we should abort if building for production
+}

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

@@ -0,0 +1,17 @@
+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;
+}
+declare function pluginReplaceConstantsGlobalThis(): Plugin[];

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

@@ -0,0 +1,52 @@
+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`).
+globalThis.__VIKE__IS_CLIENT = false;
+function pluginReplaceConstantsGlobalThis() {
+    return [
+        {
+            name: 'vike:pluginReplaceConstantsGlobalThis',
+            config: {
+                handler(config) {
+                    const isDev = config._isDev;
+                    assert(typeof isDev === 'boolean');
+                    globalThis.__VIKE__IS_DEV = isDev;
+                    return {
+                        define: {
+                            'globalThis.__VIKE__IS_DEV': JSON.stringify(isDev),
+                        },
+                    };
+                },
+            },
+            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()),
+                        };
+                    return {
+                        define: {
+                            'globalThis.__VIKE__IS_CLIENT': JSON.stringify(isClientSide),
+                            ...defineIsDebug,
+                        },
+                    };
+                },
+            },
+        },
+    ];
+}

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

@@ -0,0 +1,3 @@
+export { pluginReplaceConstantsPageContext };
+import type { Plugin } from 'vite';
+declare function pluginReplaceConstantsPageContext(): Plugin[];

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

@@ -0,0 +1,89 @@
+export { pluginReplaceConstantsPageContext };
+import { assert, assertPosixPath } from '../utils.js';
+import { normalizeId } from '../shared/normalizeId.js';
+import { isViteServerSide_extraSafe } from '../shared/isViteServerSide.js';
+import { getMagicString } from '../shared/getMagicString.js';
+const constantsIsClientSide = [
+    //
+    'pageContext.isClientSide',
+    'globalContext.isClientSide',
+    'pageContext.globalContext.isClientSide',
+];
+// - See https://vike.dev/pageContext#narrowing-down
+// - We cannot use [`define`](https://vite.dev/config/shared-options.html#define) because of https://github.com/rolldown/rolldown/issues/4300
+const skipNodeModules = '/node_modules/';
+const skipIrrelevant = 'Context.isClientSide';
+assert(constantsIsClientSide.every((constant) => constant.endsWith(skipIrrelevant)));
+const filterRolldown = {
+    id: {
+        exclude: `**${skipNodeModules}**`,
+    },
+    code: {
+        include: skipIrrelevant,
+    },
+};
+const filterFunction = (id, code) => {
+    if (id.includes(skipNodeModules))
+        return false;
+    if (!code.includes(skipIrrelevant))
+        return false;
+    return true;
+};
+function pluginReplaceConstantsPageContext() {
+    let config;
+    return [
+        {
+            name: 'vike:pluginReplaceConstantsPageContext',
+            enforce: 'post',
+            apply: 'build',
+            configResolved: {
+                handler(config_) {
+                    config = config_;
+                },
+            },
+            transform: {
+                filter: filterRolldown,
+                handler(code, id, options) {
+                    id = normalizeId(id);
+                    assertPosixPath(id);
+                    assertPosixPath(config.root);
+                    if (!id.startsWith(config.root))
+                        return; // skip linked dependencies
+                    assert(filterFunction(id, code));
+                    const isBuild = config.command === 'build';
+                    assert(isBuild);
+                    // Used by vike.dev
+                    // https://github.com/vikejs/vike/blob/08a1ff55c80ddca64ca6d4417fefd45fefeb4ffb/docs/vite.config.ts#L12
+                    // @ts-expect-error
+                    if (config._skipVikeReplaceConstants?.(id))
+                        return;
+                    const { magicString, getMagicStringResult } = getMagicString(code, id);
+                    if (constantsIsClientSide.some((c) => code.includes(c))) {
+                        const replacement = !isViteServerSide_extraSafe(config, this.environment, options);
+                        const regExp = getConstantRegExp(constantsIsClientSide);
+                        magicString.replaceAll(regExp, JSON.stringify(replacement));
+                    }
+                    return getMagicStringResult();
+                },
+            },
+        },
+    ];
+}
+// Copied & adapted from:
+// https://github.com/rollup/plugins/blob/e1a5ef99f1578eb38a8c87563cb9651db228f3bd/packages/replace/src/index.js#L57-L67
+function getConstantRegExp(constants) {
+    const keys = Object.values(constants).sort(longest).map(escape);
+    // const delimiters = ['\\b', '\\b(?!\\.)']
+    const delimiters = ['(?<!\\.)\\b', '\\b(?!\\.)']; // Improved version, to avoid replacing `globalContext.pageContext.isClientSide` with `globalContext.false`
+    const preventAssignment = false; // Let's try without it first, let's see if a user complains
+    const lookbehind = preventAssignment ? '(?<!\\b(?:const|let|var)\\s*)' : '';
+    const lookahead = preventAssignment ? '(?!\\s*=[^=])' : '';
+    const pattern = new RegExp(`${lookbehind}${delimiters[0]}(${keys.join('|')})${delimiters[1]}${lookahead}`, 'g');
+    return pattern;
+}
+function escape(str) {
+    return str.replace(/[-[\]/{}()*+?.\\^$|]/g, '\\$&');
+}
+function longest(a, b) {
+    return b.length - a.length;
+}

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

@@ -20,8 +20,10 @@ function pluginSetGlobalContext() {
                     markSetup_viteDevServer();
                 },
             },
-            configurePreviewServer() {
-                markSetup_vitePreviewServer();
+            configurePreviewServer: {
+                handler() {
+                    markSetup_vitePreviewServer();
+                },
             },
             config: {
                 order: 'pre',

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

@@ -5,7 +5,7 @@ import { getVikeConfigInternal } from '../../shared/resolveVikeConfigInternal.js
 import { extractAssetsAddQuery } from '../../../shared/extractAssetsQuery.js';
 import { debug } from './debug.js';
 import { serializeConfigValues } from '../../../../shared/page-configs/serialize/serializeConfigValues.js';
-import { handleAssetsManifest_isFixEnabled } from '../pluginBuild/handleAssetsManifest.js';
+import { handleAssetsManifest_isFixEnabled } from '../build/handleAssetsManifest.js';
 import { getConfigValueBuildTime } from '../../../../shared/page-configs/getConfigValueBuildTime.js';
 import { resolveIncludeAssetsImportedByServer } from '../../../runtime/renderPage/getPageAssets/retrievePageAssetsProd.js';
 async function generateVirtualFilePageEntry(id, isDev) {

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

@@ -1,3 +1,3 @@
 export { pluginVirtualFiles };
 import type { Plugin } from 'vite';
-declare function pluginVirtualFiles(): Plugin;
+declare function pluginVirtualFiles(): Plugin[];