vike 0.4.238 → 0.4.239-commit-050a4a3

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

@@ -33,24 +33,26 @@ function pluginExtractAssets() {
             // In dev, things just work. (Because Vite's module graph erroneously conflates the Vite server-side importees with the client-side importees.)
             apply: 'build',
             enforce: 'post',
-            async transform(src, id, options) {
-                id = normalizeId(id);
-                if (!extractAssetsRE.test(id)) {
-                    return;
-                }
-                if (isFixEnabled) {
-                    // I'm guessing isFixEnabled can only be true when mixing both designs: https://github.com/vikejs/vike/issues/1480
-                    assertV1Design(vikeConfig._pageConfigs, true);
-                    assert(false);
-                }
-                const includeAssetsImportedByServer = resolveIncludeAssetsImportedByServer(vikeConfig.config);
-                assert(includeAssetsImportedByServer);
-                assert(!isViteServerSide_extraSafe(config, this.environment, options));
-                const importStatements = await getImportStatements(src);
-                const moduleNames = getImportedModules(importStatements);
-                const code = moduleNames.map((moduleName) => `import '${moduleName}';`).join('\n');
-                debugTransformResult(id, code, importStatements);
-                return rollupSourceMapRemove(code);
+            transform: {
+                async handler(src, id, options) {
+                    id = normalizeId(id);
+                    if (!extractAssetsRE.test(id)) {
+                        return;
+                    }
+                    if (isFixEnabled) {
+                        // I'm guessing isFixEnabled can only be true when mixing both designs: https://github.com/vikejs/vike/issues/1480
+                        assertV1Design(vikeConfig._pageConfigs, true);
+                        assert(false);
+                    }
+                    const includeAssetsImportedByServer = resolveIncludeAssetsImportedByServer(vikeConfig.config);
+                    assert(includeAssetsImportedByServer);
+                    assert(!isViteServerSide_extraSafe(config, this.environment, options));
+                    const importStatements = await getImportStatements(src);
+                    const moduleNames = getImportedModules(importStatements);
+                    const code = moduleNames.map((moduleName) => `import '${moduleName}';`).join('\n');
+                    debugTransformResult(id, code, importStatements);
+                    return rollupSourceMapRemove(code);
+                },
             },
         },
         // This plugin appends `?extractAssets` to module IDs
@@ -61,89 +63,97 @@ function pluginExtractAssets() {
             //  - rollup's `alias` plugin; https://github.com/rollup/plugins/blob/5363f55aa1933b6c650832b08d6a54cb9ea64539/packages/alias/src/index.ts
             //  - Vite's `vite:resolve` plugin; https://github.com/vitejs/vite/blob/d649daba7682791178b711d9a3e44a6b5d00990c/packages/vite/src/node/plugins/resolve.ts#L105
             enforce: 'pre',
-            async resolveId(source, importer, options) {
-                if (isViteServerSide_extraSafe(config, this.environment, options)) {
-                    // When building for the server, there should never be a `?extractAssets` query
-                    assert(!extractAssetsRE.test(source));
-                    assert(importer === undefined || !extractAssetsRE.test(importer));
-                    return;
-                }
-                // If there is no `importer` then `module` is an entry.
-                // We don't need to append `?extractAssets` to entries because they already have `?extractAssets` as Vike appends `?extractAssets` to entries by using `import.meta.glob('/**/*.page.server.js', { as: "extractAssets" })` (see `generateImportGlobs.ts`).
-                if (!importer) {
-                    return;
-                }
-                // We only append `?extractAssets` if the parent module has `?extractAssets`
-                if (!extractAssetsRE.test(importer)) {
-                    return;
-                }
-                const includeAssetsImportedByServer = resolveIncludeAssetsImportedByServer(vikeConfig.config);
-                assert(includeAssetsImportedByServer);
-                let resolution = null;
-                try {
-                    resolution = await this.resolve(source, importer, { skipSelf: true, ...options });
-                }
-                catch { }
-                // Sometimes Rollup fails to resolve. If it fails to resolve, we assume the dependency to be an npm package and we skip it. (I guess Rollup should always be able to resolve local dependencies?)
-                if (!resolution)
-                    return emptyModule(source, importer);
-                const { id: file, external } = resolution;
-                // Nothing is externalized when building for the client-side
-                assert(external === false);
-                // We include:
-                //  - CSS(/LESS/SCSS/...) files
-                //  - Asset files (`.svg`, `.pdf`, ...)
-                //  - URL imports (e.g. `import scriptUrl from './script.js?url.js'`)
-                if (styleFileRE.test(file) || isAsset(file) || urlRE.test(file)) {
-                    debugOperation('INCLUDED', file, importer);
-                    return resolution;
-                }
-                // We erase `source` if its file doesn't contain JavaScript
-                if (!isScriptFile(file)) {
-                    return emptyModule(file, importer);
-                }
-                // If the import path resolves to a file in `node_modules/`, we ignore that file:
-                //  - Direct CSS dependencies are included though, such as `import 'bootstrap/theme/dark.css'`. (Because the above if-branch for CSS files will add the file.)
-                //  - Loading CSS from a library (living in `node_modules/`) in a non-direct way is unconventional; we can safely not support this case. (I'm not aware of any library that does this.)
-                assertPosixPath(file);
-                if (file.includes('/node_modules/')) {
-                    return emptyModule(file, importer);
-                }
-                // When a library is symlinked, it lives outside `root`.
-                assertPosixPath(config.root);
-                if (!file.startsWith(config.root)) {
-                    return emptyModule(file, importer);
-                }
-                return appendExtractAssetsQuery(file, importer);
+            resolveId: {
+                async handler(source, importer, options) {
+                    if (isViteServerSide_extraSafe(config, this.environment, options)) {
+                        // When building for the server, there should never be a `?extractAssets` query
+                        assert(!extractAssetsRE.test(source));
+                        assert(importer === undefined || !extractAssetsRE.test(importer));
+                        return;
+                    }
+                    // If there is no `importer` then `module` is an entry.
+                    // We don't need to append `?extractAssets` to entries because they already have `?extractAssets` as Vike appends `?extractAssets` to entries by using `import.meta.glob('/**/*.page.server.js', { as: "extractAssets" })` (see `generateImportGlobs.ts`).
+                    if (!importer) {
+                        return;
+                    }
+                    // We only append `?extractAssets` if the parent module has `?extractAssets`
+                    if (!extractAssetsRE.test(importer)) {
+                        return;
+                    }
+                    const includeAssetsImportedByServer = resolveIncludeAssetsImportedByServer(vikeConfig.config);
+                    assert(includeAssetsImportedByServer);
+                    let resolution = null;
+                    try {
+                        resolution = await this.resolve(source, importer, { skipSelf: true, ...options });
+                    }
+                    catch { }
+                    // Sometimes Rollup fails to resolve. If it fails to resolve, we assume the dependency to be an npm package and we skip it. (I guess Rollup should always be able to resolve local dependencies?)
+                    if (!resolution)
+                        return emptyModule(source, importer);
+                    const { id: file, external } = resolution;
+                    // Nothing is externalized when building for the client-side
+                    assert(external === false);
+                    // We include:
+                    //  - CSS(/LESS/SCSS/...) files
+                    //  - Asset files (`.svg`, `.pdf`, ...)
+                    //  - URL imports (e.g. `import scriptUrl from './script.js?url.js'`)
+                    if (styleFileRE.test(file) || isAsset(file) || urlRE.test(file)) {
+                        debugOperation('INCLUDED', file, importer);
+                        return resolution;
+                    }
+                    // We erase `source` if its file doesn't contain JavaScript
+                    if (!isScriptFile(file)) {
+                        return emptyModule(file, importer);
+                    }
+                    // If the import path resolves to a file in `node_modules/`, we ignore that file:
+                    //  - Direct CSS dependencies are included though, such as `import 'bootstrap/theme/dark.css'`. (Because the above if-branch for CSS files will add the file.)
+                    //  - Loading CSS from a library (living in `node_modules/`) in a non-direct way is unconventional; we can safely not support this case. (I'm not aware of any library that does this.)
+                    assertPosixPath(file);
+                    if (file.includes('/node_modules/')) {
+                        return emptyModule(file, importer);
+                    }
+                    // When a library is symlinked, it lives outside `root`.
+                    assertPosixPath(config.root);
+                    if (!file.startsWith(config.root)) {
+                        return emptyModule(file, importer);
+                    }
+                    return appendExtractAssetsQuery(file, importer);
+                },
             },
         },
         {
             name: 'vike:pluginExtractAssets-3',
             apply: 'build',
-            load(id) {
-                if (!isVirtualFileId(id))
-                    return undefined;
-                id = removeVirtualFileIdPrefix(id);
-                if (id === EMPTY_MODULE_ID) {
-                    return '// Erased by vike:pluginExtractAssets';
-                }
+            load: {
+                handler(id) {
+                    if (!isVirtualFileId(id))
+                        return undefined;
+                    id = removeVirtualFileIdPrefix(id);
+                    if (id === EMPTY_MODULE_ID) {
+                        return '// Erased by vike:pluginExtractAssets';
+                    }
+                },
             },
-            config() {
-                if (debug.isActivated) {
-                    return { logLevel: 'silent' };
-                }
+            config: {
+                handler() {
+                    if (debug.isActivated) {
+                        return { logLevel: 'silent' };
+                    }
+                },
             },
         },
         {
             name: 'vike:pluginExtractAssets-4',
-            async configResolved(config_) {
-                config = config_;
-                vikeConfig = await getVikeConfigInternal();
-                isFixEnabled = handleAssetsManifest_isFixEnabled();
-                if (!isFixEnabled) {
-                    // https://github.com/vikejs/vike/issues/1060
-                    assertUsage(!config.plugins.find((p) => p.name === 'vite-tsconfig-paths'), 'vite-tsconfig-paths not supported, remove it and use vite.config.js#resolve.alias instead');
-                }
+            configResolved: {
+                async handler(config_) {
+                    config = config_;
+                    vikeConfig = await getVikeConfigInternal();
+                    isFixEnabled = handleAssetsManifest_isFixEnabled();
+                    if (!isFixEnabled) {
+                        // https://github.com/vikejs/vike/issues/1060
+                        assertUsage(!config.plugins.find((p) => p.name === 'vite-tsconfig-paths'), 'vite-tsconfig-paths not supported, remove it and use vite.config.js#resolve.alias instead');
+                    }
+                },
             },
         },
     ];

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

@@ -14,25 +14,33 @@ function pluginExtractExportNames() {
     return {
         name: 'vike:pluginExtractExportNames',
         enforce: 'post',
-        async transform(src, id, options) {
-            id = normalizeId(id);
-            const isClientSide = !isViteServerSide_extraSafe(config, this.environment, options);
-            if (extractExportNamesRE.test(id)) {
-                const code = await getExtractExportNamesCode(src, isClientSide, !isDev, id);
-                debug('id ' + id, ['result:\n' + code.code.trim(), 'src:\n' + src.trim()]);
-                return code;
-            }
+        transform: {
+            async handler(src, id, options) {
+                id = normalizeId(id);
+                const isClientSide = !isViteServerSide_extraSafe(config, this.environment, options);
+                if (extractExportNamesRE.test(id)) {
+                    const code = await getExtractExportNamesCode(src, isClientSide, !isDev, id);
+                    debug('id ' + id, ['result:\n' + code.code.trim(), 'src:\n' + src.trim()]);
+                    return code;
+                }
+            },
         },
-        configureServer() {
-            isDev = true;
+        configureServer: {
+            handler() {
+                isDev = true;
+            },
         },
-        configResolved(config_) {
-            config = config_;
+        configResolved: {
+            handler(config_) {
+                config = config_;
+            },
         },
-        config() {
-            if (debug.isActivated) {
-                return { logLevel: 'silent' };
-            }
+        config: {
+            handler() {
+                if (debug.isActivated) {
+                    return { logLevel: 'silent' };
+                }
+            },
         },
     };
 }

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

@@ -13,68 +13,78 @@ function pluginFileEnv() {
     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);
+        load: {
+            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))
+                    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)
-                    */
+        transform: {
+            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;
-                }
-                assertFileEnv(moduleId, isViteServerSide(config, this.environment), importers, false);
-            });
+                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: {
+            handler() {
+                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_;
+        configResolved: {
+            handler(config_) {
+                config = config_;
+            },
         },
-        configureServer(viteDevServer_) {
-            viteDevServer = viteDevServer_;
+        configureServer: {
+            handler(viteDevServer_) {
+                viteDevServer = viteDevServer_;
+            },
         },
     };
     function assertFileEnv(moduleId, isServerSide, importers, onlyWarn) {

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

@@ -23,27 +23,34 @@ function pluginNonRunnableDev() {
     let config;
     return {
         name: 'vike:pluginNonRunnableDev',
-        configureServer(viteDevServer) {
-            createViteRPC(viteDevServer, getViteRpcFunctions);
+        configureServer: {
+            handler(viteDevServer) {
+                createViteRPC(viteDevServer, getViteRpcFunctions);
+            },
         },
-        configResolved(config_) {
-            config = config_;
+        configResolved: {
+            handler(config_) {
+                config = config_;
+            },
         },
-        transform(code, id) {
-            if (!config._isDev)
-                return;
-            if (id !== distFileIsNonRunnableDev && id !== distFileGlobalContext)
-                return;
-            if (isRunnableDevEnvironment(this.environment))
-                return;
-            const { magicString, getMagicStringResult } = getMagicString(code, id);
-            if (id === distFileIsNonRunnableDev) {
-                magicString.replaceAll('__VIKE__IS_NON_RUNNABLE_DEV', JSON.stringify(true));
-            }
-            if (id === distFileGlobalContext) {
-                magicString.replaceAll('__VIKE__DYNAMIC_IMPORT', 'import');
-            }
-            return getMagicStringResult();
+        transform: {
+            handler(code, id) {
+                if (!config._isDev)
+                    return;
+                const idWithoutQuery = id.split('?')[0];
+                if (idWithoutQuery !== distFileIsNonRunnableDev && idWithoutQuery !== distFileGlobalContext)
+                    return;
+                if (isRunnableDevEnvironment(this.environment))
+                    return;
+                const { magicString, getMagicStringResult } = getMagicString(code, id);
+                if (idWithoutQuery === distFileIsNonRunnableDev) {
+                    magicString.replaceAll('__VIKE__IS_NON_RUNNABLE_DEV', JSON.stringify(true));
+                }
+                if (idWithoutQuery === distFileGlobalContext) {
+                    magicString.replaceAll('__VIKE__DYNAMIC_IMPORT', 'import');
+                }
+                return getMagicStringResult();
+            },
         },
     };
 }

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

@@ -14,32 +14,38 @@ function pluginPreview() {
     return {
         name: 'vike:pluginPreview',
         apply: applyPreview,
-        config() {
-            return {
-                appType: 'custom',
-            };
+        config: {
+            handler() {
+                return {
+                    appType: 'custom',
+                };
+            },
         },
-        async configResolved(config_) {
-            config = config_;
-            vikeConfig = await getVikeConfigInternal();
-            logDockerHint(config.preview.host);
-            // vikeConfig = await getVikeConfig(config)
+        configResolved: {
+            async handler(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);
-            };
+        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);
+                };
+            },
         },
     };
     function assertDist(isPrerenderingEnabledForAllPages) {

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

@@ -9,41 +9,49 @@ function pluginReplaceConstants() {
         name: 'vike:pluginReplaceConstants',
         enforce: 'post',
         apply: 'build',
-        configResolved(config_) {
-            config = config_;
+        configResolved: {
+            handler(config_) {
+                config = config_;
+            },
         },
-        transform(code, id, options) {
-            id = normalizeId(id);
-            assertPosixPath(id);
-            if (id.includes('/node_modules/'))
-                return;
-            assertPosixPath(config.root);
-            if (!id.startsWith(config.root))
-                return;
-            if (!code.includes('import.meta.env.'))
-                return;
-            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);
-            const constantsMap = [];
-            constantsMap.push({
-                constants: ['pageContext.isClientSide', 'globalContext.isClientSide', 'pageContext.globalContext.isClientSide'],
-                replacement: !isViteServerSide_extraSafe(config, this.environment, options),
-            });
-            constantsMap.forEach(({ constants, replacement }) => {
-                if (!constants.some((c) => code.includes(c)))
+        transform: {
+            handler(code, id, options) {
+                id = normalizeId(id);
+                assertPosixPath(id);
+                if (id.includes('/node_modules/'))
                     return;
-                const regExp = getConstantRegExp(constants);
-                magicString.replaceAll(regExp, JSON.stringify(replacement));
-            });
-            if (!magicString.hasChanged())
-                return null;
-            return getMagicStringResult();
+                assertPosixPath(config.root);
+                if (!id.startsWith(config.root))
+                    return;
+                if (!code.includes('import.meta.env.'))
+                    return;
+                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);
+                const constantsMap = [];
+                constantsMap.push({
+                    constants: [
+                        'pageContext.isClientSide',
+                        'globalContext.isClientSide',
+                        'pageContext.globalContext.isClientSide',
+                    ],
+                    replacement: !isViteServerSide_extraSafe(config, this.environment, options),
+                });
+                constantsMap.forEach(({ constants, replacement }) => {
+                    if (!constants.some((c) => code.includes(c)))
+                        return;
+                    const regExp = getConstantRegExp(constants);
+                    magicString.replaceAll(regExp, JSON.stringify(replacement));
+                });
+                if (!magicString.hasChanged())
+                    return null;
+                return getMagicStringResult();
+            },
         },
     };
 }

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',