vike 0.4.160 → 0.4.161

package/dist/cjs/utils/sorter.js

@@ -1,10 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeLast = exports.makeFirst = exports.lowerFirst = exports.higherFirst = void 0;
+exports.reverse = exports.makeLast = exports.makeFirst = exports.lowerFirst = exports.higherFirst = void 0;
 const assert_js_1 = require("./assert.js");
 // -1 => element1 first (i.e. `indexOf(element1) < indexOf(element2)`)
 // +1 => element2 first (i.e. `indexOf(element2) < indexOf(element1)`)
 // 0 => keep original order of element1 and element2
+/**
+ * ```js
+ * let arr = [
+ *   { price: 10 },
+ *   { price: 1000 },
+ *   { price: 100 }
+ * ]
+ * arr = arr.sort(higherFirst(el => el.price))
+ * isEqual(arr, [
+ *   { price: 1000 },
+ *   { price: 100 },
+ *   { price: 10 }
+ * ])
+ * ```
+ */
 function higherFirst(getValue) {
     return (element1, element2) => {
         const val1 = getValue(element1);
@@ -16,6 +31,21 @@ function higherFirst(getValue) {
     };
 }
 exports.higherFirst = higherFirst;
+/**
+ * ```js
+ * let arr = [
+ *   { price: 10 },
+ *   { price: 1000 },
+ *   { price: 100 }
+ * ]
+ * arr = arr.sort(lowerFirst(el => el.price))
+ * isEqual(arr, [
+ *   { price: 10 },
+ *   { price: 100 },
+ *   { price: 1000 }
+ * ])
+ * ```
+ */
 function lowerFirst(getValue) {
     return (element1, element2) => {
         const val1 = getValue(element1);
@@ -27,6 +57,19 @@ function lowerFirst(getValue) {
     };
 }
 exports.lowerFirst = lowerFirst;
+/**
+ * ```js
+ * let arr = [
+ *  { name: 'iphone', isRocket: false },
+ *  { name: 'starship', isRocket: true }
+ * ]
+ * arr = arr.sort(makeFirst(el => el.isRocket))
+ * isEqual(arr, [
+ *  { name: 'starship', isRocket: true },
+ *  { name: 'iphone', isRocket: false }
+ * ])
+ * ```
+ */
 function makeFirst(getValue) {
     return (element1, element2) => {
         const val1 = getValue(element1);
@@ -46,6 +89,19 @@ function makeFirst(getValue) {
     };
 }
 exports.makeFirst = makeFirst;
+/**
+ * ```js
+ * let arr = [
+ *  { name: 'starship', isRocket: true },
+ *  { name: 'iphone', isRocket: false }
+ * ]
+ * arr = arr.sort(makeLast(el => el.isRocket))
+ * isEqual(arr, [
+ *  { name: 'iphone', isRocket: false },
+ *  { name: 'starship', isRocket: true }
+ * ])
+ * ```
+ */
 function makeLast(getValue) {
     return makeFirst((element) => {
         const val = getValue(element);
@@ -58,3 +114,8 @@ function makeLast(getValue) {
     });
 }
 exports.makeLast = makeLast;
+/** Reverse order result. */
+function reverse(sortKey) {
+    return (-1 * sortKey);
+}
+exports.reverse = reverse;

package/dist/esm/client/client-routing-runtime/index.d.ts

@@ -1,6 +1,6 @@
 export { navigate, reload } from './navigate.js';
 export { prefetch } from './prefetch.js';
-export { PROJECT_VERSION } from './utils.js';
+export { PROJECT_VERSION as version } from './utils.js';
 import type { PageContextBuiltInClientWithClientRouting } from '../../shared/types.js';
 /** @deprecated
  * Replace:

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

@@ -5,4 +5,4 @@
 // Use package.json#exports to make the imports isomorphic.
 export { navigate, reload } from './navigate.js';
 export { prefetch } from './prefetch.js';
-export { PROJECT_VERSION } from './utils.js';
+export { PROJECT_VERSION as version } from './utils.js';

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

@@ -1,7 +1,8 @@
 import { cac } from 'cac';
 import { resolve } from 'path';
 import { runPrerenderFromCLI, runPrerender_forceExit } from '../prerender/runPrerender.js';
-import { projectInfo, assertUsage } from './utils.js';
+import { projectInfo, assertUsage, assertWarning } from './utils.js';
+import pc from '@brillout/picocolors';
 const cli = cac(projectInfo.projectName);
 cli
     .command('prerender', 'Pre-render the HTML of your pages', { allowUnknownOptions: true })
@@ -28,6 +29,7 @@ function assertOptions() {
                 '--outDir',
                 '--configFile'
             ].includes(option), 'Unknown option: ' + option);
+        assertWarning(false, `You set ${pc.cyan(option)}, but passing options to ${pc.cyan('$ vike prerender')} is deprecated: use the config file instead. See https://vike.dev/command-prerender.`, { onlyOnce: true });
     });
 }
 // Listen to unknown commands

package/dist/esm/node/client/router.d.ts

@@ -1,4 +1,6 @@
 export { navigate };
 export { reload };
+export { prefetch };
 declare const navigate: never;
 declare const reload: never;
+declare const prefetch: never;

package/dist/esm/node/client/router.js

@@ -1,11 +1,13 @@
 export { navigate };
 export { reload };
+export { prefetch };
 import { assertWarning } from '../../utils/assert.js';
 // `never` to ensure package.json#exports["./client/router"].types points to type defined by the client-side code
 const navigate = (() => warnNoEffect('navigate'));
 const reload = (() => warnNoEffect('reload'));
+const prefetch = (() => warnNoEffect('prefetch'));
 function warnNoEffect(caller) {
-    assertWarning(false, `Calling ${caller} on the server-side has no effect`, {
+    assertWarning(false, `Calling ${caller}() on the server-side has no effect`, {
         showStackTrace: true,
         onlyOnce: false
     });

package/dist/esm/node/plugin/plugins/autoFullBuild.js

@@ -5,7 +5,7 @@ import { runPrerenderFromAutoFullBuild, runPrerender_forceExit } from '../../pre
 import { getConfigVike } from '../../shared/getConfigVike.js';
 import { isViteCliCall, getViteConfigFromCli } from '../shared/isViteCliCall.js';
 import pc from '@brillout/picocolors';
-import { logHintForCjsEsmError } from '../../runtime/renderPage/logHintForCjsEsmError.js';
+import { logErrorHint } from '../../runtime/renderPage/logErrorHint.js';
 let forceExit = false;
 function autoFullBuild() {
     let config;
@@ -82,7 +82,7 @@ async function triggerFullBuild(config, configVike, bundle) {
     }
     catch (err) {
         console.error(err);
-        logHintForCjsEsmError(err);
+        logErrorHint(err);
         process.exit(1);
     }
     if (configVike.prerender && !configVike.prerender.disableAutoRun) {

package/dist/esm/node/plugin/plugins/buildConfig/fixServerAssets.d.ts

@@ -0,0 +1,13 @@
+export { fixServerAssets };
+export { fixServerAssets_isEnabled };
+import { ViteManifest } from '../../../shared/ViteManifest.js';
+import { OutDirs } from '../../utils.js';
+/**
+ * true  => use workaround config.build.ssrEmitAssets
+ * false => use workaround extractAssets plugin
+ *
+ * Only used by V1 design.
+ */
+declare function fixServerAssets_isEnabled(): boolean;
+/** https://github.com/vikejs/vike/issues/1339 */
+declare function fixServerAssets(outDirs: OutDirs): Promise<ViteManifest>;

package/dist/esm/node/plugin/plugins/buildConfig/fixServerAssets.js

@@ -0,0 +1,142 @@
+export { fixServerAssets };
+export { fixServerAssets_isEnabled };
+import fs from 'fs/promises';
+import path from 'path';
+import { existsSync } from 'fs';
+import { assert, pLimit, unique } from '../../utils.js';
+import { isVirtualFileIdPageConfigValuesAll } from '../../../shared/virtual-files/virtualFilePageConfigValuesAll.js';
+import { manifestTempFile } from '../buildConfig.js';
+/**
+ * true  => use workaround config.build.ssrEmitAssets
+ * false => use workaround extractAssets plugin
+ *
+ * Only used by V1 design.
+ */
+function fixServerAssets_isEnabled() {
+    // We currently apply the workaround iff V1 design.
+    // Shall we allow the user to toggle between the two workarounds? E.g. based on https://vike.dev/includeAssetsImportedByServer.
+    return true;
+}
+/** https://github.com/vikejs/vike/issues/1339 */
+async function fixServerAssets(outDirs) {
+    const clientManifest = await loadManifest(outDirs.outDirClient);
+    const serverManifest = await loadManifest(outDirs.outDirServer);
+    const { clientManifestMod, filesToCopy } = addServerAssets(clientManifest, serverManifest);
+    await copyAssets(filesToCopy, outDirs);
+    return clientManifestMod;
+}
+async function loadManifest(outDir) {
+    const manifestFilePath = path.posix.join(outDir, manifestTempFile);
+    const manifestFileContent = await fs.readFile(manifestFilePath, 'utf-8');
+    assert(manifestFileContent);
+    const manifest = JSON.parse(manifestFileContent);
+    assert(manifest);
+    return manifest;
+}
+async function copyAssets(filesToCopy, { outDirClient, outDirServer }) {
+    const assetsDirServer = path.posix.join(outDirServer, 'assets');
+    if (!filesToCopy.length)
+        return;
+    assert(existsSync(assetsDirServer));
+    const concurrencyLimit = pLimit(10);
+    await Promise.all(filesToCopy.map((file) => concurrencyLimit(() => fs.cp(path.posix.join(outDirServer, file), path.posix.join(outDirClient, file), {
+        recursive: true
+    }))));
+    await fs.rm(assetsDirServer, { recursive: true });
+}
+// Add serverManifest resources to clientManifest
+function addServerAssets(clientManifest, serverManifest) {
+    var _a, _b;
+    const entriesClient = new Map();
+    const entriesServer = new Map();
+    for (const [key, entry] of Object.entries(clientManifest)) {
+        const pageId = getPageId(key);
+        if (!pageId)
+            continue;
+        const resources = collectResources(entry, clientManifest);
+        assert(!entriesClient.has(pageId));
+        entriesClient.set(pageId, { key, ...resources });
+    }
+    for (const [key, entry] of Object.entries(serverManifest)) {
+        const pageId = getPageId(key);
+        if (!pageId)
+            continue;
+        const resources = collectResources(entry, serverManifest);
+        assert(!entriesServer.has(pageId));
+        entriesServer.set(pageId, resources);
+    }
+    let filesToCopy = [];
+    for (const [pageId, entryClient] of entriesClient.entries()) {
+        const cssToAdd = [];
+        const assetsToAdd = [];
+        const entryServer = entriesServer.get(pageId);
+        if (entryServer) {
+            cssToAdd.push(...entryServer.css
+                .filter((cssServer) => !entryClient.css.some((cssClient) => cssServer.hash === cssClient.hash))
+                .map((css) => css.src));
+            assetsToAdd.push(...entryServer.assets
+                .filter((assertServer) => !entryClient.assets.some((assetClient) => assertServer.hash === assetClient.hash))
+                .map((asset) => asset.src));
+        }
+        const { key } = entryClient;
+        if (cssToAdd.length) {
+            filesToCopy.push(...cssToAdd);
+            (_a = clientManifest[key]).css ?? (_a.css = []);
+            clientManifest[key].css?.push(...cssToAdd);
+        }
+        if (assetsToAdd.length) {
+            filesToCopy.push(...assetsToAdd);
+            (_b = clientManifest[key]).assets ?? (_b.assets = []);
+            clientManifest[key].assets?.push(...assetsToAdd);
+        }
+    }
+    const clientManifestMod = clientManifest;
+    filesToCopy = unique(filesToCopy);
+    return { clientManifestMod, filesToCopy };
+}
+function getPageId(key) {
+    // Normalize from:
+    //   ../../virtual:vike:pageConfigValuesAll:client:/pages/index
+    // to:
+    //   virtual:vike:pageConfigValuesAll:client:/pages/index
+    // (This seems to be needed only for vitest tests that use Vite's build() API with an inline config.)
+    key = key.substring(key.indexOf('virtual:vike'));
+    const result = isVirtualFileIdPageConfigValuesAll(key);
+    return result && result.pageId;
+}
+function collectResources(entryRoot, manifest) {
+    const css = [];
+    const assets = [];
+    const entries = new Set([entryRoot]);
+    for (const entry of entries) {
+        for (const entryImport of entry.imports ?? []) {
+            entries.add(manifest[entryImport]);
+        }
+        const entryCss = entry.css ?? [];
+        if (entry.file.endsWith('.css'))
+            entryCss.push(entry.file);
+        for (const src of entryCss) {
+            const hash = getHash(src);
+            css.push({ src, hash });
+        }
+        const entryAssets = entry.assets ?? [];
+        for (const src of entryAssets) {
+            const hash = getHash(src);
+            assets.push({ src, hash });
+        }
+    }
+    return { css, assets };
+}
+// Use the hash of resources to determine whether they are equal. We need this, otherwise we get:
+// ```html
+// <head>
+//   <link rel="stylesheet" type="text/css" href="/assets/static/onRenderClient.2j6TxKIB.css">
+//   <link rel="stylesheet" type="text/css" href="/assets/static/onRenderHtml.2j6TxKIB.css">
+// </head>
+// ```
+function getHash(src) {
+    // src is guarenteed to end with `.[hash][extname]`, see distFileNames.ts
+    const hash = src.split('.').at(-2);
+    assert(hash);
+    return hash;
+}

package/dist/esm/node/plugin/plugins/buildConfig.d.ts

@@ -1,8 +1,10 @@
 export { buildConfig };
 export { assertRollupInput };
 export { analyzeClientEntries };
+export { manifestTempFile };
 import type { ResolvedConfig, Plugin } from 'vite';
 import type { PageConfigBuildTime } from '../../../shared/page-configs/PageConfig.js';
+declare const manifestTempFile = "_temp_manifest.json";
 declare function buildConfig(): Plugin;
 declare function analyzeClientEntries(pageConfigs: PageConfigBuildTime[], config: ResolvedConfig): {
     hasClientRouting: boolean;

package/dist/esm/node/plugin/plugins/buildConfig.js

@@ -1,8 +1,9 @@
 export { buildConfig };
 export { assertRollupInput };
 export { analyzeClientEntries };
-import { assert, resolveOutDir, viteIsSSR, getFilePathAbsolute, addOnBeforeLogHook, removeFileExtention, unique, assertPosixPath, assertUsage, injectRollupInputs, normalizeRollupInput } from '../utils.js';
-import { getVikeConfig } from './importUserCode/v1-design/getVikeConfig.js';
+export { manifestTempFile };
+import { assert, resolveOutDir, viteIsSSR, getFilePathAbsolute, addOnBeforeLogHook, removeFileExtention, unique, assertPosixPath, assertUsage, injectRollupInputs, normalizeRollupInput, assertNodeEnvIsNotDev, getOutDirs } from '../utils.js';
+import { getVikeConfig, isV1Design } from './importUserCode/v1-design/getVikeConfig.js';
 import { getConfigValue } from '../../../shared/page-configs/helpers.js';
 import { findPageFiles } from '../shared/findPageFiles.js';
 import { getConfigVike } from '../../shared/getConfigVike.js';
@@ -12,12 +13,16 @@ import { createRequire } from 'module';
 import { getClientEntryFilePath } from '../../shared/getClientEntryFilePath.js';
 import fs from 'fs/promises';
 import path from 'path';
+import { fixServerAssets, fixServerAssets_isEnabled } from './buildConfig/fixServerAssets.js';
+import { set_constant_ASSETS_MAP } from './importBuild/index.js';
 // @ts-ignore Shimmed by dist-cjs-fixup.js for CJS build.
 const importMetaUrl = import.meta.url;
 const require_ = createRequire(importMetaUrl);
 const manifestTempFile = '_temp_manifest.json';
 function buildConfig() {
-    let generateManifest;
+    let isServerAssetsFixEnabled;
+    let isSsrBuild;
+    let outDirs;
     return {
         name: 'vike:buildConfig',
         apply: 'build',
@@ -25,37 +30,56 @@ function buildConfig() {
         configResolved: {
             order: 'post',
             async handler(config) {
+                assertNodeEnv();
                 assertRollupInput(config);
                 const entries = await getEntries(config);
                 assert(Object.keys(entries).length > 0);
                 config.build.rollupOptions.input = injectRollupInputs(entries, config);
                 addLogHook();
+                outDirs = getOutDirs(config);
+                {
+                    isServerAssetsFixEnabled = fixServerAssets_isEnabled() && (await isV1Design(config, false));
+                    if (isServerAssetsFixEnabled) {
+                        // https://github.com/vikejs/vike/issues/1339
+                        config.build.ssrEmitAssets = true;
+                        // Required if `ssrEmitAssets: true`, see https://github.com/vitejs/vite/pull/11430#issuecomment-1454800934
+                        config.build.cssMinify = 'esbuild';
+                    }
+                }
             }
         },
         config(config) {
-            generateManifest = !viteIsSSR(config);
+            assertNodeEnv();
+            isSsrBuild = viteIsSSR(config);
             return {
                 build: {
                     outDir: resolveOutDir(config),
-                    manifest: generateManifest ? manifestTempFile : false,
-                    copyPublicDir: !viteIsSSR(config)
+                    manifest: manifestTempFile,
+                    copyPublicDir: !isSsrBuild
                 }
             };
         },
+        buildStart() {
+            assertNodeEnv();
+        },
         async writeBundle(options, bundle) {
-            const manifestEntry = bundle[manifestTempFile];
-            /* Fails with @vitejs/plugin-legacy because writeBundle() is called twice during the client build (once for normal client assets and a second time for legacy assets), see reproduction at https://github.com/vikejs/vike/issues/1154
-            assert(generateManifest === !!manifestEntry)
-            */
-            if (manifestEntry) {
-                const { dir } = options;
-                assert(dir);
-                const manifestFilePathOld = path.join(dir, manifestEntry.fileName);
+            if (isSsrBuild) {
                 // Ideally we'd move dist/_temp_manifest.json to dist/server/client-assets.json instead of dist/assets.json
                 //  - But we can't because there is no guarentee whether dist/server/ is generated before or after dist/client/ (generating dist/server/ after dist/client/ erases dist/server/client-assets.json)
                 //  - We'll able to do so once we replace `$ vite build` with `$ vike build`
-                const manifestFilePathNew = path.join(dir, '..', 'assets.json');
-                await fs.rename(manifestFilePathOld, manifestFilePathNew);
+                const assetsJsonFilePath = path.posix.join(outDirs.outDirRoot, 'assets.json');
+                const clientManifestFilePath = path.posix.join(outDirs.outDirClient, manifestTempFile);
+                const serverManifestFilePath = path.posix.join(outDirs.outDirServer, manifestTempFile);
+                if (!isServerAssetsFixEnabled) {
+                    await fs.copyFile(clientManifestFilePath, assetsJsonFilePath);
+                }
+                else {
+                    const clientManifestMod = await fixServerAssets(outDirs);
+                    await fs.writeFile(assetsJsonFilePath, JSON.stringify(clientManifestMod, null, 2), 'utf-8');
+                }
+                await fs.rm(clientManifestFilePath);
+                await fs.rm(serverManifestFilePath);
+                await set_constant_ASSETS_MAP(options, bundle);
             }
         }
     };
@@ -224,3 +248,6 @@ function assertRollupInput(config) {
     const htmlInput = htmlInputs[0];
     assertUsage(htmlInput === undefined, `The entry ${htmlInput} of config build.rollupOptions.input is an HTML entry which is forbidden when using Vike, instead follow https://vike.dev/add`);
 }
+function assertNodeEnv() {
+    assertNodeEnvIsNotDev('building');
+}

package/dist/esm/node/plugin/plugins/commonConfig.js

@@ -1,5 +1,5 @@
 export { commonConfig };
-import { assert, assertWarning, findUserPackageJsonPath } from '../utils.js';
+import { assert, assertWarning, findFile } from '../utils.js';
 import { assertRollupInput } from './buildConfig.js';
 import { installRequireShim_setUserRootDir } from '@brillout/require-shim';
 import pc from '@brillout/picocolors';
@@ -26,7 +26,7 @@ function commonConfig() {
                     overrideViteDefaultPort(config);
                     /* TODO: do this after implementing vike.config.js and new setting transformLinkedDependencies (or probably a better name like transpileLinkedDependencies/bundleLinkedDependencies or something else)
                     overrideViteDefaultSsrExternal(config)
-                    */
+                    //*/
                     workaroundCI(config);
                     assertRollupInput(config);
                     assertResolveAlias(config);
@@ -46,21 +46,13 @@ function overrideViteDefaultPort(config) {
     (_b = config.preview).port ?? (_b.port = 3000);
 }
 /*
+import { version } from 'vite'
 function overrideViteDefaultSsrExternal(config: ResolvedConfig) {
-  if (!isViteVersionWithSsrExternalTrue()) return
+  if (!isVersionOrAbove(version, '5.0.12')) return
   // @ts-ignore Not released yet: https://github.com/vitejs/vite/pull/10939/files#diff-5a3d42620df2c6b17e25f440ffdb67683dee7ef57317674d19f41d5f30502310L5
   config.ssr.external ??= true
 }
-import { version } from 'vite'
-function isViteVersionWithSsrExternalTrue(): boolean {
-  const versionParts = version.split('.').map((s) => parseInt(s, 10)) as [number, number, number]
-  assert(versionParts.length === 3)
-  if (versionParts[0] > 5) return true
-  if (versionParts[1] > 0) return true
-  if (versionParts[2] >= 12) return true
-  return false
-}
-*/
+//*/
 // Workaround GitHub Action failing to access the server
 function workaroundCI(config) {
     var _a, _b;
@@ -70,7 +62,7 @@ function workaroundCI(config) {
     }
 }
 function assertEsm(userViteRoot) {
-    const packageJsonPath = findUserPackageJsonPath(userViteRoot);
+    const packageJsonPath = findFile('package.json', userViteRoot);
     if (!packageJsonPath)
         return;
     const packageJson = require_(packageJsonPath);

package/dist/esm/node/plugin/plugins/config/stemUtils.js

@@ -1,7 +1,7 @@
 // Move to standalone package? E.g. https://www.npmjs.com/package/stem
 export { getStemPackages };
 import path from 'path';
-import { assert, assertUsage, assertWarning, toPosixPath, assertPosixPath, getDependencyRootDir, findUserPackageJsonPath } from '../../utils.js';
+import { assert, assertUsage, assertWarning, toPosixPath, assertPosixPath, getDependencyRootDir, findFile } from '../../utils.js';
 import { import_ } from '@brillout/import';
 import { createRequire } from 'module';
 // @ts-ignore Shimmed by dist-cjs-fixup.js for CJS build.
@@ -48,7 +48,7 @@ async function getStemPackages(userAppRootDir) {
     return stemPackages;
 }
 function findUserRootDir(userAppRootDir) {
-    const userPkgJsonPath = findUserPackageJsonPath(userAppRootDir);
+    const userPkgJsonPath = findFile('package.json', userAppRootDir);
     assertUsage(userPkgJsonPath, `Couldn't find package.json in any parent directory starting from ${userAppRootDir}`);
     return toPosixPath(path.dirname(userPkgJsonPath));
 }

package/dist/esm/node/plugin/plugins/distFileNames.js

@@ -19,9 +19,17 @@ function distFileNames() {
                 if (!('chunkFileNames' in rollupOutput)) {
                     rollupOutput.chunkFileNames = (chunkInfo) => getChunkFileName(chunkInfo, config);
                 }
-                if (!('assertUsage' in rollupOutput)) {
+                if (!('assetFileNames' in rollupOutput)) {
                     rollupOutput.assetFileNames = (chunkInfo) => getAssetFileName(chunkInfo, config);
                 }
+                else {
+                    // If a user needs this:
+                    //  - assertUsage() that the naming provided by the user ends with `.[hash][extname]`
+                    //    - It's needed for getHash() of fixServerAssets()
+                    //    - 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(false, "Setting config.build.rollupOptions.output.assetFileNames is currently forbidden. (It's possible to support, thus contact a maintainer if you need this.)");
+                }
             });
         }
     };

package/dist/esm/node/plugin/plugins/extractAssetsPlugin.js

@@ -1,6 +1,6 @@
-// Alternative: use `ssrEmitAssets: true`
-//  - See https://github.com/vitejs/vite/pull/11430
-// This plugin makes client-side bundles include the CSS imports living in server-side-only code.
+// Remove this workaround if the other workaround config.build.ssrEmitAssets turns out to be reliable.
+//  - Remove this file then revert this commit: https://github.com/vikejs/vike/commit/805a18974f13420a78fcc30fdd676696e405c3ca
+// Workaround to make client-side bundles include the CSS imports living in server-side-only code.
 //  - This is needed for HTML-only pages, and React Server Components.
 //  - We recommend using the debug flag to get an idea of how this plugin works: `$ DEBUG=vike:extractAssets pnpm exec vite build`. Then have a look at `dist/client/manifest.json` and see how `.page.server.js` entries have zero JavaScript but only CSS.
 //  - This appraoch supports import path aliases `vite.config.js#resolve.alias` https://vitejs.dev/config/#resolve-alias
@@ -13,6 +13,8 @@ import { isAsset } from '../shared/isAsset.js';
 import { getImportStatements } from '../shared/parseEsModule.js';
 import { removeSourceMap } from '../shared/removeSourceMap.js';
 import pc from '@brillout/picocolors';
+import { fixServerAssets_isEnabled } from './buildConfig/fixServerAssets.js';
+import { isV1Design } from './importUserCode/v1-design/getVikeConfig.js';
 const extractAssetsRE = /(\?|&)extractAssets(?:&|$)/;
 const rawRE = /(\?|&)raw(?:&|$)/;
 const urlRE = /(\?|&)url(?:&|$)/;
@@ -23,6 +25,7 @@ const debugEnabled = isDebugEnabled(debugNamespace);
 function extractAssetsPlugin() {
     let config;
     let configVike;
+    let isServerAssetsFixEnabled;
     return [
         // This plugin removes all JavaScript from server-side only code, so that only CSS imports remains. (And also satic files imports e.g. `import logoURL from './logo.svg.js'`).
         {
@@ -34,6 +37,7 @@ function extractAssetsPlugin() {
                 if (!extractAssetsRE.test(id)) {
                     return;
                 }
+                assert(!isServerAssetsFixEnabled);
                 assert(configVike.includeAssetsImportedByServer);
                 assert(!viteIsSSR_options(options));
                 const importStatements = await getImportStatements(src);
@@ -131,6 +135,7 @@ function extractAssetsPlugin() {
             async configResolved(config_) {
                 configVike = await getConfigVike(config_);
                 config = config_;
+                isServerAssetsFixEnabled = fixServerAssets_isEnabled() && (await isV1Design(config, false));
             },
             load(id) {
                 if (!isVirtualFileId(id))

package/dist/esm/node/plugin/plugins/importBuild/index.d.ts

@@ -1,3 +1,8 @@
 export { importBuild };
-import type { Plugin } from 'vite';
+export { set_constant_ASSETS_MAP };
+import type { Plugin, Rollup } from 'vite';
+type Bundle = Rollup.OutputBundle;
+type Options = Rollup.NormalizedOutputOptions;
 declare function importBuild(): Plugin[];
+/** Set the value of the ASSETS_MAP constant inside dist/server/entry.js (or dist/server/index.js) */
+declare function set_constant_ASSETS_MAP(options: Options, bundle: Bundle): Promise<void>;

package/dist/esm/node/plugin/plugins/importBuild/index.js

@@ -1,6 +1,7 @@
 export { importBuild };
+export { set_constant_ASSETS_MAP };
 import { serverEntryPlugin, findServerEntry } from '@brillout/vite-plugin-server-entry/plugin.js';
-import { assert, getOutDirs, toPosixPath, viteIsSSR } from '../../utils.js';
+import { assert, getOutDirs, toPosixPath } from '../../utils.js';
 import path from 'path';
 import { createRequire } from 'module';
 import { getConfigVike } from '../../../shared/getConfigVike.js';
@@ -21,11 +22,6 @@ function importBuild() {
             async configResolved(config_) {
                 config = config_;
                 configVike = await getConfigVike(config);
-            },
-            async writeBundle(options, bundle) {
-                if (!viteIsSSR(config))
-                    return;
-                await replace_ASSETS_MAP(options, bundle);
             }
         },
         ...serverEntryPlugin({
@@ -58,7 +54,8 @@ function getEntryCode(config, configVike) {
     ].join('\n');
     return importerCode;
 }
-async function replace_ASSETS_MAP(options, bundle) {
+/** Set the value of the ASSETS_MAP constant inside dist/server/entry.js (or dist/server/index.js) */
+async function set_constant_ASSETS_MAP(options, bundle) {
     const { dir } = options;
     assert(dir);
     // This will probably fail with @vitejs/plugin-legacy

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/configDefinitionsBuiltIn.d.ts

@@ -1,6 +1,7 @@
 export { configDefinitionsBuiltIn };
 export { configDefinitionsBuiltInGlobal };
 export type { ConfigDefinition };
+export type { ConfigDefinitions };
 export type { ConfigDefinitionInternal };
 export type { ConfigNameGlobal };
 export type { ConfigEffect };
@@ -54,6 +55,7 @@ type ConfigDefinitionInternal = Omit<ConfigDefinition, 'env'> & {
     _userEffectDefinedAt?: DefinedAtFileFullInfo;
     env: ConfigEnvInternal;
 };
+type ConfigDefinitions = Record<string, ConfigDefinitionInternal>;
 type ConfigDefinitionsBuiltIn = Record<ConfigNameBuiltIn, ConfigDefinitionInternal>;
 declare const configDefinitionsBuiltIn: ConfigDefinitionsBuiltIn;
 type ConfigNameGlobal = 'onPrerenderStart' | 'onBeforeRoute' | 'prerender' | 'extensions' | 'disableAutoFullBuild' | 'includeAssetsImportedByServer' | 'baseAssets' | 'baseServer' | 'redirects' | 'trailingSlash' | 'disableUrlNormalization';

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/crawlPlusFiles.d.ts

@@ -1,5 +1,4 @@
 export { crawlPlusFiles };
 declare function crawlPlusFiles(userRootDir: string, outDirAbsoluteFilesystem: string, isDev: boolean): Promise<{
     filePathRelativeToUserRootDir: string;
-    filePathAbsoluteFilesystem: string;
 }[]>;