vike 0.4.144-commit-6aef8a6 → 0.4.144-commit-7f5e99a

package/dist/esm/node/prerender/runPrerender.js

@@ -5,7 +5,7 @@ export { prerenderForceExit };
 import '../runtime/page-files/setup.js';
 import path from 'path';
 import { route } from '../../shared/route/index.js';
-import { assert, assertUsage, assertWarning, hasProp, projectInfo, objectAssign, isObjectWithKeys, isCallable, getOutDirs, hasPropertyGetter, assertPosixPath, urlToFile, executeHook, isPlainObject, setNodeEnvToProduction } from './utils.js';
+import { assert, assertUsage, assertWarning, hasProp, projectInfo, objectAssign, isObjectWithKeys, isCallable, getOutDirs, isPropertyGetter, assertPosixPath, urlToFile, executeHook, isPlainObject, setNodeEnvToProduction } from './utils.js';
 import { pLimit } from '../../utils/pLimit.js';
 import { prerenderPage, prerender404Page, getRenderContext, getPageContextInitEnhanced } from '../runtime/renderPage/renderPageAlreadyRouted.js';
 import pc from '@brillout/picocolors';
@@ -16,7 +16,7 @@ import { getConfigVike } from '../shared/getConfigVike.js';
 import { getPageFilesServerSide } from '../../shared/getPageFiles.js';
 import { getPageContextRequestUrl } from '../../shared/getPageContextRequestUrl.js';
 import { getUrlFromRouteString } from '../../shared/route/resolveRouteString.js';
-import { getConfigValue, getConfigValueFilePathToShowToUser, getHookFilePathToShowToUser } from '../../shared/page-configs/utils.js';
+import { getConfigValue, getConfigValueFilePathToShowToUser, getHookFilePathToShowToUser } from '../../shared/page-configs/helpers.js';
 import { loadConfigValues } from '../../shared/page-configs/loadConfigValues.js';
 import { isErrorPage } from '../../shared/error-page.js';
 import { addUrlComputedProps } from '../../shared/addUrlComputedProps.js';
@@ -285,7 +285,7 @@ async function callOnPrerenderStartHook(prerenderContext, renderContext) {
         const configValue = pageConfigGlobal.configValues.onPrerenderStart;
         if (configValue?.value) {
             const { value: hookFn } = configValue;
-            // config.onPrerenderStart isn't a computed nor a cumulative config => definedAtInfo should always be defined
+            // config.onPrerenderStart isn't a computed nor a cumulative config => definedAt should always be defined
             const hookFilePath = getHookFilePathToShowToUser(configValue);
             assert(hookFilePath);
             onPrerenderStartHook = {
@@ -343,7 +343,7 @@ async function callOnPrerenderStartHook(prerenderContext, renderContext) {
             enumerable: false,
             configurable: true
         });
-        assert(hasPropertyGetter(pageContext, 'url'));
+        assert(isPropertyGetter(pageContext, 'url'));
         assert(pageContext.urlOriginal);
         pageContext._urlOriginalBeforeHook = pageContext.urlOriginal;
     });
@@ -382,7 +382,7 @@ async function callOnPrerenderStartHook(prerenderContext, renderContext) {
     prerenderContext.pageContexts = result.prerenderContext.pageContexts;
     prerenderContext.pageContexts.forEach((pageContext) => {
         // TODO/v1-release: remove
-        if (!hasPropertyGetter(pageContext, 'url') && pageContext.url) {
+        if (pageContext.url && !isPropertyGetter(pageContext, 'url')) {
             assertWarning(false, msgPrefix +
                 ' provided pageContext.url but it should provide pageContext.urlOriginal instead, see https://vike.dev/migration/0.4.23', { onlyOnce: true });
             pageContext.urlOriginal = pageContext.url;
@@ -407,10 +407,9 @@ async function routeAndPrerender(prerenderContext, htmlFiles, prerenderPageIds,
     await Promise.all(prerenderContext.pageContexts.map((pageContext) => concurrencyLimit(async () => {
         const { urlOriginal } = pageContext;
         assert(urlOriginal);
-        const routeResult = await route(pageContext);
-        assert(hasProp(routeResult.pageContextAddendum, '_pageId', 'null') ||
-            hasProp(routeResult.pageContextAddendum, '_pageId', 'string'));
-        if (routeResult.pageContextAddendum._pageId === null) {
+        const pageContextFromRoute = await route(pageContext);
+        assert(hasProp(pageContextFromRoute, '_pageId', 'null') || hasProp(pageContextFromRoute, '_pageId', 'string'));
+        if (pageContextFromRoute._pageId === null) {
             let hookName;
             let hookFilePath;
             if (pageContext._providedByHook) {
@@ -427,13 +426,13 @@ async function routeAndPrerender(prerenderContext, htmlFiles, prerenderPageIds,
             }
             else {
                 // `prerenderHookFile` is `null` when the URL was deduced by the Filesytem Routing of `.page.js` files. The `onBeforeRoute()` can override Filesystem Routing; it is therefore expected that the deduced URL may not match any page.
-                assert(routeResult.pageContextAddendum._routingProvidedByOnBeforeRouteHook);
+                assert(pageContextFromRoute._routingProvidedByOnBeforeRouteHook);
                 // Abort since the URL doesn't correspond to any page
                 return;
             }
         }
-        assert(routeResult.pageContextAddendum._pageId);
-        objectAssign(pageContext, routeResult.pageContextAddendum);
+        assert(pageContextFromRoute._pageId);
+        objectAssign(pageContext, pageContextFromRoute);
         const { _pageId: pageId } = pageContext;
         objectAssign(pageContext, await loadPageFilesServerSide(pageContext));
         let usesClientRouter;

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

@@ -5,7 +5,7 @@ export * from '../../utils/objectAssign.js';
 export * from '../../utils/isObjectWithKeys.js';
 export * from '../../utils/isCallable.js';
 export * from '../../utils/getOutDirs.js';
-export * from '../../utils/hasPropertyGetter.js';
+export * from '../../utils/isPropertyGetter.js';
 export * from '../../utils/filesystemPathHandling.js';
 export * from '../../utils/urlToFile.js';
 export * from '../../shared/hooks/executeHook.js';

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

@@ -7,7 +7,7 @@ export * from '../../utils/objectAssign.js';
 export * from '../../utils/isObjectWithKeys.js';
 export * from '../../utils/isCallable.js';
 export * from '../../utils/getOutDirs.js';
-export * from '../../utils/hasPropertyGetter.js';
+export * from '../../utils/isPropertyGetter.js';
 export * from '../../utils/filesystemPathHandling.js';
 export * from '../../utils/urlToFile.js';
 export * from '../../shared/hooks/executeHook.js';

package/dist/esm/node/runtime/html/serializePageContextClientSide.js

@@ -1,6 +1,6 @@
 export { serializePageContextClientSide };
 export { serializePageContextAbort };
-import { stringify } from '@brillout/json-serializer/stringify';
+import { stringify, isJsonSerializerError } from '@brillout/json-serializer/stringify';
 import { assert, assertWarning, hasProp, unique } from '../utils.js';
 import { isErrorPage } from '../../../shared/error-page.js';
 import { addIs404ToPageProps } from '../../../shared/addIs404ToPageProps.js';
@@ -46,19 +46,33 @@ function serializePageContextClientSide(pageContext) {
             catch (err) {
                 hasWarned = true;
                 propsNonSerializable.push(prop);
-                assert(hasProp(err, 'messageCore', 'string'));
-                assertWarning(false, [
+                let msg = [
                     `${varName} cannot be serialized and, therefore, cannot be passed to the client.`,
-                    `Make sure that ${varName} is serializable, or remove ${h(propName)} from ${h('passToClient')}.`,
-                    `Serialization error: ${err.messageCore}.`
-                ].join(' '), { onlyOnce: false });
+                    `Make sure that ${varName} is serializable, or remove ${h(propName)} from ${h('passToClient')}.`
+                ].join(' ');
+                if (isJsonSerializerError(err)) {
+                    msg = `${msg} Serialization error: ${err.messageCore}.`;
+                }
+                else {
+                    // When a property getter throws an error
+                    console.warn('Serialization error:');
+                    console.warn(err);
+                    msg = `${msg} The serialization failed because of the error printed above.`;
+                }
+                // We warn (instead of throwing an error) since Vike's client runtime throws an error (with `assertUsage()`) if the user's client code tries to access the property that cannot be serialized
+                assertWarning(false, msg, { onlyOnce: false });
             }
         });
         assert(hasWarned);
         propsNonSerializable.forEach((prop) => {
             pageContextClient[prop] = notSerializable;
         });
-        pageContextSerialized = serialize(pageContextClient);
+        try {
+            pageContextSerialized = serialize(pageContextClient);
+        }
+        catch (err) {
+            assert(false);
+        }
     }
     return pageContextSerialized;
 }

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

@@ -20,7 +20,7 @@ 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/utils.js';
+import { getConfigValueFilePathToShowToUser } from '../../../shared/page-configs/helpers.js';
 async function renderPageAlreadyRouted(pageContext) {
     // pageContext._pageId can either be the:
     //  - ID of the page matching the routing, or the

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

@@ -240,8 +240,8 @@ async function renderPageNominal(pageContext) {
     }
     // Route
     {
-        const routeResult = await route(pageContext);
-        objectAssign(pageContext, routeResult.pageContextAddendum);
+        const pageContextFromRoute = await route(pageContext);
+        objectAssign(pageContext, pageContextFromRoute);
         objectAssign(pageContext, { is404: pageContext._pageId ? null : true });
         if (pageContext._pageId === null) {
             const errorPageId = getErrorPageId(pageContext._pageFilesAll, pageContext._pageConfigs);

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

@@ -25,7 +25,7 @@ export * from '../../utils/capitalizeFirstLetter.js';
 export * from '../../utils/debugGlob.js';
 export * from '../../utils/isEquivalentError.js';
 export * from '../../utils/styleFileRE.js';
-export * from '../../utils/hasPropertyGetter.js';
+export * from '../../utils/isPropertyGetter.js';
 export * from '../../utils/debug.js';
 export * from '../../utils/urlToFile.js';
 export * from '../../utils/getGlobalObject.js';

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

@@ -28,7 +28,7 @@ export * from '../../utils/capitalizeFirstLetter.js';
 export * from '../../utils/debugGlob.js';
 export * from '../../utils/isEquivalentError.js';
 export * from '../../utils/styleFileRE.js';
-export * from '../../utils/hasPropertyGetter.js';
+export * from '../../utils/isPropertyGetter.js';
 export * from '../../utils/debug.js';
 export * from '../../utils/urlToFile.js';
 export * from '../../utils/getGlobalObject.js';

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

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

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

@@ -55,6 +55,7 @@ type PageContextUrlComputedPropsServer = PageContextUrlComputedPropsClient & {
 declare function addUrlComputedProps<PageContext extends Record<string, unknown> & PageContextUrlSources>(pageContext: PageContext, enumerable?: boolean): asserts pageContext is PageContext & PageContextUrlComputedPropsInternal;
 type PageContextUrlSources = {
     urlOriginal: string;
+    urlLogical?: string;
     _urlRewrite: string | null;
     _baseServer: string;
     _urlHandler: null | ((url: string) => string);

package/dist/esm/shared/addUrlComputedProps.js

@@ -1,28 +1,40 @@
 // URLs props need to be computed props, because the user can modify the URL e.g. with onBeforeRoute() for i18n
 export { addUrlComputedProps };
 export { assertPageContextUrlComputedProps };
-import { assert, parseUrl, assertWarning, isPlainObject, hasPropertyGetter, isBrowser } from './utils.js';
+import { assert, parseUrl, assertWarning, isPlainObject, isPropertyGetter, isBrowser } from './utils.js';
 function addUrlComputedProps(pageContext, enumerable = true) {
     assert(pageContext.urlOriginal);
     if ('urlPathname' in pageContext) {
-        assert(hasPropertyGetter(pageContext, 'urlPathname'));
+        assert(typeof pageContext.urlPathname === 'string');
+        /* If this assert() fails then it's most likely because Object.assign() was used instead of objectAssign(), i.e.:
+           ```js
+           // Add property getters such as pageContext.urlPathname to pageContext
+           addUrlComputedProps(pageContext)
+           // ❌ Breaks the property getters of pageContext set by addUrlComputedProps() such as pageContext.urlPathname
+           Object.assign(pageContext2, pageContext)
+           // ❌ Also breaks the property getters
+           const pageContext3 = { ...pageContext }
+           // ✅ Preserves property getters of pageContext (see objectAssign() implementation)
+           objectAssign(pageContext2, pageContext)
+           ```
+        */
+        assert(isPropertyGetter(pageContext, 'urlPathname'));
     }
+    if ('urlParsed' in pageContext)
+        assert(isPropertyGetter(pageContext, 'urlParsed'));
+    // TODO/v1-release: move pageContext.urlParsed to pageContext.url
+    if ('url' in pageContext)
+        assert(isPropertyGetter(pageContext, 'url'));
     Object.defineProperty(pageContext, 'urlPathname', {
         get: urlPathnameGetter,
         enumerable,
         configurable: true
     });
-    // TODO/v1-release: move pageContext.urlParsed to pageContext.url
-    if ('url' in pageContext)
-        assert(hasPropertyGetter(pageContext, 'url'));
     Object.defineProperty(pageContext, 'url', {
         get: urlGetter,
         enumerable: false,
         configurable: true
     });
-    if ('urlParsed' in pageContext) {
-        assert(hasPropertyGetter(pageContext, 'urlParsed'));
-    }
     Object.defineProperty(pageContext, 'urlParsed', {
         get: urlParsedGetter,
         enumerable,
@@ -30,17 +42,17 @@ function addUrlComputedProps(pageContext, enumerable = true) {
     });
 }
 function getUrlParsed(pageContext) {
-    // We use a url handler function because the onBeforeRoute() hook may modify pageContext.urlOriginal (e.g. for i18n)
+    // We need a url handler function because the onBeforeRoute() hook may set pageContext.urlLogical (typically for i18n)
     let urlHandler = pageContext._urlHandler;
     if (!urlHandler) {
         urlHandler = (url) => url;
     }
-    const url = pageContext._urlRewrite ?? pageContext.urlOriginal;
-    assert(url && typeof url === 'string');
-    const urlLogical = urlHandler(url);
+    let urlResolved = pageContext._urlRewrite ?? pageContext.urlLogical ?? pageContext.urlOriginal;
+    urlResolved = urlHandler(urlResolved);
     const baseServer = pageContext._baseServer;
+    assert(urlResolved && typeof urlResolved === 'string');
     assert(baseServer.startsWith('/'));
-    return parseUrl(urlLogical, baseServer);
+    return parseUrl(urlResolved, baseServer);
 }
 function urlPathnameGetter() {
     const { pathname } = getUrlParsed(this);

package/dist/esm/shared/getPageFiles/analyzeClientSide.js

@@ -1,5 +1,5 @@
 export { analyzeClientSide };
-import { getConfigValue } from '../page-configs/utils.js';
+import { getConfigValue } from '../page-configs/helpers.js';
 import { analyzePageClientSide } from './analyzePageClientSide.js';
 function analyzeClientSide(pageConfig, pageFilesAll, pageId) {
     // V1 design
@@ -9,9 +9,7 @@ function analyzeClientSide(pageConfig, pageFilesAll, pageId) {
         return { isClientSideRenderable, isClientRouting };
     }
     else {
-        // TODO/v1-release:
-        //  - remove V0.4 implementation
-        //  - globally rename isHtmlOnly to !isClientSideRenderable
+        // TODO/v1-release: remove
         // V0.4 design
         const { isHtmlOnly, isClientRouting } = analyzePageClientSide(pageFilesAll, pageId);
         return { isClientSideRenderable: !isHtmlOnly, isClientRouting };

package/dist/esm/shared/getPageFiles/getExports.js

@@ -3,7 +3,7 @@ export { getExports };
 import { isScriptFile, isTemplateFile } from '../../utils/isScriptFile.js';
 import { assert, hasProp, isObject, assertWarning, assertUsage, makeLast, isBrowser } from '../utils.js';
 import { assertDefaultExports, forbiddenDefaultExports } from './assert_exports_old_design.js';
-import { getConfigDefinedAtString, getConfigValueFilePathToShowToUser } from '../page-configs/utils.js';
+import { getConfigDefinedAtString, getConfigValueFilePathToShowToUser } from '../page-configs/helpers.js';
 import pc from '@brillout/picocolors';
 function getExports(pageFiles, pageConfig) {
     const configEntries = {};
@@ -31,7 +31,7 @@ function getExports(pageFiles, pageConfig) {
         Object.entries(pageConfig.configValues).forEach(([configName, configValue]) => {
             const { value } = configValue;
             const configValueFilePathToShowToUser = getConfigValueFilePathToShowToUser(configValue);
-            const configDefinedAt = getConfigDefinedAtString(configName, configValue, true);
+            const configDefinedAt = getConfigDefinedAtString('Config', configName, configValue);
             config[configName] = config[configName] ?? value;
             configEntries[configName] = configEntries[configName] ?? [];
             // Currently each configName has only one entry. Adding an entry for each overriden config value isn't implemented yet. (This is an isomorphic file and it isn't clear whether this can/should be implemented on the client-side. We should load a minimum amount of code on the client-side.)

package/dist/esm/shared/hooks/getHook.js

@@ -23,6 +23,6 @@ function assertHook(pageContext, hookName) {
 function assertHookFn(hookFn, { hookName, hookFilePath }) {
     assert(hookName && hookFilePath);
     assert(!hookName.endsWith(')'));
-    assertUsage(isCallable(hookFn), `hook ${hookName}() defined by ${hookFilePath} should be a function`);
+    assertUsage(isCallable(hookFn), `Hook ${hookName}() defined by ${hookFilePath} should be a function`);
     checkType(hookFn);
 }

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

@@ -13,7 +13,7 @@ export type { ConfigValueComputed };
 export type { ConfigValuesComputed };
 export type { DefinedAt };
 export type { DefinedAtFile };
-export type { DefinedAtFileInfo };
+export type { DefinedAtFileFullInfo };
 export type { FilePathResolved };
 export type { FilePath };
 import type { ConfigValueImported } from './serialize/PageConfigSerialized.js';
@@ -56,15 +56,14 @@ type ConfigEnvInternal = ConfigEnv | '_routing-eager' | '_routing-lazy';
 type ConfigValueSource = {
     value?: unknown;
     configEnv: ConfigEnvInternal;
-    definedAtInfo: DefinedAtFileInfo;
+    definedAt: DefinedAtFileFullInfo;
     /** 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 */
     valueIsFilePath?: true;
 };
-type DefinedAtFileInfo = FilePath & {
+type DefinedAtFileFullInfo = DefinedAtFile & FilePath & {
     fileExportName?: string;
-    fileExportPathToShowToUser: null | string[];
 };
 type ConfigValueSources = Record<string, ConfigValueSource[]>;
 type ConfigValueComputed = {
@@ -76,17 +75,10 @@ type ConfigValue = {
     value: unknown;
     definedAt: DefinedAt;
 };
-type DefinedAt = {
-    file: DefinedAtFile;
-    isComputed?: undefined;
-    isCumulative?: undefined;
-} | {
-    isCumulative: true;
+type DefinedAt = DefinedAtFile | {
     files: DefinedAtFile[];
-    isComputed?: undefined;
 } | {
     isComputed: true;
-    isCumulative?: undefined;
 };
 type DefinedAtFile = {
     filePathToShowToUser: string;

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

@@ -0,0 +1,7 @@
+export { getConfigDefinedAtString };
+export { getDefinedAtString };
+import type { DefinedAt } from '../PageConfig.js';
+declare function getConfigDefinedAtString<ConfigName extends string, SentenceBegin extends 'Config' | 'config' | 'Hook'>(sentenceBegin: SentenceBegin, configName: ConfigName, { definedAt }: {
+    definedAt: DefinedAt;
+}): `${SentenceBegin} ${ConfigName}${string} defined ${'internally' | `at ${string}`}`;
+declare function getDefinedAtString(definedAt: DefinedAt, configName: string): string;

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

@@ -0,0 +1,37 @@
+export { getConfigDefinedAtString };
+export { getDefinedAtString };
+import { assert } from '../../utils.js';
+import pc from '@brillout/picocolors';
+import { getExportPath } from '../getExportPath.js';
+function getConfigDefinedAtString(sentenceBegin, configName, { definedAt }) {
+    const definedAtString = getDefinedAtString(definedAt, configName);
+    const definedAtStr = definedAtString === 'internally' ? definedAtString : `at ${definedAtString}`;
+    let configNameStr = `${configName}${sentenceBegin === 'Hook' ? '()' : ''}`;
+    const configDefinedAt = `${sentenceBegin} ${pc.cyan(configNameStr)} defined ${definedAtStr}`;
+    return configDefinedAt;
+}
+function getDefinedAtString(definedAt, configName) {
+    if ('isComputed' in definedAt) {
+        return 'internally';
+    }
+    let files;
+    if ('files' in definedAt) {
+        files = definedAt.files;
+    }
+    else {
+        files = [definedAt];
+    }
+    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

@@ -0,0 +1,14 @@
+export { getConfigValue };
+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 & {
+    value: string;
+};
+declare function getConfigValue(pageConfig: PageConfigCommon, configName: ConfigName, type: 'boolean'): null | ConfigValue & {
+    value: boolean;
+};
+declare function getConfigValue(pageConfig: PageConfigCommon, configName: ConfigName): null | ConfigValue & {
+    value: unknown;
+};

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

@@ -0,0 +1,38 @@
+export { getConfigValue };
+import { assert, assertUsage, getValuePrintable } from '../../utils.js';
+import pc from '@brillout/picocolors';
+import { getConfigDefinedAtString } from './getConfigDefinedAtString.js';
+// prettier-ignore
+function getConfigValue(pageConfig, configName, type) {
+    const configValue = getConfigValueEntry(pageConfig, configName);
+    if (configValue === null)
+        return null;
+    const { value, definedAt } = configValue;
+    if (type)
+        assertConfigValueType(value, type, configName, definedAt);
+    return configValue;
+}
+function assertConfigValueType(value, type, configName, definedAt) {
+    assert(value !== null);
+    const typeActual = typeof value;
+    if (typeActual === type)
+        return;
+    const valuePrintable = getValuePrintable(value);
+    const problem = valuePrintable !== null
+        ? `value ${pc.cyan(valuePrintable)}`
+        : `type ${pc.cyan(typeActual)}`;
+    const configDefinedAt = getConfigDefinedAtString('Config', configName, {
+        definedAt
+    });
+    const errMsg = `${configDefinedAt} has an invalid ${problem}: it should be a ${pc.cyan(type)} instead`;
+    assertUsage(false, errMsg);
+}
+function getConfigValueEntry(pageConfig, configName) {
+    const configValue = pageConfig.configValues[configName];
+    if (!configValue)
+        return null;
+    // Enable users to suppress global config values by setting the local config value to null
+    if (configValue.value === null)
+        return null;
+    return configValue;
+}

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

@@ -0,0 +1,13 @@
+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';
+declare function getPageConfig(pageId: string, pageConfigs: PageConfigRuntime[]): PageConfigRuntime;
+declare function getConfigValueFilePathToShowToUser({ definedAt }: {
+    definedAt: DefinedAt;
+}): null | string;
+declare function getHookFilePathToShowToUser({ definedAt }: {
+    definedAt: DefinedAt;
+}): string;

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

@@ -0,0 +1,27 @@
+export { getPageConfig };
+export { getConfigValueFilePathToShowToUser };
+export { getHookFilePathToShowToUser };
+export { getConfigDefinedAtString, getDefinedAtString } from './helpers/getConfigDefinedAtString.js';
+export { getConfigValue } from './helpers/getConfigValue.js';
+import { assert } 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 }) {
+    // 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)
+        return null;
+    const { filePathToShowToUser } = definedAt;
+    assert(filePathToShowToUser);
+    return filePathToShowToUser;
+}
+function getHookFilePathToShowToUser({ definedAt }) {
+    const filePathToShowToUser = getConfigValueFilePathToShowToUser({ definedAt });
+    assert(filePathToShowToUser);
+    return filePathToShowToUser;
+}

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

@@ -8,14 +8,12 @@ function parseConfigValuesImported(configValuesImported) {
         configValues[configName] = {
             value,
             definedAt: {
-                file: {
-                    // 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]
-                }
+                // 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);

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

@@ -2,7 +2,7 @@ export { parsePageConfigs };
 import { parse } from '@brillout/json-serializer/parse';
 import { parseConfigValuesImported } from './parseConfigValuesImported.js';
 import { assert, assertUsage, isCallable } from '../../utils.js';
-import { getConfigDefinedAtString } from '../utils.js';
+import { getConfigDefinedAtString } from '../helpers.js';
 function parsePageConfigs(pageConfigsSerialized, pageConfigGlobalSerialized) {
     const pageConfigs = pageConfigsSerialized.map((pageConfigSerialized) => {
         const configValues = {};
@@ -49,7 +49,7 @@ function assertRouteConfigValue(configValues) {
         return;
     const { value } = configValue;
     const configValueType = typeof value;
-    const configDefinedAt = getConfigDefinedAtString(configName, configValue, true);
+    const configDefinedAt = getConfigDefinedAtString('Config', configName, configValue);
     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

@@ -23,9 +23,9 @@ function serializeConfigValue(lines, configName, configValueSerialized) {
 function serializeConfigValueImported(configValueSource, configName, whitespace, varCounterContainer, importStatements) {
     assert(!configValueSource.valueIsFilePath);
     assert(whitespace.replaceAll(' ', '').length === 0);
-    const { valueIsImportedAtRuntime, definedAtInfo } = configValueSource;
+    const { valueIsImportedAtRuntime, definedAt } = configValueSource;
     assert(valueIsImportedAtRuntime);
-    const { filePathAbsoluteVite, fileExportName } = definedAtInfo;
+    const { filePathAbsoluteVite, fileExportName } = definedAt;
     assertPosixPath(filePathAbsoluteVite);
     const fileName = path.posix.basename(filePathAbsoluteVite);
     const isValueFile = fileName.startsWith('+');

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

@@ -11,7 +11,7 @@ declare function executeOnBeforeRouteHook(onBeforeRouteHook: OnBeforeRouteHook,
     _allPageIds: string[];
 }): Promise<null | {
     urlOriginal?: string;
-    _urlOriginalPristine?: string;
+    urlLogical?: string;
     _pageId?: string | null;
     routeParams?: Record<string, string>;
 }>;

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

@@ -6,6 +6,7 @@ export { executeOnBeforeRouteHook };
 async function executeOnBeforeRouteHook(onBeforeRouteHook, pageContext) {
     let hookReturn = onBeforeRouteHook.onBeforeRoute(pageContext);
     assertSyncRouting(hookReturn, `The onBeforeRoute() hook ${onBeforeRouteHook.hookFilePath}`);
+    // TODO/v1-release: make executeOnBeforeRouteHook() and route() sync
     hookReturn = await hookReturn;
     const errPrefix = `The onBeforeRoute() hook defined by ${onBeforeRouteHook.hookFilePath}`;
     assertUsage(hookReturn === null ||
@@ -23,28 +24,25 @@ async function executeOnBeforeRouteHook(onBeforeRouteHook, pageContext) {
     if (hasProp(hookReturn.pageContext, 'routeParams')) {
         assertRouteParams(hookReturn.pageContext, `${errPrefix} returned ${pc.cyan('{ pageContext: { routeParams } }')} but routeParams should`);
     }
-    const pageContextAddendumHook = {};
+    const deprecatedReturn = (prop) => `${errPrefix} returned ${pc.cyan(`{ pageContext: { ${prop} } }`)} which is deprecated. Return ${pc.cyan('{ pageContext: { urlLogical } }')} instead.`;
     if (hasProp(hookReturn.pageContext, 'url')) {
-        assertWarning(false, `${errPrefix} returned ${pc.cyan('{ pageContext: { url } }')} but ${pc.cyan('pageContext.url')} has been renamed to ${pc.cyan('pageContext.urlOriginal')}. Return ${pc.cyan('{ pageContext: { urlOriginal } }')} instead. (See https://vike.dev/migration/0.4.23 for more information.)`, { onlyOnce: true });
-        hookReturn.pageContext.urlOriginal = hookReturn.pageContext.url;
+        assertWarning(false, deprecatedReturn('url'), { onlyOnce: true });
+        hookReturn.pageContext.urlLogical = hookReturn.pageContext.url;
         delete hookReturn.pageContext.url;
     }
     if (hasProp(hookReturn.pageContext, 'urlOriginal')) {
-        assertUsageUrl(hookReturn.pageContext.urlOriginal, `${errPrefix} returned ${pc.cyan('{ pageContext: { urlOriginal } }')} but ${pc.cyan('urlOriginal')}`);
-        // Ugly workaround: ideally urlOriginal should be immutable.
-        //  - Instead of using pageContext._urlOriginalPristine, maybe we can keep pageContext.urlOriginal immutable while re-using `pageContext._urlRewrite`.
-        //  - Or better yet we rename pageContext._urlRewrite to pageContext.urlLogical and we allow the user to override pageContext.urlLogical, and we rename pageContext.urlOriginal => `pageContext.urlReal`.
-        //    - pageContext.urlReal / pageContext.urlLogical
-        //                         VS
-        //      pageContext.urlReal / pageContext.urlModified
-        //                         VS
-        //      pageContext.urlOriginal / pageContext.urlModified
-        objectAssign(pageContextAddendumHook, { _urlOriginalPristine: pageContext.urlOriginal });
+        assertWarning(false, deprecatedReturn('urlOriginal'), { onlyOnce: true });
+        hookReturn.pageContext.urlLogical = hookReturn.pageContext.urlOriginal;
+        delete hookReturn.pageContext.urlOriginal;
+    }
+    if (hasProp(hookReturn.pageContext, 'urlLogical')) {
+        assertUsageUrl(hookReturn.pageContext.urlLogical, `${errPrefix} returned ${pc.cyan('{ pageContext: { urlLogical } }')} but ${pc.cyan('urlLogical')}`);
     }
     assertPageContextProvidedByUser(hookReturn.pageContext, {
         hookFilePath: onBeforeRouteHook.hookFilePath,
         hookName: 'onBeforeRoute'
     });
+    const pageContextAddendumHook = {};
     objectAssign(pageContextAddendumHook, hookReturn.pageContext);
     return pageContextAddendumHook;
 }