vike 0.4.266 → 0.4.267-commit-7884d91

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

@@ -12,6 +12,8 @@ import { getAssetsDir } from '../../shared/getAssetsDir.js';
 import { assertModuleId, getFilePathToShowToUserModule } from '../../shared/getFilePath.js';
 import '../../assertEnvVite.js';
 import { isVite8OrAbove } from '../../shared/isVite8OrAbove.js';
+import { isViteServerSide_configEnvironment } from '../../shared/isViteServerSide.js';
+import { getVikeConfigInternal } from '../../shared/resolveVikeConfigInternal.js';
 function pluginDistFileNames() {
     return [
         {
@@ -19,42 +21,65 @@ function pluginDistFileNames() {
             apply: 'build',
             enforce: 'post',
             configResolved: {
-                handler(config) {
-                    const rollupOutputs = getRollupOutputs(config);
-                    // We need to support multiple outputs: @vite/plugin-legacy adds an output, see https://github.com/vikejs/vike/issues/477#issuecomment-1406434802
-                    rollupOutputs.forEach((rollupOutput) => {
-                        if (!('entryFileNames' in rollupOutput)) {
-                            rollupOutput.entryFileNames = (chunkInfo) => getEntryFileName(chunkInfo, config, true);
-                        }
-                        if (!('chunkFileNames' in rollupOutput)) {
-                            rollupOutput.chunkFileNames = (chunkInfo) => getChunkFileName(chunkInfo, config);
-                        }
-                        if (!('assetFileNames' in rollupOutput)) {
-                            rollupOutput.assetFileNames = (chunkInfo) => getAssetFileName(chunkInfo, config);
-                            rollupOutput.assetFileNames.isTheOneSetByVike = true;
-                            assert(rollupOutput.assetFileNames.isTheOneSetByVike);
-                        }
-                        else {
-                            // If a user needs this:
-                            //  - assertUsage() that the naming provided by the user ends with `.[hash][extname]`
-                            //    - It's needed for getHash() of handleAssetsManifest()
-                            //    - Asset URLs should always contain a hash: it's paramount for caching assets.
-                            //    - If rollupOutput.assetFileNames is a function then use a wrapper function to apply the assertUsage()
-                            assertUsage(rollupOutput.assetFileNames.isTheOneSetByVike, "Setting Vite's configuration build.rollupOptions.output.assetFileNames is currently forbidden. Reach out if you need to use it.");
-                        }
+                async handler(config) {
+                    const { _additionalEnvironmentNames: additionalEnvironmentNames } = await getVikeConfigInternal();
+                    Object.entries(config.environments).forEach(([envName, envConfig]) => {
+                        // Vike doesn't own the builds of additional environments (e.g. `rsc`): it only emits `entry-environment.mjs` there
+                        if (additionalEnvironmentNames.includes(envName))
+                            return;
+                        const { build } = envConfig;
+                        copyRollupOutputs(build);
+                        const isServerSide = isViteServerSide_configEnvironment(envName, envConfig);
+                        setFileNames(config, build, isServerSide, envName);
+                        disableCSSBundling(config, build);
                     });
-                    disableCSSBundling(config);
                 },
             },
         },
     ];
 }
+function setFileNames(config, build, isServerSide, envName) {
+    const rollupOutputs = getRollupOutputs(build);
+    // We need to support multiple outputs: @vite/plugin-legacy adds an output, see https://github.com/vikejs/vike/issues/477#issuecomment-1406434802
+    rollupOutputs.forEach((rollupOutput) => {
+        // Server environments other than `ssr` keep their own entry file names, e.g. @vitejs/plugin-rsc imports its `rsc` entry as `index.js`
+        if (!('entryFileNames' in rollupOutput) && (!isServerSide || envName === 'ssr')) {
+            rollupOutput.entryFileNames = (chunkInfo) => getEntryFileName(chunkInfo, config, build, isServerSide);
+        }
+        if (!('chunkFileNames' in rollupOutput)) {
+            rollupOutput.chunkFileNames = (chunkInfo) => getChunkFileName(chunkInfo, build, isServerSide);
+        }
+        if (!('assetFileNames' in rollupOutput)) {
+            rollupOutput.assetFileNames = (chunkInfo) => getAssetFileName(chunkInfo, config, build);
+            rollupOutput.assetFileNames.isTheOneSetByVike = true;
+            assert(rollupOutput.assetFileNames.isTheOneSetByVike);
+        }
+        else {
+            // If a user needs this:
+            //  - assertUsage() that the naming provided by the user ends with `.[hash][extname]`
+            //    - It's needed for getHash() of handleAssetsManifest()
+            //    - Asset URLs should always contain a hash: it's paramount for caching assets.
+            //    - If rollupOutput.assetFileNames is a function then use a wrapper function to apply the assertUsage()
+            assertUsage(rollupOutput.assetFileNames.isTheOneSetByVike, "Setting Vite's configuration build.rollupOptions.output.assetFileNames is currently forbidden. Reach out if you need to use it.");
+        }
+    });
+}
+// Vike sets entryFileNames/chunkFileNames/assetFileNames on an output object only if the user didn't set them. But the user's output object can be:
+// - The same object for several environments.
+// - Reused across Vite's config resolutions, e.g. an inline config such as VITE_CONFIG.
+// Without a copy, the file names Vike sets for one environment look user-set to the next environment, which then keeps the wrong environment's file names.
+function copyRollupOutputs(build) {
+    const { output } = build.rollupOptions;
+    if (!output)
+        return;
+    build.rollupOptions.output = isArray(output) ? output.map((o) => ({ ...o })) : { ...output };
+}
 function getIdHash(id) {
     return crypto.createHash('md5').update(id).digest('hex').slice(0, 8);
 }
-function getAssetFileName(assetInfo, config) {
+function getAssetFileName(assetInfo, config, build) {
     const userRootDir = config.root;
-    const assetsDir = getAssetsDir(config);
+    const assetsDir = getAssetsDir(build);
     const dir = assetsDir + '/static';
     let { name } = assetInfo;
     if (!name) {
@@ -78,19 +103,19 @@ function getAssetFileName(assetInfo, config) {
     name = clean(name, userRootDir);
     return `${dir}/${name}.[hash][extname]`;
 }
-function getChunkFileName(_chunkInfo, config) {
-    const isForClientSide = !config.build.ssr;
+function getChunkFileName(_chunkInfo, build, isServerSide) {
+    const isForClientSide = !isServerSide;
     let name = 'chunks/chunk-[hash].js';
     if (isForClientSide) {
-        const assetsDir = getAssetsDir(config);
+        const assetsDir = getAssetsDir(build);
         name = `${assetsDir}/${name}`;
     }
     return name;
 }
-function getEntryFileName(chunkInfo, config, isEntry) {
+function getEntryFileName(chunkInfo, config, build, isServerSide) {
     const userRootDir = config.root;
-    const assetsDir = getAssetsDir(config);
-    const isForClientSide = !config.build.ssr;
+    const assetsDir = getAssetsDir(build);
+    const isForClientSide = !isServerSide;
     let { name } = chunkInfo;
     assertPosixPath(name);
     name = clean(name, userRootDir, true, 
@@ -100,7 +125,7 @@ function getEntryFileName(chunkInfo, config, isEntry) {
         return `${assetsDir}/${name}.[hash].js`;
     }
     else {
-        return `${name}.${isEntry ? 'mjs' : 'js'}`;
+        return `${name}.mjs`;
     }
 }
 function removePathSeparators(name) {
@@ -188,9 +213,9 @@ function workaroundGlob(name) {
     return name;
 }
 // Workaround for Vite CSS duplication bug: https://github.com/vikejs/vike/issues/1815
-function disableCSSBundling(config) {
+function disableCSSBundling(config, build) {
     if (isVite8OrAbove(config)) {
-        for (const output of getRolldownOutputs(config)) {
+        for (const output of getRolldownOutputs(build)) {
             assert(output);
             const { codeSplitting } = output;
             // `codeSplitting: false` => single-bundle mode; respect the user's choice.
@@ -219,7 +244,7 @@ function disableCSSBundling(config) {
         }
     }
     else {
-        for (const output of getRollupOutputs(config)) {
+        for (const output of getRollupOutputs(build)) {
             assert(output);
             wrapManualChunks(output, config, 'rollupOptions');
         }
@@ -291,28 +316,23 @@ function getCssChunkName(id, config) {
         return `${name}-${hash}`;
     }
 }
-function getRollupOutputs(config) {
-    var _a, _b;
-    // @ts-expect-error is read-only
-    config.build ?? (config.build = {});
-    (_a = config.build).rollupOptions ?? (_a.rollupOptions = {});
-    (_b = config.build.rollupOptions).output ?? (_b.output = {});
-    const { output } = config.build.rollupOptions;
+function getRollupOutputs(build) {
+    var _a;
+    (_a = build.rollupOptions).output ?? (_a.output = {});
+    const { output } = build.rollupOptions;
     if (!isArray(output)) {
         return [output];
     }
     return output;
 }
-function getRolldownOutputs(config) {
-    var _a, _b;
-    // @ts-expect-error is read-only
-    config.build ?? (config.build = {});
+function getRolldownOutputs(build) {
+    var _a;
     // @ts-ignore
-    (_a = config.build).rolldownOptions ?? (_a.rolldownOptions = {});
+    build.rolldownOptions ?? (build.rolldownOptions = {});
     // @ts-ignore
-    (_b = config.build.rolldownOptions).output ?? (_b.output = {});
+    (_a = build.rolldownOptions).output ?? (_a.output = {});
     // @ts-ignore
-    const { output } = config.build.rolldownOptions;
+    const { output } = build.rolldownOptions;
     if (!isArray(output)) {
         return [output];
     }

package/dist/node/vite/plugins/build/pluginEnvironmentEntries.d.ts

@@ -0,0 +1,6 @@
+export { pluginEnvironmentEntries };
+export { getEnvironmentEntryPlaceholder };
+import type { Plugin } from 'vite';
+import '../../assertEnvVite.js';
+declare function pluginEnvironmentEntries(): Plugin[];
+declare function getEnvironmentEntryPlaceholder(environmentName: string): string;

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

@@ -0,0 +1,71 @@
+export { pluginEnvironmentEntries };
+export { getEnvironmentEntryPlaceholder };
+// Vike's server environment imports the global entry of every additional environment (e.g. `rsc`), see loadPageContextEnvironments.ts
+// - An additional environment is a separate build, so the server imports its entry by a path relative to the importing chunk, which is known only after chunking (the same marker + renderChunk() as @vitejs/plugin-rsc's import.meta.viteRsc.loadModule())
+import { assertUsage } from '../../../../utils/assert.js';
+import { generateVirtualFileIdAdditionalEnvironment } from '../../../../shared-server-node/virtualFileId.js';
+import { getVikeConfigInternal } from '../../shared/resolveVikeConfigInternal.js';
+import { getMagicString } from '../../shared/getMagicString.js';
+import path from 'node:path';
+import '../../assertEnvVite.js';
+const environmentEntryFileName = 'entry-environment.mjs';
+const environmentEntryPlaceholder = '__VIKE_ENVIRONMENT_ENTRY__';
+const environmentEntryPlaceholderRegex = new RegExp(`(["'\`])${environmentEntryPlaceholder}:(.+?)\\1`, 'g');
+function pluginEnvironmentEntries() {
+    return [
+        {
+            name: 'vike:build:emitEnvironmentEntry',
+            apply: 'build',
+            buildStart: {
+                async handler() {
+                    const { name, config } = this.environment;
+                    const { _additionalEnvironmentNames: additionalEnvironmentNames } = await getVikeConfigInternal();
+                    if (!additionalEnvironmentNames.includes(name))
+                        return;
+                    assertUsage(config.consumer === 'server', `The Vike environment ${name} should be a server-side Vite environment`);
+                    this.emitFile({
+                        type: 'chunk',
+                        id: generateVirtualFileIdAdditionalEnvironment(name),
+                        fileName: environmentEntryFileName,
+                    });
+                },
+            },
+        },
+        {
+            name: 'vike:build:linkEnvironmentEntries',
+            apply: 'build',
+            resolveId: {
+                filter: { id: new RegExp(`^${environmentEntryPlaceholder}:`) },
+                handler(id) {
+                    return { id, external: true };
+                },
+            },
+            renderChunk: {
+                handler(code, chunk) {
+                    return replaceEnvironmentEntryPlaceholders(code, chunk.fileName, this.environment);
+                },
+            },
+        },
+    ];
+}
+// The import specifier of the environment's entry, replaced by its relative path once the importer's location is known
+function getEnvironmentEntryPlaceholder(environmentName) {
+    return `${environmentEntryPlaceholder}:${environmentName}`;
+}
+// Replace each placeholder with the path of the environment's entry, relative to the chunk
+function replaceEnvironmentEntryPlaceholders(code, chunkFileName, environment) {
+    if (!code.includes(environmentEntryPlaceholder))
+        return;
+    const { config } = environment;
+    const chunkDir = path.dirname(path.resolve(config.root, config.build.outDir, chunkFileName));
+    const { magicString, getMagicStringResult } = getMagicString(code, chunkFileName);
+    for (const match of code.matchAll(environmentEntryPlaceholderRegex)) {
+        const outDir = config.environments[match[2]].build.outDir;
+        const environmentEntry = path.resolve(config.root, outDir, environmentEntryFileName);
+        let importPath = path.relative(chunkDir, environmentEntry).split(path.sep).join('/');
+        if (!importPath.startsWith('.'))
+            importPath = `./${importPath}`;
+        magicString.overwrite(match.index, match.index + match[0].length, JSON.stringify(importPath));
+    }
+    return getMagicStringResult();
+}

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

@@ -9,23 +9,25 @@ function pluginSuppressRollupWarning() {
             enforce: 'post',
             configResolved: {
                 async handler(config) {
-                    const onWarnOriginal = config.build.rollupOptions.onwarn;
-                    config.build.rollupOptions.onwarn = function (warning, warn) {
-                        // Suppress
-                        if (suppressUnusedImport(warning))
-                            return;
-                        if (suppressEmptyBundle(warning))
-                            return;
-                        if (suppressUseClientDirective(warning))
-                            return;
-                        // Pass through
-                        if (onWarnOriginal) {
-                            onWarnOriginal.apply(this, arguments);
-                        }
-                        else {
-                            warn(warning);
-                        }
-                    };
+                    Object.values(config.environments).forEach(({ build }) => {
+                        const onWarnOriginal = build.rollupOptions.onwarn;
+                        build.rollupOptions.onwarn = function (warning, warn) {
+                            // Suppress
+                            if (suppressUnusedImport(warning))
+                                return;
+                            if (suppressEmptyBundle(warning))
+                                return;
+                            if (suppressUseClientDirective(warning))
+                                return;
+                            // Pass through
+                            if (onWarnOriginal) {
+                                onWarnOriginal.apply(this, arguments);
+                            }
+                            else {
+                                warn(warning);
+                            }
+                        };
+                    });
                 },
             },
         },

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

@@ -8,11 +8,11 @@ import { isObject } from '../../../utils/isObject.js';
 import { assertRollupInput } from './build/pluginBuildConfig.js';
 import pc from '@brillout/picocolors';
 import { assertResolveAlias } from './pluginCommon/assertResolveAlias.js';
-import { getVikeConfigInternal, setVikeConfigContext } from '../shared/resolveVikeConfigInternal.js';
+import { getVikeConfigInternal, setVikeConfigContext, setViteEnvironmentNames, } from '../shared/resolveVikeConfigInternal.js';
 import { assertViteRoot, getViteRoot, normalizeViteRoot } from '../../api/resolveViteConfigUser.js';
 import { temp_disablePrerenderAutoRun } from '../../prerender/context.js';
 import { resolvePrerenderConfigGlobal, isDistServerRemoved } from '../../prerender/resolvePrerenderConfig.js';
-import { version as viteVersionVike } from 'vite';
+import { assertViteVersion } from '../../../utils/assertViteVersion.js';
 import '../assertEnvVite.js';
 const pluginName = 'vike:pluginCommon';
 globalThis.__VIKE__IS_PROCESS_SHARED_WITH_VITE = true;
@@ -24,7 +24,9 @@ function pluginCommon(vikeVitePluginOptions) {
             config: {
                 order: 'pre',
                 async handler(configFromUser, env) {
-                    const viteVersionUser = this?.meta?.viteVersion; // is `undefined` on old Vite versions
+                    // `this` is `undefined` on Vite 6 or older
+                    const viteVersion = this?.meta.viteVersion;
+                    assertViteVersion(viteVersion);
                     const isDev = isDevCheck(env);
                     const isBuild = env.command === 'build';
                     const isPreview = env.isPreview;
@@ -38,7 +40,7 @@ function pluginCommon(vikeVitePluginOptions) {
                     const vikeConfig = await getVikeConfigInternal();
                     return {
                         _isDev: isDev,
-                        _viteVersionResolved: viteVersionUser || viteVersionVike,
+                        _viteVersionResolved: viteVersion,
                         _rootResolvedEarly: rootResolvedEarly,
                         // TO-DO/next-major-release: remove https://github.com/vikejs/vike/issues/2122
                         configVikePromise: Promise.resolve({
@@ -52,9 +54,10 @@ function pluginCommon(vikeVitePluginOptions) {
         {
             name: pluginName,
             configResolved: {
-                handler(config) {
+                async handler(config) {
                     assertViteRoot(config._rootResolvedEarly, config);
                     assertSingleInstance(config);
+                    await setViteEnvironmentNames(Object.keys(config.environments));
                 },
             },
         },
@@ -72,7 +75,7 @@ function pluginCommon(vikeVitePluginOptions) {
                     overrideViteDefaultSsrExternal(config)
                     //*/
                     workaroundCI(config);
-                    assertRollupInput(config);
+                    assertRollupInput(config.build.rollupOptions.input);
                     assertResolveAlias(config);
                     temp_supportOldInterface(config);
                     await emitServerEntryOnlyIfNeeded(config);

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

@@ -15,6 +15,7 @@ import { requireResolveOptional } from '../../../../utils/requireResolve.js';
 import { setTimeoutUnref } from '../../../../utils/setTimeoutUnref.js';
 import { isObject } from '../../../../utils/isObject.js';
 import { toPosixPath } from '../../../../utils/path.js';
+import { PROJECT_VERSION } from '../../../../utils/PROJECT_VERSION.js';
 import { unique } from '../../../../utils/unique.js';
 import { getVikeConfigInternal } from '../../shared/resolveVikeConfigInternal.js';
 import { getCacheValue, setCacheValue } from '../../shared/cache.js';
@@ -37,7 +38,7 @@ const skillName = 'vike';
 // The skill file shipped by the vike npm package: node_modules/vike/skills/vike/SKILL.md (see packages/vike/scripts/copySkill.mjs)
 const skillFilePathInsidePackage = 'skills/vike/SKILL.md';
 // Cache entry at node_modules/.vike/cache.json, see cache.ts
-// - `false` => the check didn't log anything last time => skip the check (forever, until node_modules/ is removed)
+// - `{ skip: true, version }` => the check didn't log anything last time, with that Vike version => skip the check until Vike is upgraded (the official skill file may change between Vike versions) or node_modules/ is removed
 // - Nothing is written as long as the hint is logged => the check is re-run upon every dev start
 const cacheKey = 'logSkillHint';
 // Log a hint if the user didn't install Vike's skill for AI agents (vike/SKILL.md), or if it differs from the official one — https://vike.dev/ai#skill
@@ -95,8 +96,9 @@ async function checkSkillUnsafe(userRootDir) {
     if (!getConfigValueAiSkill(vikeConfig))
         return;
     globalObject.alreadyChecked = true;
-    // The check is skipped forever once it didn't log anything (until node_modules/ is removed) — see cacheKey
-    if ((await getCacheValue(userRootDir, cacheKey)) === false)
+    // The check is skipped once it didn't log anything, until Vike is upgraded (or node_modules/ is removed) — see cacheKey
+    const cached = await getCacheValue(userRootDir, cacheKey);
+    if (isObject(cached) && cached.skip === true && cached.version === PROJECT_VERSION)
         return;
     const skillState = await getSkillState(userRootDir);
     if (skillState.state === 'missing') {
@@ -110,7 +112,7 @@ async function checkSkillUnsafe(userRootDir) {
     if (skillState.state === 'installed' ||
         skillState.state === 'not-using-ai-agents' ||
         skillState.state === 'vike-not-from-npm') {
-        await setCacheValue(userRootDir, cacheKey, false);
+        await setCacheValue(userRootDir, cacheKey, { skip: true, version: PROJECT_VERSION });
         return;
     }
     checkType(skillState);

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

@@ -191,7 +191,7 @@ async function getPageDeps(config, pageConfigs, pageConfigGlobal) {
             [...pageConfigs, pageConfigGlobal].forEach((pageConfig) => {
                 Object.entries(pageConfig.configValueSources).forEach(([configName]) => {
                     const runtimeEnv = {
-                        isForClientSide,
+                        environmentName: isForClientSide ? 'client' : 'server',
                         isDev: true,
                         // TO-DO/eventually/remove-server-router: let's eventually remove support for Server Routing
                         isClientRouting: true,

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

@@ -16,7 +16,10 @@ const filterRolldown = {
         include: new RegExp(escapeRegex(VIRTUAL_FILE_ID_constantsGlobalThis)),
     },
 };
-const filterFunction = (id) => id === VIRTUAL_FILE_ID_constantsGlobalThis || id === addVirtualFileIdPrefix(VIRTUAL_FILE_ID_constantsGlobalThis);
+const filterFunction = (id) => id === VIRTUAL_FILE_ID_constantsGlobalThis ||
+    // Vite re-resolves the resolved ID and its URL when a plugin adds the module as a watch file (@vitejs/plugin-rsc)
+    id === addVirtualFileIdPrefix(VIRTUAL_FILE_ID_constantsGlobalThis) ||
+    id === `/@id/__x00__${VIRTUAL_FILE_ID_constantsGlobalThis}`;
 // ===
 function pluginReplaceConstantsGlobalThis() {
     let config;
@@ -63,9 +66,8 @@ function pluginReplaceConstantsGlobalThis() {
             resolveId: {
                 filter: filterRolldown,
                 handler(id) {
-                    assert(filterFunction(id));
-                    assert(id === VIRTUAL_FILE_ID_constantsGlobalThis);
-                    return addVirtualFileIdPrefix(id);
+                    assert(filterFunction(id), { id });
+                    return addVirtualFileIdPrefix(VIRTUAL_FILE_ID_constantsGlobalThis);
                 },
             },
             load: {

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

@@ -1,7 +1,7 @@
 export { pluginUniversalDeploy };
 import { toRou3 } from 'convert-route';
 import { addEntry } from '@universal-deploy/store';
-import universalDeploy, { resolveTargets } from '@universal-deploy/vite';
+import universalDeploy, { precompress, resolveTargets } from '@universal-deploy/vite';
 import { pluginServerEntryInject } from './pluginUniversalDeploy/pluginServerEntryInject.js';
 import { getDeployConfig } from './pluginUniversalDeploy/getDeployConfig.js';
 import { pluginCommon } from './pluginUniversalDeploy/common.js';
@@ -23,10 +23,11 @@ function pluginUniversalDeploy(vikeConfig) {
                 const target = targets.filter((t) => t !== '@cloudflare/vite-plugin')[0];
                 assertUsage(target === undefined, `${target} requires +server — see https://vike.dev/server`);
             }),
+            precompress(vikeConfig.config.precompress),
         ];
     const { serverEntryVike, serverEntryId, serverFilePath } = serverConfig;
     return [
-        ...universalDeploy(),
+        ...universalDeploy({ node: { precompress: vikeConfig.config.precompress } }),
         {
             name: 'vike:pluginUniversalDeploy:entries',
             config() {

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

@@ -1,3 +1,4 @@
 export { generateVirtualFileGlobalEntry };
+import type { RuntimeEnvRuntime } from './getConfigValueSourcesRelevant.js';
 import '../../assertEnvVite.js';
-declare function generateVirtualFileGlobalEntry(isForClientSide: boolean, isDev: boolean, id: string, isClientRouting: boolean): Promise<string>;
+declare function generateVirtualFileGlobalEntry(runtimeEnv: RuntimeEnvRuntime, id: string): Promise<string>;

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

@@ -4,25 +4,31 @@ 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';
+import { getEnvironmentEntryPlaceholder } from '../build/pluginEnvironmentEntries.js';
 import '../../assertEnvVite.js';
-async function generateVirtualFileGlobalEntry(isForClientSide, isDev, id, isClientRouting) {
+async function generateVirtualFileGlobalEntry(runtimeEnv, id) {
     const vikeConfig = await getVikeConfigInternal(true);
-    const { _pageConfigs: pageConfigs, _pageConfigGlobal: pageConfigGlobal } = vikeConfig;
-    return getCode(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, isClientRouting);
+    const { _pageConfigs: pageConfigs, _pageConfigGlobal: pageConfigGlobal, _additionalEnvironmentNames: additionalEnvironmentNames, } = vikeConfig;
+    return getCode(pageConfigs, pageConfigGlobal, runtimeEnv, id, additionalEnvironmentNames);
 }
-function getCode(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, isClientRouting) {
+function getCode(pageConfigs, pageConfigGlobal, runtimeEnv, id, additionalEnvironmentNames) {
     const lines = [];
     const importStatements = [];
     const filesEnv = new Map();
+    const { environmentName, isDev } = runtimeEnv;
+    const isForClientSide = environmentName === 'client';
     if (!isForClientSide) {
         importStatements.push(`import '${VIRTUAL_FILE_ID_constantsGlobalThis}';`);
     }
     lines.push('export const pageConfigsSerialized = [');
-    lines.push(getCodePageConfigsSerialized(pageConfigs, isForClientSide, isClientRouting, isDev, importStatements, filesEnv));
+    lines.push(getCodePageConfigsSerialized(pageConfigs, runtimeEnv, importStatements, filesEnv));
     lines.push('];');
     lines.push('export const pageConfigGlobalSerialized = {');
-    lines.push(getCodePageConfigGlobalSerialized(pageConfigGlobal, isForClientSide, isClientRouting, isDev, importStatements, filesEnv));
+    lines.push(getCodePageConfigGlobalSerialized(pageConfigGlobal, runtimeEnv, importStatements, filesEnv));
     lines.push('};');
+    if (environmentName === 'server') {
+        lines.push(getCodeEnvironmentEntries(additionalEnvironmentNames, isDev, importStatements));
+    }
     if (!isForClientSide && isDev) {
         // https://vite.dev/guide/api-environment-frameworks.html
         lines.push('if (import.meta.hot) import.meta.hot.accept();');
@@ -31,10 +37,21 @@ function getCode(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, isCl
     if (!isForClientSide) {
         code = `import '${VIRTUAL_FILE_ID_constantsGlobalThis}';\n` + code;
     }
-    debug(id, isForClientSide ? 'CLIENT-SIDE' : 'SERVER-SIDE', code);
+    debug(id, `${environmentName.toUpperCase()}-SIDE`, code);
     return code;
 }
-function getCodePageConfigsSerialized(pageConfigs, isForClientSide, isClientRouting, isDev, importStatements, filesEnv) {
+// The global entries of the additional environments (e.g. `rsc`), loaded by loadPageContextEnvironments.ts
+// - In development, they're loaded with the environment's module runner instead
+function getCodeEnvironmentEntries(additionalEnvironmentNames, isDev, importStatements) {
+    const entries = additionalEnvironmentNames.map((name, i) => {
+        if (isDev)
+            return `${JSON.stringify(name)}: null`;
+        importStatements.push(`import * as environmentEntry${i} from ${JSON.stringify(getEnvironmentEntryPlaceholder(name))};`);
+        return `${JSON.stringify(name)}: environmentEntry${i}`;
+    });
+    return `export const environmentEntries = { ${entries.join(', ')} };`;
+}
+function getCodePageConfigsSerialized(pageConfigs, runtimeEnv, importStatements, filesEnv) {
     const lines = [];
     pageConfigs.forEach((pageConfig) => {
         const { pageId, routeFilesystem, isErrorPage } = pageConfig;
@@ -42,20 +59,20 @@ function getCodePageConfigsSerialized(pageConfigs, isForClientSide, isClientRout
         lines.push(`    pageId: ${JSON.stringify(pageId)},`);
         lines.push(`    isErrorPage: ${JSON.stringify(isErrorPage)},`);
         lines.push(`    routeFilesystem: ${JSON.stringify(routeFilesystem)},`);
-        const virtualFileId = JSON.stringify(generateVirtualFileId({ type: 'page-entry', pageId, isForClientSide }));
+        const virtualFileId = JSON.stringify(generateVirtualFileId({ type: 'page-entry', pageId, environmentName: runtimeEnv.environmentName }));
         lines.push(`    loadVirtualFilePageEntry: () => ({ moduleId: ${virtualFileId}, moduleExportsPromise: import(${virtualFileId}) }),`);
         lines.push(`    configValuesSerialized: {`);
-        lines.push(...serializeConfigValues(pageConfig, importStatements, filesEnv, { isForClientSide, isClientRouting, isDev }, '    ', true));
+        lines.push(...serializeConfigValues(pageConfig, importStatements, filesEnv, runtimeEnv, '    ', true));
         lines.push(`    },`);
         lines.push(`  },`);
     });
     const code = lines.join('\n');
     return code;
 }
-function getCodePageConfigGlobalSerialized(pageConfigGlobal, isForClientSide, isClientRouting, isDev, importStatements, filesEnv) {
+function getCodePageConfigGlobalSerialized(pageConfigGlobal, runtimeEnv, importStatements, filesEnv) {
     const lines = [];
     lines.push(`  configValuesSerialized: {`);
-    lines.push(...serializeConfigValues(pageConfigGlobal, importStatements, filesEnv, { isForClientSide, isClientRouting, isDev }, '    ', null));
+    lines.push(...serializeConfigValues(pageConfigGlobal, importStatements, filesEnv, runtimeEnv, '    ', null));
     lines.push(`  },`);
     const code = lines.join('\n');
     return code;

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

@@ -18,7 +18,8 @@ import '../../assertEnvVite.js';
 async function generateVirtualFileGlobalEntryWithOldDesign(id, options, config, env, isDev) {
     const idParsed = parseVirtualFileId(id);
     assert(idParsed && idParsed.type === 'global-entry');
-    const { isForClientSide, isClientRouting } = idParsed;
+    const { environmentName, isClientRouting } = idParsed;
+    const isForClientSide = environmentName === 'client';
     assert(isForClientSide === !isViteServerSide_extraSafe(config, env, options));
     const code = await getCode(config, isForClientSide, isClientRouting, isDev, id);
     return code;
@@ -75,7 +76,7 @@ export const pageFilesExportNamesEager = {};
 export const pageFilesList = [];
 export const neverLoaded = {};
 
-${await generateVirtualFileGlobalEntry(isForClientSide, isDev, id, isClientRouting)}
+${await generateVirtualFileGlobalEntry({ environmentName: isForClientSide ? 'client' : 'server', isClientRouting, isDev }, id)}
 
 `;
     const vikeConfig = await getVikeConfigInternal();

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

@@ -18,7 +18,7 @@ async function generateVirtualFilePageEntry(id, isDev) {
       assert(result.isForClientSide === isForClientSide)
     }
     */
-    const { pageId, isForClientSide } = result;
+    const { pageId, environmentName } = result;
     const vikeConfig = await getVikeConfigInternal(true);
     const { _pageConfigs: pageConfigs } = vikeConfig;
     const pageConfig = pageConfigs.find((pageConfig) => pageConfig.pageId === pageId);
@@ -31,20 +31,20 @@ async function generateVirtualFilePageEntry(id, isDev) {
             throw getProjectError(`Outdated request. Try again. ${getDebugInfoStr({ id, pageId })}`);
         }
     }
-    const code = getCode(pageConfig, isForClientSide, pageId, resolveIncludeAssetsImportedByServer(vikeConfig.config), isDev);
-    debug(id, isForClientSide ? 'CLIENT-SIDE' : 'SERVER-SIDE', code);
+    const code = getCode(pageConfig, environmentName, pageId, resolveIncludeAssetsImportedByServer(vikeConfig.config), isDev);
+    debug(id, `${environmentName.toUpperCase()}-SIDE`, code);
     return code;
 }
-function getCode(pageConfig, isForClientSide, pageId, includeAssetsImportedByServer, isDev) {
+function getCode(pageConfig, environmentName, pageId, includeAssetsImportedByServer, isDev) {
     const lines = [];
     const importStatements = [];
     const filesEnv = new Map();
     const isClientRouting = getConfigValueBuildTime(pageConfig, 'clientRouting', 'boolean')?.value ?? false;
     lines.push('export const configValuesSerialized = {');
-    lines.push(...serializeConfigValues(pageConfig, importStatements, filesEnv, { isForClientSide, isClientRouting, isDev }, '', false));
+    lines.push(...serializeConfigValues(pageConfig, importStatements, filesEnv, { environmentName, isClientRouting, isDev }, '', false));
     lines.push('};');
-    if (!handleAssetsManifest_isFixEnabled() && includeAssetsImportedByServer && isForClientSide && !isDev) {
-        importStatements.push(`import '${extractAssetsAddQuery(generateVirtualFileId({ type: 'page-entry', pageId, isForClientSide: false }))}'`);
+    if (!handleAssetsManifest_isFixEnabled() && includeAssetsImportedByServer && environmentName === 'client' && !isDev) {
+        importStatements.push(`import '${extractAssetsAddQuery(generateVirtualFileId({ type: 'page-entry', pageId, environmentName: 'server' }))}'`);
     }
     const code = [...importStatements, ...lines].join('\n');
     return code;