vike 0.4.160 → 0.4.161-commit-0e9c635

package/dist/cjs/utils/objectKeys.js

@@ -1,10 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.objectKeys = void 0;
+exports.objectKeys = exports.objectFromEntries = exports.objectEntries = void 0;
+// https://stackoverflow.com/questions/60141960/typescript-key-value-relation-preserving-object-entries-type/75337277#75337277
+/** Same as Object.entries() but with type inference */
+function objectEntries(obj) {
+    return Object.entries(obj);
+}
+exports.objectEntries = objectEntries;
+/** Same as Object.fromEntries() but with type inference */
+function objectFromEntries(arr) {
+    return Object.fromEntries(arr);
+}
+exports.objectFromEntries = objectFromEntries;
+// https://stackoverflow.com/questions/52856496/typescript-object-keys-return-string
+// https://github.com/sindresorhus/ts-extras/blob/main/source/object-keys.ts
 /** Same as Object.keys() but with type inference */
 function objectKeys(obj) {
     return Object.keys(obj);
 }
 exports.objectKeys = objectKeys;
-// https://stackoverflow.com/questions/52856496/typescript-object-keys-return-string
-// https://github.com/sindresorhus/ts-extras/blob/main/source/object-keys.ts
+/*
+function objectKeys2<T extends Record<string, unknown>>(obj: T): Array<keyof T> {
+  return Object.keys(obj)
+}
+*/

package/dist/cjs/utils/projectInfo.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PROJECT_VERSION = exports.projectInfo = void 0;
 const assertSingleInstance_js_1 = require("./assertSingleInstance.js");
-const PROJECT_VERSION = '0.4.160';
+const PROJECT_VERSION = '0.4.161-commit-0e9c635';
 exports.PROJECT_VERSION = PROJECT_VERSION;
 const projectInfo = {
     projectName: 'Vike',

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,23 +1,29 @@
 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, isNpmPackageImport } 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';
 import { getVirtualFileIdPageConfigValuesAll } from '../../shared/virtual-files/virtualFilePageConfigValuesAll.js';
 import { extractAssetsAddQuery } from '../../shared/extractAssetsQuery.js';
 import { createRequire } from 'module';
-import { getClientEntryFilePath } from '../../shared/getClientEntryFilePath.js';
+import { getClientEntry } from '../../shared/getClientEntry.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';
+import { prependEntriesDir } from '../../shared/prependEntriesDir.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 +31,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);
             }
         }
     };
@@ -108,7 +133,7 @@ function analyzeClientEntries(pageConfigs, config) {
     let hasClientRouting = false;
     let hasServerRouting = false;
     let clientEntries = {};
-    let clientFilePaths = [];
+    let clientEntryList = [];
     pageConfigs.forEach((pageConfig) => {
         const configValue = getConfigValue(pageConfig, 'clientRouting', 'boolean');
         if (configValue?.value) {
@@ -123,15 +148,15 @@ function analyzeClientEntries(pageConfigs, config) {
             clientEntries[entryName] = entryTarget;
         }
         {
-            const clientFilePath = getClientEntryFilePath(pageConfig);
-            if (clientFilePath) {
-                clientFilePaths.push(clientFilePath);
+            const clientEntry = getClientEntry(pageConfig);
+            if (clientEntry) {
+                clientEntryList.push(clientEntry);
             }
         }
     });
-    clientFilePaths = unique(clientFilePaths);
-    clientFilePaths.forEach((pageFile) => {
-        const { entryName, entryTarget } = getEntryFromFilePath(pageFile, config);
+    clientEntryList = unique(clientEntryList);
+    clientEntryList.forEach((clientEntry) => {
+        const { entryName, entryTarget } = getEntryFromClientEntry(clientEntry, config);
         clientEntries[entryName] = entryTarget;
     });
     return { hasClientRouting, hasServerRouting, clientEntries };
@@ -153,12 +178,18 @@ async function getPageFileEntries(config, includeAssetsImportedByServer) {
             assert(includeAssetsImportedByServer);
             addExtractAssetsQuery = true;
         }
-        const { entryName, entryTarget } = getEntryFromFilePath(pageFile, config, addExtractAssetsQuery);
+        const { entryName, entryTarget } = getEntryFromClientEntry(pageFile, config, addExtractAssetsQuery);
         pageFileEntries[entryName] = entryTarget;
     });
     return pageFileEntries;
 }
-function getEntryFromFilePath(filePath, config, addExtractAssetsQuery) {
+function getEntryFromClientEntry(clientEntry, config, addExtractAssetsQuery) {
+    if (isNpmPackageImport(clientEntry)) {
+        const entryTarget = clientEntry;
+        const entryName = prependEntriesDir(clientEntry);
+        return { entryName, entryTarget };
+    }
+    const filePath = clientEntry;
     assertPosixPath(filePath);
     assert(filePath.startsWith('/'));
     let entryTarget = getFilePathAbsolute(filePath, config);
@@ -178,14 +209,6 @@ function getEntryFromPageConfig(pageConfig, isForClientSide) {
     entryName = prependEntriesDir(entryName);
     return { entryName, entryTarget };
 }
-function prependEntriesDir(entryName) {
-    if (entryName.startsWith('/')) {
-        entryName = entryName.slice(1);
-    }
-    assert(!entryName.startsWith('/'));
-    entryName = `entries/${entryName}`;
-    return entryName;
-}
 function resolve(filePath) {
     assert(filePath.startsWith('dist/'));
     // [RELATIVE_PATH_FROM_DIST] Current directory: node_modules/vike/dist/esm/node/plugin/plugins/
@@ -224,3 +247,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.)");
+                }
             });
         }
     };