vike 0.4.160 → 0.4.161-commit-0e9c635

package/dist/esm/node/runtime/renderPage/{logHintForCjsEsmError.js → logErrorHint.js}

@@ -1,12 +1,22 @@
-export { logHintForCjsEsmError };
-// For ./logHintForCjsEsmError/*.spec.ts
+export { logErrorHint };
+// For ./logErrorHint/*.spec.ts
 export { isCjsEsmError };
-export { isReactInvalidComponentError };
+export { isKnownError };
 export { getHint };
 import pc from '@brillout/picocolors';
 import { assert, formatHintLog, isNotNullish, isObject, unique, joinEnglish } from '../utils.js';
-function logHintForCjsEsmError(error) {
-    /* Collect errors for ./logHintForCjsEsmError.spec.ts
+const knownErrors = [
+    {
+        errMsg: 'jsxDEV is not a function',
+        link: 'https://github.com/vikejs/vike/issues/1469#issuecomment-1919518096'
+    },
+    {
+        errMsg: 'Element type is invalid: expected a string (for built-in components) or a class/function (for composite components)',
+        link: 'https://vike.dev/broken-npm-package#react-invalid-component'
+    }
+];
+function logErrorHint(error) {
+    /* Collect errors for ./logErrorHint.spec.ts
     collectError(error)
     //*/
     const hint = getHint(error);
@@ -14,9 +24,10 @@ function logHintForCjsEsmError(error) {
         logHint(hint);
 }
 function getHint(error) {
-    if (isReactInvalidComponentError(error)) {
-        const hint = 'To fix this error, see https://vike.dev/broken-npm-package#react-invalid-component';
-        return hint;
+    {
+        const link = isKnownError(error);
+        if (link)
+            return `To fix this error, see ${link}`;
     }
     const res = isCjsEsmError(error);
     if (res) {
@@ -37,43 +48,71 @@ function logHint(hint) {
     hint = formatHintLog(hint);
     console.error(hint);
 }
-function isReactInvalidComponentError(error) {
+function isKnownError(error) {
     const anywhere = getAnywhere(error);
-    return includes(anywhere, 'Element type is invalid: expected a string (for built-in components) or a class/function (for composite components)');
+    const knownErr = knownErrors.find((knownErorr) => {
+        return includes(anywhere, knownErorr.errMsg);
+    });
+    if (!knownErr)
+        return false;
+    return knownErr.link;
 }
-/**
- * `false` -> noop
- * `true` -> generic message
- * `'some-npm-package'` -> add some-npm-package to `ssr.noExternal`
- */
+// `false` -> noop
+// `true` -> generic message
+// `'some-npm-package'` -> add some-npm-package to `ssr.noExternal`
 function isCjsEsmError(error) {
+    const res = check(error);
+    if (res === true || res === false)
+        return res;
+    const packageNames = normalizeRes(res);
+    if (packageNames === false)
+        return packageNames;
+    packageNames.forEach((packageName) => {
+        assert(!['vite', 'vike'].includes(packageName));
+    });
+    return packageNames;
+}
+function normalizeRes(res) {
+    let packageNames = Array.isArray(res) ? res : [res];
+    packageNames = unique(packageNames.filter(isNotNullish).filter((packageName) => packageName !== '@brillout/import'));
+    if (packageNames.length === 0)
+        return false;
+    return packageNames;
+}
+function check(error) {
     const message = getErrMessage(error);
     const anywhere = getAnywhere(error);
     const packageName_stack1 = getPackageName_stack1(error);
     const packageName_stack2 = getPackageName_stack2(error);
     const isRelatedToNodeModules = !!packageName_stack1 || !!packageName_stack2 || includesNodeModules(message);
-    // const relatedNpmPackages = normalize([packageName_stack1, packageName_stack2, extractFromNodeModulesPath(message)])
+    /*
+    const relatedNpmPackages = normalizeArray([
+      packageName_stack1 || null,
+      packageName_stack2 || null,
+      (message && extractFromNodeModulesPath(message)) || null
+    ])
+    */
     // ERR_UNSUPPORTED_DIR_IMPORT
     {
-        const packageNames = parseNodeModulesPathMessage('ERR_UNSUPPORTED_DIR_IMPORT', anywhere);
-        if (packageNames)
-            return packageNames;
+        const packageName = parseNodeModulesPathMessage('ERR_UNSUPPORTED_DIR_IMPORT', anywhere);
+        if (packageName)
+            return packageName;
     }
     // ERR_UNKNOWN_FILE_EXTENSION
     {
-        const packageNames = parseUnkownFileExtensionMessage(anywhere);
-        if (packageNames)
-            return packageNames;
+        const packageName = parseUnkownFileExtensionMessage(anywhere);
+        if (packageName)
+            return packageName;
     }
     {
-        const packageNames = parseNodeModulesPathMessage('ERR_UNKNOWN_FILE_EXTENSION', anywhere);
-        if (packageNames)
-            return packageNames;
+        const packageName = parseNodeModulesPathMessage('ERR_UNKNOWN_FILE_EXTENSION', anywhere);
+        if (packageName)
+            return packageName;
     }
     {
-        const packageNames = parseNodeModulesPathMessage('is not exported', anywhere);
-        if (packageNames)
-            return packageNames;
+        const packageName = parseNodeModulesPathMessage('is not exported', anywhere);
+        if (packageName)
+            return packageName;
     }
     // Using CJS inside ESM modules.
     if (includes(anywhere, 'require is not a function') ||
@@ -94,7 +133,7 @@ function isCjsEsmError(error) {
     if (includes(anywhere, 'ERR_REQUIRE_ESM')) {
         /* The issue is the importer, not the importee.
         if (relatedNpmPackages) return relatedNpmPackages
-        */
+         */
         {
             if (packageName_stack1)
                 return packageName_stack1;
@@ -114,9 +153,9 @@ function isCjsEsmError(error) {
     */
     // `SyntaxError: Named export '${exportName}' not found. The requested module '${packageName}' is a CommonJS module, which may not support all module.exports as named exports.`
     {
-        const packageNames = parseImportFrom(anywhere);
-        if (packageNames)
-            return packageNames;
+        const packageName = parseImportFrom(anywhere);
+        if (packageName)
+            return packageName;
     }
     if (includes(anywhere, 'Cannot read properties of undefined')) {
         if (isRelatedToNodeModules) {
@@ -152,7 +191,7 @@ function parseCannotFindMessage(str) {
         return false;
     // const packageNameCannotFind = extractFromPath(match[1]!)
     const packageNameFrom = extractFromPath(match[2]);
-    return normalize([
+    return normalizeArray([
         // packageNameCannotFind,
         packageNameFrom
     ]);
@@ -163,7 +202,7 @@ function parseUnkownFileExtensionMessage(str) {
         return false;
     const filePath = match[1];
     const packageName = extractFromPath(filePath);
-    return normalize([packageName]);
+    return packageName;
 }
 function parseImportFrom(str) {
     const match = /\bimport\b.*?\bfrom\b\s*?"(.+?)"/.exec(str);
@@ -171,7 +210,7 @@ function parseImportFrom(str) {
         return false;
     const importPath = match[1];
     const packageName = extractFromPath(importPath);
-    return normalize([packageName]);
+    return packageName;
 }
 function parseNodeModulesPathMessage(begin, str) {
     str = str.replaceAll('\\', '/');
@@ -225,7 +264,6 @@ function extractFromPath(filePath) {
         packageName = packageName.split('/')[0];
     }
     packageName = clean(packageName);
-    assert(!['vite', 'vike'].includes(packageName));
     return packageName;
 }
 function clean(packageName) {
@@ -243,7 +281,7 @@ function extractFromNodeModulesPath(str) {
         return false;
     const packageName = extractFromPath(str);
     assert(packageName);
-    return normalize([packageName]);
+    return packageName;
 }
 function includes(str1, str2) {
     return !!str1 && str1.toLowerCase().includes(str2.toLowerCase());
@@ -258,11 +296,11 @@ function includesNodeModules(str) {
         return false;
     return true;
 }
-function normalize(packageNames) {
-    const result = unique(packageNames.filter(isNotNullish).filter((packageName) => packageName !== '@brillout/import'));
-    if (result.length === 0)
-        return false;
-    return result;
+function normalizeArray(arr) {
+    const arrNormalized = arr.filter(isNotNullish);
+    if (arrNormalized.length === 0)
+        return null;
+    return arrNormalized;
 }
 function getErrMessage(err) {
     if (!isObject(err))

package/dist/esm/node/runtime/renderPage/loggerProd.js

@@ -6,7 +6,7 @@ import { isAbortError } from '../../../shared/route/abort.js';
 import { setAlreadyLogged } from './isNewError.js';
 import { isObject, warnIfErrorIsNotObject } from '../utils.js';
 import pc from '@brillout/picocolors';
-import { logHintForCjsEsmError } from './logHintForCjsEsmError.js';
+import { logErrorHint } from './logErrorHint.js';
 function logErrorProd(err, _httpRquestId) {
     warnIfErrorIsNotObject(err);
     setAlreadyLogged(err);
@@ -20,6 +20,6 @@ function logErrorProd(err, _httpRquestId) {
 }
 // Every server-side runtime error is expected to go through onRuntimeError(). (In principle, any runtime error is (or at least should) be catched by Vike, otherwise Vike couldn't render the error page.)
 function onRuntimeError(err) {
-    // The more runtime errors we pass to logHintForCjsEsmError() the better.
-    logHintForCjsEsmError(err);
+    // The more runtime errors we pass to logErrorHint() the better.
+    logErrorHint(err);
 }

package/dist/esm/node/runtime/renderPage/renderPageAlreadyRouted.js

@@ -6,7 +6,7 @@ export { getRenderContext };
 import { getErrorPageId } from '../../../shared/error-page.js';
 import { getHtmlString } from '../html/renderHtml.js';
 import { getPageFilesAll } from '../../../shared/getPageFiles.js';
-import { assert, assertUsage, assertWarning, hasProp, isNotNullish, objectAssign, unique } from '../utils.js';
+import { assert, assertUsage, hasProp, objectAssign } from '../utils.js';
 import { serializePageContextClientSide } from '../html/serializePageContextClientSide.js';
 import { addUrlComputedProps } from '../../../shared/addUrlComputedProps.js';
 import { getGlobalContext } from '../globalContext.js';
@@ -20,8 +20,8 @@ import { preparePageContextForUserConsumptionServerSide } from './preparePageCon
 import { executeGuardHook } from '../../../shared/route/executeGuardHook.js';
 import { loadPageRoutes } from '../../../shared/route/loadPageRoutes.js';
 import pc from '@brillout/picocolors';
-import { getConfigValueFilePathToShowToUser } from '../../../shared/page-configs/helpers.js';
 import { isServerSideError } from '../../../shared/misc/isServerSideError.js';
+import { assertV1Design } from '../../shared/assertV1Design.js';
 async function renderPageAlreadyRouted(pageContext) {
     // pageContext._pageId can either be the:
     //  - ID of the page matching the routing, or the
@@ -151,7 +151,7 @@ async function getRenderContext() {
     const globalContext = getGlobalContext();
     const { pageFilesAll, allPageIds, pageConfigs, pageConfigGlobal } = await getPageFilesAll(false, globalContext.isProduction);
     const { pageRoutes, onBeforeRouteHook } = await loadPageRoutes(pageFilesAll, pageConfigs, pageConfigGlobal, allPageIds);
-    assertV1Design(pageFilesAll, pageConfigs);
+    assertV1Design(pageFilesAll.length > 0, pageConfigs, pageFilesAll);
     const renderContext = {
         pageFilesAll: pageFilesAll,
         pageConfigs,
@@ -162,24 +162,3 @@ async function getRenderContext() {
     };
     return renderContext;
 }
-function assertV1Design(pageFilesAll, pageConfigs) {
-    const isV1Design = pageConfigs.length !== 0;
-    const isDesignOld = pageFilesAll.length !== 0;
-    if (isV1Design && isDesignOld) {
-        const indent = '- ';
-        const v1Files = unique(pageConfigs
-            .map((p) => Object.values(p.configValues)
-            .map(getConfigValueFilePathToShowToUser)
-            .filter(isNotNullish)
-            .map((filePathToShowToUser) => indent + filePathToShowToUser))
-            .flat(2));
-        assertUsage(false, [
-            'Mixing the new V1 design with the old V0.4 design is forbidden.',
-            'V1 files:',
-            ...v1Files,
-            'V0.4 files:',
-            ...pageFilesAll.map((p) => indent + p.filePath)
-        ].join('\n'));
-    }
-    assertWarning(!isDesignOld, "You are using Vike's deprecated design. Update to the new V1 design, see https://vike.dev/migration/v1-design for how to migrate.", { onlyOnce: true });
-}

package/dist/esm/node/runtime/utils.d.ts

@@ -36,7 +36,7 @@ export * from '../../utils/isNpmPackage.js';
 export * from '../../utils/isNotNullish.js';
 export * from '../../utils/isScriptFile.js';
 export * from '../../utils/removeFileExtention.js';
-export * from '../../utils/objectEntries.js';
+export * from '../../utils/objectKeys.js';
 export * from '../../utils/isStringRecord.js';
 export * from '../../utils/getFileExtension.js';
 export * from '../../utils/assertIsNotProductionRuntime.js';

package/dist/esm/node/runtime/utils.js

@@ -39,7 +39,7 @@ export * from '../../utils/isNpmPackage.js';
 export * from '../../utils/isNotNullish.js';
 export * from '../../utils/isScriptFile.js';
 export * from '../../utils/removeFileExtention.js';
-export * from '../../utils/objectEntries.js';
+export * from '../../utils/objectKeys.js';
 export * from '../../utils/isStringRecord.js';
 export * from '../../utils/getFileExtension.js';
 export * from '../../utils/assertIsNotProductionRuntime.js';

package/dist/esm/node/shared/ViteManifest.d.ts

@@ -6,6 +6,7 @@ type ViteManifestEntry = {
     css?: string[];
     assets?: string[];
     isEntry?: boolean;
+    name?: string;
     isDynamicEntry?: boolean;
     imports?: string[];
     dynamicImports?: string[];

package/dist/esm/node/shared/assertPluginManifest.d.ts

@@ -6,7 +6,6 @@ type PluginManifest = {
     baseAssets: string | null;
     usesClientRouter: boolean;
     includeAssetsImportedByServer: boolean;
-    manifestKeyMap: Record<string, string>;
     redirects: Record<string, string>;
     trailingSlash: boolean;
     disableUrlNormalization: boolean;

package/dist/esm/node/shared/assertPluginManifest.js

@@ -1,21 +1,18 @@
 export { assertPluginManifest };
 import { assertRuntimeManifest } from './assertRuntimeManifest.js';
-import { assert, assertUsage, isPlainObject, projectInfo, checkType, hasProp, isStringRecord, objectAssign } from './utils.js';
+import { assert, assertUsage, isPlainObject, projectInfo, checkType, hasProp } from './utils.js';
 function assertPluginManifest(pluginManifest) {
     assert(isPlainObject(pluginManifest));
     assertUsage(pluginManifest.version === projectInfo.projectVersion, `Re-build your app (you're using vike@${projectInfo.projectVersion} but your app was built with vike@${pluginManifest.version})`);
     assertRuntimeManifest(pluginManifest);
     assert(hasProp(pluginManifest, 'usesClientRouter', 'boolean'));
     assert(hasProp(pluginManifest, 'version', 'string'));
-    assert(hasProp(pluginManifest, 'manifestKeyMap', 'object'));
-    const { manifestKeyMap } = pluginManifest;
-    assert(isStringRecord(manifestKeyMap));
     // Avoid:
     // ```
     // Uncaught (in promise) TypeError: Cannot set property manifestKeyMap of #<Object> which has only a getter
     // ```
+    // We removed manifestKeyMap, maybe this isn't needed anymore.
     // See https://github.com/vikejs/vike/issues/596
     const pluginManifestClone = { ...pluginManifest };
-    objectAssign(pluginManifestClone, { manifestKeyMap });
     checkType(pluginManifestClone);
 }

package/dist/esm/node/shared/assertV1Design.d.ts

@@ -0,0 +1,4 @@
+export { assertV1Design };
+import { PageFile } from '../../shared/getPageFiles.js';
+import type { PageConfigBuildTime, PageConfigRuntime } from '../../shared/page-configs/PageConfig.js';
+declare function assertV1Design(isOldDesign: boolean, pageConfigs: (PageConfigRuntime | PageConfigBuildTime)[], pageFilesAll?: PageFile[]): void;

package/dist/esm/node/shared/assertV1Design.js

@@ -0,0 +1,23 @@
+export { assertV1Design };
+import { getConfigValueFilePathToShowToUser } from '../../shared/page-configs/helpers.js';
+import { assert, assertUsage, assertWarning, isNotNullish, unique } from './utils.js';
+function assertV1Design(isOldDesign, pageConfigs, pageFilesAll) {
+    const isV1Design = pageConfigs.length > 0;
+    if (isV1Design && isOldDesign) {
+        const lines = ['Mixing the new V1 design with the old V0.4 design is forbidden.'];
+        if (pageFilesAll) {
+            assert(pageFilesAll.length > 0);
+            const indent = '- ';
+            const filesV1 = unique(pageConfigs
+                .map((p) => Object.values(p.configValues)
+                .map(getConfigValueFilePathToShowToUser)
+                .filter(isNotNullish)
+                .map((filePathToShowToUser) => indent + filePathToShowToUser))
+                .flat(2));
+            const filesOld = pageFilesAll.map((p) => indent + p.filePath);
+            lines.push(...['V1 design files:', ...filesV1, 'Old design files:', ...filesOld]);
+        }
+        assertUsage(false, lines.join('\n'));
+    }
+    assertWarning(!isOldDesign, "You are using Vike's deprecated design. Update to the new V1 design, see https://vike.dev/migration/v1-design for how to migrate.", { onlyOnce: true });
+}

package/dist/esm/node/shared/getClientEntry.d.ts

@@ -0,0 +1,3 @@
+export { getClientEntry };
+import type { PageConfigRuntime, PageConfigBuildTime } from '../../shared/page-configs/PageConfig.js';
+declare function getClientEntry(pageConfig: PageConfigRuntime | PageConfigBuildTime): null | string;

package/dist/esm/node/shared/{getClientEntryFilePath.js → getClientEntry.js}

@@ -1,6 +1,6 @@
-export { getClientEntryFilePath };
+export { getClientEntry };
 import { getConfigValue } from '../../shared/page-configs/helpers.js';
-function getClientEntryFilePath(pageConfig) {
+function getClientEntry(pageConfig) {
     const configName = 'client';
     const configValue = getConfigValue(pageConfig, configName, 'string');
     if (!configValue)

package/dist/esm/node/shared/prependEntriesDir.d.ts

@@ -0,0 +1,2 @@
+export { prependEntriesDir };
+declare function prependEntriesDir(entryName: string): string;

package/dist/esm/node/shared/prependEntriesDir.js

@@ -0,0 +1,10 @@
+export { prependEntriesDir };
+import { assert } from './utils.js';
+function prependEntriesDir(entryName) {
+    if (entryName.startsWith('/')) {
+        entryName = entryName.slice(1);
+    }
+    assert(!entryName.startsWith('/'));
+    entryName = `entries/${entryName}`;
+    return entryName;
+}

package/dist/esm/node/shared/utils.d.ts

@@ -13,3 +13,5 @@ export * from '../../utils/parseUrl-extras.js';
 export * from '../../utils/isObject.js';
 export * from '../../utils/virtual-files.js';
 export * from '../../utils/assertIsNotBrowser.js';
+export * from '../../utils/isNotNullish.js';
+export * from '../../utils/unique.js';

package/dist/esm/node/shared/utils.js

@@ -15,3 +15,5 @@ export * from '../../utils/parseUrl-extras.js';
 export * from '../../utils/isObject.js';
 export * from '../../utils/virtual-files.js';
 export * from '../../utils/assertIsNotBrowser.js';
+export * from '../../utils/isNotNullish.js';
+export * from '../../utils/unique.js';

package/dist/esm/shared/page-configs/Config.d.ts

@@ -201,7 +201,7 @@ type OnRenderHtmlSync = (pageContext: PageContextServer) => DocumentHtml | {
     pageContext: OnRenderHtmlPageContextReturn | (() => Promise<OnRenderHtmlPageContextReturn> | OnRenderHtmlPageContextReturn);
 };
 type OnRenderHtmlPageContextReturn = Partial<Vike.PageContext & {
-    /** See https://vike.dev/stream */
+    /** See https://vike.dev/streaming */
     enableEagerStreaming: boolean;
 }>;
 /** @deprecated Use a sync route() with an async guard() instead */

package/dist/esm/shared/page-configs/PageConfig.d.ts

@@ -17,6 +17,7 @@ export type { DefinedAtFileFullInfo };
 export type { FilePathResolved };
 export type { FilePath };
 import type { ConfigValueImported, ConfigValueSerialized } from './serialize/PageConfigSerialized.js';
+import type { LocationId } from '../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/filesystemRouting.js';
 type PageConfigBase = {
     pageId: string;
     isErrorPage?: true;
@@ -24,11 +25,10 @@ type PageConfigBase = {
         routeString: string;
         definedBy: string;
     };
+    configValues: ConfigValues;
 };
 /** Page config data structure available at runtime */
 type PageConfigRuntime = PageConfigBase & {
-    /** All loaded config values */
-    configValues: ConfigValues;
     /** Load config values that are lazily loaded such as config.Page */
     loadConfigValuesAll: () => Promise<{
         configValuesImported: ConfigValueImported[];
@@ -42,7 +42,6 @@ type PageConfigRuntimeLoaded = PageConfigRuntime & {
 };
 /** Page config data structure available at build-time */
 type PageConfigBuildTime = PageConfigBase & {
-    configValues: ConfigValues;
     configValueSources: ConfigValueSources;
     configValuesComputed: ConfigValuesComputed;
 };
@@ -71,6 +70,7 @@ type ConfigValueSource = {
     value?: unknown;
     configEnv: ConfigEnvInternal;
     definedAt: DefinedAtFileFullInfo;
+    locationId: LocationId;
     /** Wether the config value is loaded at runtime, for example config.Page or config.onBeforeRender */
     valueIsImportedAtRuntime: boolean;
     /** Whether the config value is a file path, for example config.client */

package/dist/esm/shared/page-configs/serialize/parseConfigValuesImported.js

@@ -2,41 +2,68 @@ export { parseConfigValuesImported };
 import { assert } from '../../utils.js';
 import { assertPlusFileExport } from '../assertPlusFileExport.js';
 function parseConfigValuesImported(configValuesImported) {
-    const configValues = {};
-    const addConfigValue = (configName, value, importPath, exportName) => {
-        configValues[configName] = {
-            value,
-            definedAt: {
-                // importPath cannot be relative to the current file, since the current file is a virtual file
-                filePathToShowToUser: importPath,
-                fileExportPathToShowToUser: [configName, 'default'].includes(exportName)
-                    ? []
-                    : // Side-effect config
-                        [exportName]
-            }
-        };
-        assertIsNotNull(value, configName, importPath);
-    };
-    configValuesImported.forEach((configValueLoaded) => {
+    const configValuesUnmerged = {};
+    configValuesImported
+        .filter((c) => c.configName !== 'client')
+        .forEach((configValueLoaded) => {
         if (configValueLoaded.isValueFile) {
             const { exportValues, importPath, configName } = configValueLoaded;
-            if (configName !== 'client') {
-                assertPlusFileExport(exportValues, importPath, configName);
-            }
+            assertPlusFileExport(exportValues, importPath, configName);
             Object.entries(exportValues).forEach(([exportName, exportValue]) => {
                 const isSideExport = exportName !== 'default'; // .md files may have "side-exports" such as `export { frontmatter }`
                 const configName = isSideExport ? exportName : configValueLoaded.configName;
-                if (isSideExport && configName in configValues) {
-                    // We can't avoid side-export conflicts upstream. (Because we cannot know about side-exports upstream at build-time.)
-                    // Side-exports have the lowest priority.
-                    return;
-                }
-                addConfigValue(configName, exportValue, importPath, exportName);
+                configValuesUnmerged[configName] ?? (configValuesUnmerged[configName] = []);
+                configValuesUnmerged[configName].push({
+                    value: exportValue,
+                    importPath,
+                    exportName,
+                    isSideExport
+                });
             });
         }
         else {
             const { configName, importPath, exportValue, exportName } = configValueLoaded;
-            addConfigValue(configName, exportValue, importPath, exportName);
+            configValuesUnmerged[configName] ?? (configValuesUnmerged[configName] = []);
+            configValuesUnmerged[configName].push({
+                value: exportValue,
+                importPath,
+                exportName,
+                isSideExport: false
+            });
+        }
+    });
+    const configValues = {};
+    Object.entries(configValuesUnmerged).forEach(([configName, values]) => {
+        const valuesWithoutSideExports = values.filter((v) => !v.isSideExport);
+        const isCumulative = valuesWithoutSideExports.length > 1;
+        const noSideExports = valuesWithoutSideExports.length === values.length;
+        if (isCumulative) {
+            // Vike currently doesn't support side exports for cumulative configs
+            assert(noSideExports);
+            // TODO: implement
+            assert(false);
+        }
+        else {
+            const val = valuesWithoutSideExports[0] ??
+                // We can't avoid side-export conflicts upstream. (We cannot know about side-exports at build-time.)
+                // Side-exports have lower precedence.
+                values[0];
+            assert(val);
+            const { value, importPath, exportName } = val;
+            configValues[configName] = {
+                value,
+                definedAt: {
+                    // importPath cannot be relative to the current file, since the current file is a virtual file
+                    filePathToShowToUser: importPath,
+                    fileExportPathToShowToUser: [configName, 'default'].includes(exportName)
+                        ? []
+                        : [
+                            // Side-export
+                            exportName
+                        ]
+                }
+            };
+            assertIsNotNull(value, configName, importPath);
         }
     });
     return configValues;

package/dist/esm/shared/route/executeGuardHook.js

@@ -1,6 +1,7 @@
 export { executeGuardHook };
 import { getHook, getHookTimeoutDefault } from '../hooks/getHook.js';
 import { assert, assertUsage, executeHook, isCallable } from './utils.js';
+const errIntro = 'The guard() hook defined by';
 async function executeGuardHook(pageContext, prepareForUserConsumption) {
     let hook;
     if (pageContext._pageFilesAll.length > 0) {
@@ -20,7 +21,7 @@ async function executeGuardHook(pageContext, prepareForUserConsumption) {
     if (res)
         pageContextForUserConsumption = res;
     const hookResult = await executeHook(() => guard(pageContextForUserConsumption), hook);
-    assertUsage(hookResult === undefined, `The guard() hook of ${hook.hookFilePath} returns a value, but guard() doesn't accept any return value`);
+    assertUsage(hookResult === undefined, `${errIntro} ${hook.hookFilePath} returns a value, but guard() shouldn't return any value`);
 }
 function findPageGuard(pageId, pageFilesAll) {
     const pageRouteFile = pageFilesAll.find((p) => p.pageId === pageId && p.fileType === '.page.route');
@@ -33,6 +34,6 @@ function findPageGuard(pageId, pageFilesAll) {
         return null;
     const hookFilePath = filePath;
     const hookTimeout = getHookTimeoutDefault('guard');
-    assertUsage(isCallable(hookFn), `guard() defined by ${hookFilePath} should be a function`);
+    assertUsage(isCallable(hookFn), `${errIntro} ${hookFilePath} should be a function`);
     return { hookFn, hookName: 'guard', hookFilePath, hookTimeout };
 }

package/dist/esm/shared/utils.d.ts

@@ -18,6 +18,5 @@ export * from '../utils/projectInfo.js';
 export * from '../utils/isPropertyGetter.js';
 export * from '../utils/isPromise.js';
 export * from '../utils/checkType.js';
-export * from '../utils/objectEntries.js';
 export * from '../utils/getValuePrintable.js';
 export * from '../utils/escapeRegex.js';

package/dist/esm/shared/utils.js

@@ -22,6 +22,5 @@ export * from '../utils/projectInfo.js';
 export * from '../utils/isPropertyGetter.js';
 export * from '../utils/isPromise.js';
 export * from '../utils/checkType.js';
-export * from '../utils/objectEntries.js';
 export * from '../utils/getValuePrintable.js';
 export * from '../utils/escapeRegex.js';

package/dist/esm/utils/assertNodeVersion.js

@@ -1,11 +1,11 @@
 export { assertNodeVersion };
 import { assertUsage } from './assert.js';
 import { isNodeJS } from './isNodeJS.js';
+import { isVersionOrAbove } from './isVersionOrAbove.js';
 // package.json#engines.node isn't enough as users can ignore it
 function assertNodeVersion() {
     if (!isNodeJS())
         return;
     const version = process.versions.node;
-    const major = parseInt(version.split('.')[0], 10);
-    assertUsage(major >= 16, `Node.js ${version} isn't supported, use Node.js >=16.0.0 instead.`);
+    assertUsage(isVersionOrAbove(version, '16.0.0'), `Node.js ${version} isn't supported, use Node.js >=16.0.0 instead.`);
 }

package/dist/esm/utils/findFile.d.ts

@@ -0,0 +1,3 @@
+export { findFile };
+type Filename = 'package.json' | 'vike.config.js' | 'vike.config.ts';
+declare function findFile(arg: Filename | Filename[], cwd: string): null | string;