vike 0.4.168-commit-ce94f5c → 0.4.168-commit-42406a9

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

@@ -1,6 +1,18 @@
 export type { FilePath };
+export type { FilePathUnresolved };
 export type { FilePathResolved };
-type FilePathResolved = FilePath & {
+type FilePath = FilePathResolved | FilePathUnresolved;
+type FilePathUnresolved = FilePathCommon & {
+    filePathAbsoluteFilesystem: null;
+} & ImportPathAbsolute;
+type FilePathResolved = FilePathCommon & {
+    /**
+     * The file's path, absolute starting from the filesystem root.
+     *
+     * Example: `/home/rom/code/my-app/pages/some-page/+Page.js`
+     *
+     * The value is `null` for imports using path aliases. (Because Vike cannot resolve path aliases, otherwise Vike would need to re-implement https://www.npmjs.com/package/@rollup/plugin-alias.)
+     */
     filePathAbsoluteFilesystem: string;
     /**
      * The file's path, shown to the user in logs.
@@ -10,22 +22,23 @@ type FilePathResolved = FilePath & {
      * Its value is equivalent to `filePath.filePathAbsoluteUserRootDir ?? filePath.filePathAbsoluteFilesystem`.
      */
     filePathToShowToUserResolved: string;
-};
-type IsReferencedByUserLandFile = {
-    filePathAbsoluteUserRootDir: string;
-} | {
-    importPathAbsolute: string;
-};
-type FilePath = FilePathProps & IsReferencedByUserLandFile;
-type FilePathProps = {
     /**
-     * The file's path, absolute starting from the filesystem root.
+     * File's name (without its file path).
      *
-     * Example: `/home/rom/code/my-app/pages/some-page/+Page.js`
-     *
-     * The value is `null` for imports using path aliases. (Because Vike cannot resolve path aliases, otherwise Vike would need to re-implement https://www.npmjs.com/package/@rollup/plugin-alias.)
+     * Example: `+Page.js`
      */
-    filePathAbsoluteFilesystem: string | null;
+    fileName: string;
+} & (FilePathAbsoluteUserRootDir | ImportPathAbsolute);
+type ImportPathAbsolute = {
+    /**
+     * The file's non-relative import path. It's either:
+     *  - an npm package import (e.g. `vike-react/config`), or
+     *  - a path alias import (e.g. `#components/Counter').
+     */
+    importPathAbsolute: string;
+    filePathAbsoluteUserRootDir: null;
+};
+type FilePathAbsoluteUserRootDir = {
     /**
      * The file's path, absolute starting from the user root directory (i.e. Vite's `config.root`).
      *
@@ -34,7 +47,10 @@ type FilePathProps = {
      * Its value is `null` if the file is outside of the user root directory (i.e. Vite's `config.root`).
      *
      */
-    filePathAbsoluteUserRootDir: string | null;
+    filePathAbsoluteUserRootDir: string;
+    importPathAbsolute: string | null;
+};
+type FilePathCommon = {
     /**
      * The file's path, shown to the user in logs.
      *
@@ -50,15 +66,9 @@ type FilePathProps = {
      *   - `/pages/+config.js`
      *   - `vike-react/config`
      *
-     * We use it to generate import paths in virtual modules. (Since import paths in virtual modules cannot be relative.)
+     * We use it to generate imports in virtual modules. (Since import paths in virtual modules cannot be relative.)
      *
      * Its value is equivalent to `filePath.filePathAbsoluteUserRootDir ?? filePath.importPathAbsolute`.
      */
     filePathAbsoluteVite: string;
-    /**
-     * The file's non-relative import path. It's either:
-     *  - an npm package import (e.g. `vike-react/config`), or
-     *  - a path alias import (e.g. `#components/Counter').
-     */
-    importPathAbsolute: string | null;
 };

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

@@ -6,14 +6,16 @@ export type { ConfigEnvInternal };
 export type { PageConfigGlobalRuntime };
 export type { PageConfigGlobalBuildTime };
 export type { ConfigValue };
+export type { ConfigValueClassic };
+export type { ConfigValueCumulative };
+export type { ConfigValueComputed };
 export type { ConfigValues };
 export type { ConfigValueSource };
 export type { ConfigValueSources };
-export type { ConfigValueComputed };
 export type { ConfigValuesComputed };
-export type { DefinedAt };
+export type { DefinedAtData };
 export type { DefinedAtFile };
-export type { DefinedAtFileFullInfo };
+export type { DefinedAtFilePath };
 import type { ConfigValueImported, ConfigValueSerialized } from './serialize/PageConfigSerialized.js';
 import type { LocationId } from '../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/filesystemRouting.js';
 import type { FilePath } from './FilePath.js';
@@ -68,7 +70,7 @@ type ConfigEnvInternal = Omit<ConfigEnv, 'client'> & {
 type ConfigValueSource = {
     value?: unknown;
     configEnv: ConfigEnvInternal;
-    definedAt: DefinedAtFileFullInfo;
+    definedAtFilePath: DefinedAtFilePath;
     locationId: LocationId;
     /** Wether the config value is loaded at runtime, for example config.Page or config.onBeforeRender */
     valueIsImportedAtRuntime: boolean;
@@ -76,26 +78,36 @@ type ConfigValueSource = {
     valueIsFilePath?: true;
     valueIsDefinedByValueFile: boolean;
 };
-type DefinedAtFileFullInfo = DefinedAtFile & FilePath & {
+type DefinedAtFilePath = DefinedAtFile & FilePath & {
     fileExportName?: string;
 };
 type ConfigValueSources = Record<string, ConfigValueSource[]>;
-type ConfigValueComputed = {
+type ConfigValuesComputed = Record<string, {
     configEnv: ConfigEnvInternal;
     value: unknown;
-};
-type ConfigValuesComputed = Record<string, ConfigValueComputed>;
-type ConfigValue = {
+}>;
+type ConfigValue = ConfigValueClassic | ConfigValueCumulative | ConfigValueComputed;
+/** Defined by a unique source (thus unique file path). */
+type ConfigValueClassic = {
+    type: 'classic';
     value: unknown;
-    definedAt: DefinedAt;
+    definedAtData: DefinedAtFile;
 };
-type DefinedAt = DefinedAtFile | {
-    files: DefinedAtFile[];
-} | {
-    isComputed: true;
+/** Defined by multiple sources (thus multiple file paths). */
+type ConfigValueCumulative = {
+    type: 'cumulative';
+    value: unknown[];
+    definedAtData: DefinedAtFile[];
 };
+/** Defined internally by Vike (currently, Vike doesn't support computed configs created by users). */
+type ConfigValueComputed = {
+    type: 'computed';
+    value: unknown;
+    definedAtData: null;
+};
+type ConfigValues = Record<string, ConfigValue>;
+type DefinedAtData = DefinedAtFile | DefinedAtFile[] | null;
 type DefinedAtFile = {
     filePathToShowToUser: string;
     fileExportPathToShowToUser: null | string[];
 };
-type ConfigValues = Record<string, ConfigValue>;

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

@@ -0,0 +1,11 @@
+export { getConfigDefinedAt };
+export { getConfigDefinedAtOptional };
+export { getDefinedAtString };
+export type { ConfigDefinedAt };
+export type { ConfigDefinedAtOptional };
+import type { DefinedAtData, DefinedAtFile } from './PageConfig.js';
+type ConfigDefinedAtOptional = ConfigDefinedAt | `Config ${string} defined internally`;
+type ConfigDefinedAt = `Config ${string} defined at ${string}`;
+declare function getConfigDefinedAt<SentenceBegin extends 'Config' | 'config', ConfigName extends string>(sentenceBegin: SentenceBegin, configName: ConfigName, definedAtData: DefinedAtFile | DefinedAtFile[]): `${SentenceBegin} ${ConfigName} defined at ${string}`;
+declare function getConfigDefinedAtOptional<SentenceBegin extends 'Config' | 'config', ConfigName extends string>(sentenceBegin: SentenceBegin, configName: ConfigName, definedAtData: DefinedAtData): `${SentenceBegin} ${ConfigName} defined ${'internally' | `at ${string}`}`;
+declare function getDefinedAtString(definedAtData: DefinedAtFile | DefinedAtFile[], configName: string): string;

package/dist/esm/shared/page-configs/getConfigDefinedAt.js

@@ -0,0 +1,42 @@
+export { getConfigDefinedAt };
+export { getConfigDefinedAtOptional };
+export { getDefinedAtString };
+import { assert, isArray } from '../utils.js';
+import pc from '@brillout/picocolors';
+import { getExportPath } from './getExportPath.js';
+function getConfigDefinedAt(sentenceBegin, configName, definedAtData) {
+    return `${begin(sentenceBegin, configName)} at ${getDefinedAtString(definedAtData, configName)}`;
+}
+function getConfigDefinedAtOptional(sentenceBegin, configName, definedAtData) {
+    if (!definedAtData) {
+        return `${begin(sentenceBegin, configName)} internally`;
+    }
+    else {
+        return `${begin(sentenceBegin, configName)} at ${getDefinedAtString(definedAtData, configName)}`;
+    }
+}
+function begin(sentenceBegin, configName) {
+    return `${sentenceBegin} ${pc.cyan(configName)} defined`;
+}
+function getDefinedAtString(definedAtData, configName) {
+    let files;
+    if (isArray(definedAtData)) {
+        files = definedAtData;
+    }
+    else {
+        files = [definedAtData];
+    }
+    assert(files.length >= 1);
+    const definedAtString = files
+        .map((source) => {
+        const { filePathToShowToUser, fileExportPathToShowToUser } = source;
+        let s = filePathToShowToUser;
+        const exportPath = getExportPath(fileExportPathToShowToUser, configName);
+        if (exportPath) {
+            s = `${s} > ${pc.cyan(exportPath)}`;
+        }
+        return s;
+    })
+        .join(' / ');
+    return definedAtString;
+}

package/dist/esm/shared/page-configs/{helpers/getConfigValue.d.ts → getConfigValue.d.ts}

@@ -1,6 +1,6 @@
 export { getConfigValue };
-import type { PageConfigRuntime, PageConfigBuildTime, ConfigValue } from '../PageConfig.js';
-import type { ConfigNameBuiltIn } from '../Config.js';
+import type { PageConfigRuntime, PageConfigBuildTime, ConfigValue } from './PageConfig.js';
+import type { ConfigNameBuiltIn } from './Config.js';
 type PageConfigCommon = PageConfigRuntime | PageConfigBuildTime;
 type ConfigName = ConfigNameBuiltIn;
 declare function getConfigValue(pageConfig: PageConfigCommon, configName: ConfigName, type: 'string'): null | ConfigValue & {

package/dist/esm/shared/page-configs/{helpers/getConfigValue.js → getConfigValue.js}

@@ -1,19 +1,19 @@
 export { getConfigValue };
-import { assert, assertUsage, getValuePrintable } from '../../utils.js';
+import { assert, assertUsage, getValuePrintable } from '../utils.js';
 import pc from '@brillout/picocolors';
-import { getConfigDefinedAtString } from './getConfigDefinedAtString.js';
+import { getConfigDefinedAtOptional } from './getConfigDefinedAt.js';
 // prettier-ignore
 // biome-ignore format:
 function getConfigValue(pageConfig, configName, type) {
     const configValue = getConfigValueEntry(pageConfig, configName);
     if (configValue === null)
         return null;
-    const { value, definedAt } = configValue;
+    const { value, definedAtData } = configValue;
     if (type)
-        assertConfigValueType(value, type, configName, definedAt);
+        assertConfigValueType(value, type, configName, definedAtData);
     return configValue;
 }
-function assertConfigValueType(value, type, configName, definedAt) {
+function assertConfigValueType(value, type, configName, definedAtData) {
     assert(value !== null);
     const typeActual = typeof value;
     if (typeActual === type)
@@ -22,9 +22,7 @@ function assertConfigValueType(value, type, configName, definedAt) {
     const problem = valuePrintable !== null
         ? `value ${pc.cyan(valuePrintable)}`
         : `type ${pc.cyan(typeActual)}`;
-    const configDefinedAt = getConfigDefinedAtString('Config', configName, {
-        definedAt
-    });
+    const configDefinedAt = getConfigDefinedAtOptional('Config', configName, definedAtData);
     const errMsg = `${configDefinedAt} has an invalid ${problem}: it should be a ${pc.cyan(type)} instead`;
     assertUsage(false, errMsg);
 }

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

@@ -1,13 +1,7 @@
 export { getPageConfig };
 export { getConfigValueFilePathToShowToUser };
 export { getHookFilePathToShowToUser };
-export { getConfigDefinedAtString, getDefinedAtString } from './helpers/getConfigDefinedAtString.js';
-export { getConfigValue } from './helpers/getConfigValue.js';
-import type { PageConfigRuntime, DefinedAt } from './PageConfig.js';
+import type { PageConfigRuntime, DefinedAtData } from './PageConfig.js';
 declare function getPageConfig(pageId: string, pageConfigs: PageConfigRuntime[]): PageConfigRuntime;
-declare function getConfigValueFilePathToShowToUser({ definedAt }: {
-    definedAt: DefinedAt;
-}): null | string;
-declare function getHookFilePathToShowToUser({ definedAt }: {
-    definedAt: DefinedAt;
-}): string;
+declare function getConfigValueFilePathToShowToUser(definedAtData: DefinedAtData): null | string;
+declare function getHookFilePathToShowToUser(definedAtData: DefinedAtData): string;

package/dist/esm/shared/page-configs/helpers.js

@@ -1,27 +1,25 @@
 export { getPageConfig };
 export { getConfigValueFilePathToShowToUser };
 export { getHookFilePathToShowToUser };
-export { getConfigDefinedAtString, getDefinedAtString } from './helpers/getConfigDefinedAtString.js';
-export { getConfigValue } from './helpers/getConfigValue.js';
-import { assert } from '../utils.js';
+import { assert, isArray } from '../utils.js';
 function getPageConfig(pageId, pageConfigs) {
     const pageConfig = pageConfigs.find((p) => p.pageId === pageId);
     assert(pageConfigs.length > 0);
     assert(pageConfig);
     return pageConfig;
 }
-function getConfigValueFilePathToShowToUser({ definedAt }) {
+function getConfigValueFilePathToShowToUser(definedAtData) {
     // A unique file path only exists if the config value isn't cumulative nor computed:
     //  - cumulative config values have multiple file paths
     //  - computed values don't have any file path
-    if ('isComputed' in definedAt || 'files' in definedAt)
+    if (!definedAtData || isArray(definedAtData))
         return null;
-    const { filePathToShowToUser } = definedAt;
+    const { filePathToShowToUser } = definedAtData;
     assert(filePathToShowToUser);
     return filePathToShowToUser;
 }
-function getHookFilePathToShowToUser({ definedAt }) {
-    const filePathToShowToUser = getConfigValueFilePathToShowToUser({ definedAt });
+function getHookFilePathToShowToUser(definedAtData) {
+    const filePathToShowToUser = getConfigValueFilePathToShowToUser(definedAtData);
     assert(filePathToShowToUser);
     return filePathToShowToUser;
 }

package/dist/esm/shared/page-configs/serialize/PageConfigSerialized.d.ts

@@ -2,7 +2,7 @@ export type { PageConfigRuntimeSerialized };
 export type { PageConfigGlobalRuntimeSerialized };
 export type { ConfigValueSerialized };
 export type { ConfigValueImported };
-import type { DefinedAt, PageConfigRuntime } from '../PageConfig.js';
+import type { ConfigValueClassic, ConfigValueComputed, ConfigValueCumulative, PageConfigRuntime } from '../PageConfig.js';
 /** Page config data structure serialized in virtual files: parsing it results in PageConfigRuntime */
 type PageConfigRuntimeSerialized = Omit<PageConfigRuntime, 'configValues'> & {
     /** Config values that are serializable and loaded eagerly such as config.passToClient */
@@ -14,10 +14,13 @@ type PageConfigGlobalRuntimeSerialized = {
     configValuesImported: ConfigValueImported[];
 };
 /** Value is serialized */
-type ConfigValueSerialized = {
+type ConfigValueSerialized = (Omit<ConfigValueClassic, 'value'> & {
     valueSerialized: string;
-    definedAt: DefinedAt;
-};
+}) | (Omit<ConfigValueCumulative, 'value'> & {
+    valueSerialized: string;
+}) | (Omit<ConfigValueComputed, 'value'> & {
+    valueSerialized: string;
+});
 /** Value is imported */
 type ConfigValueImported = {
     configName: string;

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

@@ -1,8 +1,8 @@
 export { assertPageConfigsSerialized };
 export { assertPageConfigGlobalSerialized };
-import { assert, isObject, hasProp } from '../../utils.js';
+import { assert, isObject, hasProp, isArray } from '../../utils.js';
 function assertPageConfigsSerialized(pageConfigsSerialized) {
-    assert(Array.isArray(pageConfigsSerialized));
+    assert(isArray(pageConfigsSerialized));
     pageConfigsSerialized.forEach((pageConfigSerialized) => {
         assert(isObject(pageConfigSerialized));
         assert(hasProp(pageConfigSerialized, 'pageId', 'string'));

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

@@ -51,8 +51,9 @@ function parseConfigValuesImported(configValuesImported) {
             assert(val);
             const { value, importPath, exportName } = val;
             configValues[configName] = {
+                type: 'classic',
                 value,
-                definedAt: {
+                definedAtData: {
                     // importPath cannot be relative to the current file, since the current file is a virtual file
                     filePathToShowToUser: importPath,
                     fileExportPathToShowToUser: [configName, 'default'].includes(exportName)

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

@@ -1,16 +1,21 @@
 export { parseConfigValuesSerialized };
-import { assert } from '../../utils.js';
+import { assert, isArray } from '../../utils.js';
 import { parse } from '@brillout/json-serializer/parse';
 function parseConfigValuesSerialized(configValuesSerialized) {
     const configValues = {};
     Object.entries(configValuesSerialized).forEach(([configName, configValueSeriliazed]) => {
-        const { valueSerialized, definedAt } = configValueSeriliazed;
-        assert(valueSerialized);
         assert(!configValues[configName]);
-        configValues[configName] = {
-            value: parse(valueSerialized),
-            definedAt
-        };
+        const { valueSerialized, ...common } = configValueSeriliazed;
+        const value = parse(valueSerialized);
+        let configValue;
+        if (common.type === 'cumulative') {
+            assert(isArray(value));
+            configValue = { value, ...common };
+        }
+        else {
+            configValue = { value, ...common };
+        }
+        configValues[configName] = configValue;
     });
     return configValues;
 }

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

@@ -1,7 +1,7 @@
 export { parsePageConfigs };
 import { parseConfigValuesImported } from './parseConfigValuesImported.js';
-import { assertUsage, isCallable } from '../../utils.js';
-import { getConfigDefinedAtString } from '../helpers.js';
+import { assert, assertUsage, isCallable } from '../../utils.js';
+import { getConfigDefinedAt } from '../getConfigDefinedAt.js';
 import { parseConfigValuesSerialized } from './parseConfigValuesSerialized.js';
 function parsePageConfigs(pageConfigsSerialized, pageConfigGlobalSerialized) {
     const pageConfigs = pageConfigsSerialized.map((pageConfigSerialized) => {
@@ -38,9 +38,10 @@ function assertRouteConfigValue(configValues) {
     const configValue = configValues[configName];
     if (!configValue)
         return;
-    const { value } = configValue;
+    const { value, definedAtData } = configValue;
     const configValueType = typeof value;
-    const configDefinedAt = getConfigDefinedAtString('Config', configName, configValue);
+    assert(definedAtData);
+    const configDefinedAt = getConfigDefinedAt('Config', configName, definedAtData);
     assertUsage(configValueType === 'string' || isCallable(value), `${configDefinedAt} has an invalid type '${configValueType}': it should be a string or a function instead, see https://vike.dev/route`);
     /* We don't use assertRouteString() in order to avoid unnecessarily bloating the client-side bundle when using Server Routing:
     * - When using Server Routing, this file is loaded => loading assertRouteString() would bloat the client bundle.

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

@@ -13,7 +13,7 @@ function serializeConfigValue(lines, configName, configValueSerialized) {
     lines.push(`${whitespace}['${configName}']: {`);
     whitespace += '  ';
     Object.entries(configValueSerialized).forEach(([key, val]) => {
-        const valSerialized = key === 'definedAt' ? JSON.stringify(val) : val;
+        const valSerialized = key === 'valueSerialized' ? val : JSON.stringify(val);
         lines.push(`${whitespace}  ${key}: ${valSerialized},`);
     });
     whitespace = whitespace.slice(2);
@@ -22,9 +22,9 @@ function serializeConfigValue(lines, configName, configValueSerialized) {
 function serializeConfigValueImported(configValueSource, configName, whitespace, varCounterContainer, importStatements) {
     assert(!configValueSource.valueIsFilePath);
     assert(whitespace.replaceAll(' ', '').length === 0);
-    const { valueIsImportedAtRuntime, valueIsDefinedByValueFile, definedAt } = configValueSource;
+    const { valueIsImportedAtRuntime, valueIsDefinedByValueFile, definedAtFilePath } = configValueSource;
     assert(valueIsImportedAtRuntime);
-    const { filePathAbsoluteVite, fileExportName } = definedAt;
+    const { filePathAbsoluteVite, fileExportName } = definedAtFilePath;
     if (valueIsDefinedByValueFile)
         assert(fileExportName === undefined);
     const { importName, importStatement } = generateEagerImport(filePathAbsoluteVite, varCounterContainer.varCounter++, fileExportName);

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

@@ -69,8 +69,8 @@ async function route(pageContextForRoute) {
         }
         // Route Function defined in `.page.route.js`
         if (pageRoute.routeType === 'FUNCTION') {
-            const { routeFunction, routeDefinedAt } = pageRoute;
-            const match = await resolveRouteFunction(routeFunction, pageContext, routeDefinedAt);
+            const { routeFunction, routeDefinedAtString } = pageRoute;
+            const match = await resolveRouteFunction(routeFunction, pageContext, routeDefinedAtString);
             if (match) {
                 const { routeParams, precedence } = match;
                 routeMatches.push({ pageId, precedence, routeParams, routeType });

package/dist/esm/shared/route/loadPageRoutes.d.ts

@@ -9,16 +9,16 @@ type PageRoute = {
     comesFromV1PageConfig: boolean;
 } & ({
     routeString: string;
-    routeDefinedAt: null;
+    routeDefinedAtString: null;
     routeType: 'FILESYSTEM';
     routeFilesystemDefinedBy: string;
 } | {
     routeString: string;
-    routeDefinedAt: string;
+    routeDefinedAtString: string;
     routeType: 'STRING';
 } | {
     routeFunction: Function;
-    routeDefinedAt: string;
+    routeDefinedAtString: string;
     routeType: 'FUNCTION';
 });
 type PageRoutes = PageRoute[];

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

@@ -3,7 +3,8 @@ import { isErrorPageId } from '../error-page.js';
 import { assert, assertUsage, hasProp, slice } from './utils.js';
 import { deduceRouteStringFromFilesystemPath } from './deduceRouteStringFromFilesystemPath.js';
 import { isCallable } from '../utils.js';
-import { getConfigValue, getDefinedAtString } from '../page-configs/helpers.js';
+import { getConfigValue } from '../page-configs/getConfigValue.js';
+import { getDefinedAtString } from '../page-configs/getConfigDefinedAt.js';
 import { warnDeprecatedAllowKey } from './resolveRouteFunction.js';
 import { getHookFromPageConfigGlobal, getHookTimeoutDefault } from '../hooks/getHook.js';
 async function loadPageRoutes(
@@ -30,13 +31,14 @@ function getPageRoutes(filesystemRoots, pageFilesAll, pageConfigs, allPageIds) {
                 const configValue = getConfigValue(pageConfig, configName);
                 if (configValue) {
                     const route = configValue.value;
-                    const definedAt = getDefinedAtString(configValue.definedAt, configName);
+                    assert(configValue.definedAtData);
+                    const definedAtString = getDefinedAtString(configValue.definedAtData, configName);
                     if (typeof route === 'string') {
                         pageRoute = {
                             pageId,
                             comesFromV1PageConfig,
                             routeString: route,
-                            routeDefinedAt: definedAt,
+                            routeDefinedAtString: definedAtString,
                             routeType: 'STRING'
                         };
                     }
@@ -48,7 +50,7 @@ function getPageRoutes(filesystemRoots, pageFilesAll, pageConfigs, allPageIds) {
                             pageId,
                             comesFromV1PageConfig,
                             routeFunction: route,
-                            routeDefinedAt: definedAt,
+                            routeDefinedAtString: definedAtString,
                             routeType: 'FUNCTION'
                         };
                     }
@@ -64,7 +66,7 @@ function getPageRoutes(filesystemRoots, pageFilesAll, pageConfigs, allPageIds) {
                     routeFilesystemDefinedBy: definedBy,
                     comesFromV1PageConfig,
                     routeString,
-                    routeDefinedAt: null,
+                    routeDefinedAtString: null,
                     routeType: 'FILESYSTEM'
                 };
             }
@@ -89,7 +91,7 @@ function getPageRoutes(filesystemRoots, pageFilesAll, pageConfigs, allPageIds) {
                     pageId,
                     comesFromV1PageConfig,
                     routeString,
-                    routeDefinedAt: null,
+                    routeDefinedAtString: null,
                     routeFilesystemDefinedBy: `${pageId}.page.*`,
                     routeType: 'FILESYSTEM'
                 });
@@ -104,7 +106,7 @@ function getPageRoutes(filesystemRoots, pageFilesAll, pageConfigs, allPageIds) {
                         pageId,
                         comesFromV1PageConfig,
                         routeString,
-                        routeDefinedAt: filePath,
+                        routeDefinedAtString: filePath,
                         routeType: 'STRING'
                     });
                     return;
@@ -121,7 +123,7 @@ function getPageRoutes(filesystemRoots, pageFilesAll, pageConfigs, allPageIds) {
                         pageId,
                         comesFromV1PageConfig,
                         routeFunction,
-                        routeDefinedAt: filePath,
+                        routeDefinedAtString: filePath,
                         routeType: 'FUNCTION'
                     });
                     return;

package/dist/esm/shared/route/resolveRouteFunction.d.ts

@@ -3,7 +3,7 @@ export { assertRouteParams };
 export { assertSyncRouting };
 export { warnDeprecatedAllowKey };
 import { PageContextUrlComputedPropsInternal } from '../addUrlComputedProps.js';
-declare function resolveRouteFunction(routeFunction: Function, pageContext: PageContextUrlComputedPropsInternal, routeDefinedAt: string): Promise<null | {
+declare function resolveRouteFunction(routeFunction: Function, pageContext: PageContextUrlComputedPropsInternal, routeDefinedAtString: string): Promise<null | {
     precedence: number | null;
     routeParams: Record<string, string>;
 }>;

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

@@ -3,12 +3,12 @@ export { assertRouteParams };
 export { assertSyncRouting };
 export { warnDeprecatedAllowKey };
 import { assertPageContextUrlComputedProps } from '../addUrlComputedProps.js';
-import { assert, assertUsage, assertWarning, hasProp, isPlainObject, isPromise, isStringRecord } from './utils.js';
+import { assert, assertUsage, assertWarning, hasProp, isPlainObject, isPromise } from './utils.js';
 import pc from '@brillout/picocolors';
-async function resolveRouteFunction(routeFunction, pageContext, routeDefinedAt) {
+async function resolveRouteFunction(routeFunction, pageContext, routeDefinedAtString) {
     assertPageContextUrlComputedProps(pageContext);
     let result = routeFunction(pageContext);
-    assertSyncRouting(result, `The Route Function ${routeDefinedAt}`);
+    assertSyncRouting(result, `The Route Function ${routeDefinedAtString}`);
     // TODO/v1-release: make resolveRouteFunction() and route() sync
     //* We disallow asynchronous routing, because we need to check whether a link is a Vike link in a synchronous fashion before calling ev.preventDefault() in the 'click' event listener
     result = await result;
@@ -19,11 +19,11 @@ async function resolveRouteFunction(routeFunction, pageContext, routeDefinedAt)
     if (result === true) {
         result = {};
     }
-    assertUsage(isPlainObject(result), `The Route Function ${routeDefinedAt} should return a boolean or a plain JavaScript object (but it's ${pc.cyan(`typeof result === ${JSON.stringify(typeof result)}`)} instead)`);
+    assertUsage(isPlainObject(result), `The Route Function ${routeDefinedAtString} should return a boolean or a plain JavaScript object (but it's ${pc.cyan(`typeof result === ${JSON.stringify(typeof result)}`)} instead)`);
     // AFAICT this return interface is superfluous. Should we soft-deprecate it and remove it?
     if ('match' in result) {
         const { match } = result;
-        assertUsage(typeof match === 'boolean', `The ${pc.cyan('match')} value returned by the Route Function ${routeDefinedAt} should be a boolean.`);
+        assertUsage(typeof match === 'boolean', `The ${pc.cyan('match')} value returned by the Route Function ${routeDefinedAtString} should be a boolean.`);
         if (!match) {
             return null;
         }
@@ -31,14 +31,14 @@ async function resolveRouteFunction(routeFunction, pageContext, routeDefinedAt)
     let precedence = null;
     if ('precedence' in result) {
         precedence = result.precedence;
-        assertUsage(typeof precedence === 'number', `The ${pc.cyan('precedence')} value returned by the Route Function ${routeDefinedAt} should be a number.`);
+        assertUsage(typeof precedence === 'number', `The ${pc.cyan('precedence')} value returned by the Route Function ${routeDefinedAtString} should be a number.`);
     }
-    assertRouteParams(result, `The ${pc.cyan('routeParams')} object returned by the Route Function ${routeDefinedAt} should`);
+    assertRouteParams(result, `The ${pc.cyan('routeParams')} object returned by the Route Function ${routeDefinedAtString} should`);
     const routeParams = result.routeParams || {};
     assertUsage(!('pageContext' in result), `Providing ${pc.cyan('pageContext')} in Route Functions is prohibited, see https://vike.dev/route-function#cannot-provide-pagecontext`);
     assert(isPlainObject(routeParams));
     Object.keys(result).forEach((key) => {
-        assertUsage(key === 'match' || key === 'routeParams' || key === 'precedence', `The Route Function ${routeDefinedAt} returned an object with an unknown property ${pc.cyan(key)} (the known properties are ${pc.cyan('match')}, ${pc.cyan('routeParams')}, and ${pc.cyan('precedence')})`);
+        assertUsage(key === 'match' || key === 'routeParams' || key === 'precedence', `The Route Function ${routeDefinedAtString} returned an object with an unknown property ${pc.cyan(key)} (the known properties are ${pc.cyan('match')}, ${pc.cyan('routeParams')}, and ${pc.cyan('precedence')})`);
     });
     return {
         precedence,
@@ -60,6 +60,5 @@ function assertRouteParams(result, errPrefix) {
         return;
     }
     assert(errPrefix.endsWith(' should'));
-    assertUsage(isPlainObject(result.routeParams), `${errPrefix} be a plain JavaScript object.`);
-    assertUsage(isStringRecord(result.routeParams), `${errPrefix} only hold string values.`);
+    assertUsage(hasProp(result, 'routeParams', 'string{}'), `${errPrefix} be an object holding string values.`);
 }

package/dist/esm/shared/route/resolveRouteString.d.ts

@@ -10,8 +10,6 @@ declare function resolveRouteString(routeString: string, urlPathname: string): n
 };
 type Segment = {
     glob: true;
-    /** Make route /a/* match URL /a */
-    isLastDir?: true;
     static?: undefined;
     param?: undefined;
 } | {