vike 0.4.229 → 0.4.230-commit-8b60b8c

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

@@ -5,6 +5,7 @@ export type { ConfigNameBuiltIn };
 export type { ConfigNameGlobal };
 export type { ConfigMeta };
 export type { HookName };
+export type { HookNameOld };
 export type { HookNamePage };
 export type { HookNameGlobal };
 export type { ImportString };
@@ -43,10 +44,11 @@ import type { Vike, VikePackages } from '../VikeNamespace.js';
 import type { HooksTimeoutProvidedByUser } from '../hooks/getHook.js';
 import type { GlobalContext, PageContextClient, PageContextServer } from '../types.js';
 import type { InlineConfig } from 'vite';
-type HookName = HookNamePage | HookNameGlobal | HookNameOldDesign;
-type HookNamePage = 'onHydrationEnd' | 'onBeforePrerenderStart' | 'onBeforeRender' | 'onPageTransitionStart' | 'onPageTransitionEnd' | 'onRenderHtml' | 'onRenderClient' | 'guard' | 'data';
-type HookNameGlobal = 'onBeforePrerender' | 'onBeforeRoute' | 'onPrerenderStart' | 'onCreatePageContext' | 'onCreateGlobalContext';
-type HookNameOldDesign = 'render' | 'prerender';
+type HookNameOld = HookName | HookNameOldDesign;
+type HookName = HookNamePage | HookNameGlobal;
+type HookNamePage = 'onHydrationEnd' | 'onBeforePrerenderStart' | 'onBeforeRender' | 'onPageTransitionStart' | 'onPageTransitionEnd' | 'onRenderHtml' | 'onRenderClient' | 'guard' | 'data' | 'onData' | 'route';
+type HookNameGlobal = 'onBeforeRoute' | 'onPrerenderStart' | 'onCreatePageContext' | 'onCreateGlobalContext';
+type HookNameOldDesign = 'render' | 'prerender' | 'onBeforePrerender';
 type ConfigNameBuiltIn = Exclude<keyof Config, keyof VikeVitePluginOptions | 'onBeforeRoute' | 'onPrerenderStart' | 'vite' | 'redirects'> | 'prerender' | 'isClientRuntimeLoaded' | 'onBeforeRenderEnv' | 'dataEnv' | 'hooksTimeout' | 'clientHooks' | 'middleware';
 type ConfigNameGlobal = 'onPrerenderStart' | 'onBeforeRoute' | 'prerender' | 'disableAutoFullBuild' | 'includeAssetsImportedByServer' | 'baseAssets' | 'baseServer' | 'redirects' | 'trailingSlash' | 'disableUrlNormalization' | 'vite';
 type Config = ConfigBuiltIn & Vike.Config & (VikePackages.ConfigVikeReact | VikePackages.ConfigVikeVue | VikePackages.ConfigVikeSolid | VikePackages.ConfigVikeSvelte | VikePackages.ConfigVikeAngular);
@@ -345,6 +347,11 @@ type ConfigBuiltIn = {
      *  https://vike.dev/data
      */
     data?: DataAsync<unknown> | DataSync<unknown> | ImportString | null;
+    /** Hook called as soon as `pageContext.data` is available.
+     *
+     *  https://vike.dev/onData
+     */
+    onData?: Function;
     /** Determines what pageContext properties are sent to the client-side.
      *
      * https://vike.dev/passToClient

package/dist/esm/shared/page-configs/{getPageConfigUserFriendly.d.ts → getUserFriendlyConfigs.d.ts}

@@ -1,6 +1,6 @@
-export { getPageConfigUserFriendly };
-export { getPageConfigUserFriendly_oldDesign };
-export { getPageConfigGlobalUserFriendly };
+export { getUserFriendlyConfigsGlobal };
+export { getUserFriendlyConfigsPageEager };
+export { getUserFriendlyConfigsPageLazy };
 export type { PageConfigsUserFriendly };
 export type { PageConfigUserFriendly };
 export type { PageConfigUserFriendlyOld };
@@ -92,8 +92,10 @@ type WithRoute = {
     isErrorPage: true;
 };
 type PageConfigUserFriendlyWithRoute = PageConfigUserFriendly & WithRoute;
-declare function getPageConfigUserFriendly(pageConfigGlobalValues: ConfigValues, pageConfig: PageConfigRuntime | PageConfigBuildTime, pageConfigValues: ConfigValues): [string, PageConfigUserFriendlyWithRoute];
-declare function getPageConfigGlobalUserFriendly({ pageConfigGlobalValues }: {
+declare function getUserFriendlyConfigsPageEager(pageConfigGlobalValues: ConfigValues, pageConfig: PageConfigRuntime | PageConfigBuildTime, pageConfigValues: ConfigValues): [string, PageConfigUserFriendlyWithRoute];
+declare function getUserFriendlyConfigsGlobal({ pageConfigGlobalValues }: {
     pageConfigGlobalValues: ConfigValues;
 }): PageConfigUserFriendly;
-declare function getPageConfigUserFriendly_oldDesign(pageFiles: PageFile[], pageConfig: PageConfigRuntimeLoaded | null, pageConfigGlobal: PageConfigGlobalRuntime): PageConfigUserFriendlyOld;
+declare function getUserFriendlyConfigsPageLazy(pageFiles: PageFile[], // V0.4 design
+pageConfig: PageConfigRuntimeLoaded | null, // V1 design
+pageConfigGlobal: PageConfigGlobalRuntime): PageConfigUserFriendlyOld;

package/dist/esm/shared/page-configs/{getPageConfigUserFriendly.js → getUserFriendlyConfigs.js}

@@ -1,13 +1,13 @@
-export { getPageConfigUserFriendly };
-export { getPageConfigUserFriendly_oldDesign };
-export { getPageConfigGlobalUserFriendly };
+export { getUserFriendlyConfigsGlobal };
+export { getUserFriendlyConfigsPageEager };
+export { getUserFriendlyConfigsPageLazy };
 import { assertDefaultExports, forbiddenDefaultExports } from '../getPageFiles/assert_exports_old_design.js';
 import { getConfigDefinedAtOptional, getDefinedAtString } from './getConfigDefinedAt.js';
 import { getConfigValueFilePathToShowToUser } from './helpers.js';
-import { assert, isObject, assertWarning, assertUsage, makeLast, isBrowser, isScriptFile, isTemplateFile } from '../utils.js';
+import { assert, isObject, assertWarning, assertUsage, makeLast, isBrowser, isScriptFile, isTemplateFile, objectDefineProperty } from '../utils.js';
 import pc from '@brillout/picocolors';
-function getPageConfigUserFriendly(pageConfigGlobalValues, pageConfig, pageConfigValues) {
-    const pageConfigUserFriendly = getPageConfigUserFriendly_public({ pageConfigGlobalValues, pageConfigValues });
+function getUserFriendlyConfigsPageEager(pageConfigGlobalValues, pageConfig, pageConfigValues) {
+    const pageConfigUserFriendly = getUserFriendlyConfigs_public({ pageConfigGlobalValues, pageConfigValues });
     let page;
     if (!pageConfig.isErrorPage) {
         const route = pageConfigUserFriendly.config.route ?? pageConfig.routeFilesystem.routeString;
@@ -24,8 +24,8 @@ function getPageConfigUserFriendly(pageConfigGlobalValues, pageConfig, pageConfi
     }
     return [pageConfig.pageId, page];
 }
-function getPageConfigUserFriendly_public({ pageConfigGlobalValues, pageConfigValues }) {
-    const pageConfigUserFriendly = getPageConfigUserFriendly_base({ pageConfigGlobalValues, pageConfigValues });
+function getUserFriendlyConfigs_public({ pageConfigGlobalValues, pageConfigValues }) {
+    const pageConfigUserFriendly = getUserFriendlyConfigs_base({ pageConfigGlobalValues, pageConfigValues });
     return getPublicCopy(pageConfigUserFriendly);
 }
 function getPublicCopy(pageConfigUserFriendly) {
@@ -37,15 +37,17 @@ function getPublicCopy(pageConfigUserFriendly) {
         _from: p.from
     };
 }
-function getPageConfigUserFriendly_base({ pageConfigGlobalValues, pageConfigValues }) {
+function getUserFriendlyConfigs_base({ pageConfigGlobalValues, pageConfigValues }) {
     const configValues = { ...pageConfigGlobalValues, ...pageConfigValues };
-    return getPageConfigUserFriendly_V1Design({ configValues });
+    return getUserFriendlyConfigs_V1Design({ configValues });
 }
-function getPageConfigGlobalUserFriendly({ pageConfigGlobalValues }) {
-    const pageConfigGlobalUserFriendly = getPageConfigUserFriendly_V1Design({ configValues: pageConfigGlobalValues });
+function getUserFriendlyConfigsGlobal({ pageConfigGlobalValues }) {
+    const pageConfigGlobalUserFriendly = getUserFriendlyConfigs_V1Design({ configValues: pageConfigGlobalValues });
     return getPublicCopy(pageConfigGlobalUserFriendly);
 }
-function getPageConfigUserFriendly_oldDesign(pageFiles, pageConfig, pageConfigGlobal) {
+function getUserFriendlyConfigsPageLazy(pageFiles, // V0.4 design
+pageConfig, // V1 design
+pageConfigGlobal) {
     const config = {};
     const configEntries = {}; // TODO/v1-release: remove
     const exportsAll = {}; // TODO/v1-release: remove
@@ -70,7 +72,7 @@ function getPageConfigUserFriendly_oldDesign(pageFiles, pageConfig, pageConfigGl
     let sources;
     let from;
     if (pageConfig) {
-        const res = getPageConfigUserFriendly_base({
+        const res = getUserFriendlyConfigs_base({
             pageConfigGlobalValues: pageConfigGlobal.configValues,
             pageConfigValues: pageConfig.configValues
         });
@@ -90,7 +92,7 @@ function getPageConfigUserFriendly_oldDesign(pageFiles, pageConfig, pageConfigGl
             configsComputed: {}
         };
     }
-    const pageExports = createObjectWithDeprecationWarning();
+    const pageExports = {};
     const exports = {};
     Object.entries(exportsAll).forEach(([exportName, values]) => {
         values.forEach(({ exportValue, _fileType, _isFromDefaultExport }) => {
@@ -113,13 +115,27 @@ function getPageConfigUserFriendly_oldDesign(pageFiles, pageConfig, pageConfigGl
         // TODO/eventually: deprecate/remove every prop below
         configEntries,
         exports,
-        exportsAll,
-        pageExports
+        exportsAll
     };
+    // TODO/v1-release: remove
+    objectDefineProperty(pageContextExports, 'pageExports', {
+        get: () => {
+            // We only show the warning in Node.js because when using Client Routing Vue integration uses `Object.assign(pageContextReactive, pageContext)` which will wrongully trigger the warning. There is no cross-browser way to catch whether the property accessor was initiated by an `Object.assign()` call.
+            if (!isBrowser()) {
+                assertWarning(false, 'pageContext.pageExports is outdated, use pageContext.exports instead', {
+                    onlyOnce: true,
+                    showStackTrace: true
+                });
+            }
+            return pageExports;
+        },
+        enumerable: false,
+        configurable: true
+    });
     return pageContextExports;
 }
 // V1 design
-function getPageConfigUserFriendly_V1Design(pageConfig) {
+function getUserFriendlyConfigs_V1Design(pageConfig) {
     const config = {};
     const configEntries = {};
     const exportsAll = {};
@@ -135,19 +151,30 @@ function getPageConfigUserFriendly_V1Design(pageConfig) {
         sources[configName] ?? (sources[configName] = []);
         sources[configName].push(src);
     };
-    Object.entries(pageConfig.configValues).forEach(([configName, configValue]) => {
-        const { value } = configValue;
-        const configValueFilePathToShowToUser = getConfigValueFilePathToShowToUser(configValue.definedAtData);
-        const configDefinedAt = getConfigDefinedAtOptional('Config', configName, configValue.definedAtData);
-        config[configName] = config[configName] ?? value;
+    const addLegacy = (configName, value, definedAtData) => {
+        const configValueFilePathToShowToUser = getConfigValueFilePathToShowToUser(definedAtData);
+        const configDefinedAt = getConfigDefinedAtOptional('Config', configName, definedAtData);
         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.)
-        assert(configEntries[configName].length === 0);
         configEntries[configName].push({
             configValue: value,
             configDefinedAt,
             configDefinedByFile: configValueFilePathToShowToUser
         });
+        // TODO/v1-release: remove
+        const exportName = configName;
+        exportsAll[exportName] = exportsAll[exportName] ?? [];
+        exportsAll[exportName].push({
+            exportValue: value,
+            exportSource: configDefinedAt,
+            filePath: configValueFilePathToShowToUser,
+            _filePath: configValueFilePathToShowToUser,
+            _fileType: null,
+            _isFromDefaultExport: null
+        });
+    };
+    Object.entries(pageConfig.configValues).forEach(([configName, configValue]) => {
+        const { value } = configValue;
+        config[configName] = config[configName] ?? value;
         if (configValue.type === 'standard') {
             const src = {
                 type: 'configsStandard',
@@ -156,6 +183,7 @@ function getPageConfigUserFriendly_V1Design(pageConfig) {
             };
             addSrc(src, configName);
             from.configsStandard[configName] = src;
+            addLegacy(configName, value, configValue.definedAtData);
         }
         if (configValue.type === 'cumulative') {
             const src = {
@@ -164,6 +192,7 @@ function getPageConfigUserFriendly_V1Design(pageConfig) {
                     const definedAtFile = configValue.definedAtData[i];
                     assert(definedAtFile);
                     const definedAt = getDefinedAtString(definedAtFile, configName);
+                    addLegacy(configName, value, definedAtFile);
                     return {
                         value,
                         definedAt
@@ -180,18 +209,8 @@ function getPageConfigUserFriendly_V1Design(pageConfig) {
             };
             addSrc(src, configName);
             from.configsComputed[configName] = src;
+            addLegacy(configName, value, configValue.definedAtData);
         }
-        // TODO/v1-release: remove
-        const exportName = configName;
-        exportsAll[exportName] = exportsAll[exportName] ?? [];
-        exportsAll[exportName].push({
-            exportValue: value,
-            exportSource: configDefinedAt,
-            filePath: configValueFilePathToShowToUser,
-            _filePath: configValueFilePathToShowToUser,
-            _fileType: null,
-            _isFromDefaultExport: null
-        });
     });
     return {
         config: config,
@@ -239,15 +258,3 @@ function getExportValues(pageFile) {
     });
     return exportValues;
 }
-// TODO/v1-release: remove
-function createObjectWithDeprecationWarning() {
-    return new Proxy({}, {
-        get(...args) {
-            // We only show the warning in Node.js because when using Client Routing Vue integration uses `Object.assign(pageContextReactive, pageContext)` which will wrongully trigger the warning. There is no cross-browser way to catch whether the property accessor was initiated by an `Object.assign()` call.
-            if (!isBrowser()) {
-                assertWarning(false, '`pageContext.pageExports` is outdated. Use `pageContext.exports` instead, see https://vike.dev/exports', { onlyOnce: true, showStackTrace: true });
-            }
-            return Reflect.get(...args);
-        }
-    });
-}

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

@@ -0,0 +1,7 @@
+export { prepareGlobalContextForPublicUsage };
+export type { GlobalContextPrepareMinimum };
+type GlobalContextPrepareMinimum = {
+    _isOriginalObject: true;
+    isGlobalContext: true;
+};
+declare function prepareGlobalContextForPublicUsage<GlobalContext extends GlobalContextPrepareMinimum>(globalContext: GlobalContext): GlobalContext;

package/dist/esm/shared/prepareGlobalContextForPublicUsage.js

@@ -0,0 +1,8 @@
+export { prepareGlobalContextForPublicUsage };
+import { getProxyForPublicUsage } from './getProxyForPublicUsage.js';
+import { assert } from './utils.js';
+function prepareGlobalContextForPublicUsage(globalContext) {
+    assert(globalContext._isOriginalObject); // ensure we preserve the original object reference
+    const globalContextPublic = getProxyForPublicUsage(globalContext, 'globalContext');
+    return globalContextPublic;
+}

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

@@ -0,0 +1,11 @@
+export { preparePageContextForPublicUsage };
+export { assertPropertyGetters };
+export type { PageContextPrepareMinimum };
+import { type GlobalContextPrepareMinimum } from './prepareGlobalContextForPublicUsage.js';
+type PageContextPrepareMinimum = {
+    _isOriginalObject: true;
+    isPageContext: true;
+    _globalContext: GlobalContextPrepareMinimum;
+};
+declare function preparePageContextForPublicUsage<PageContext extends PageContextPrepareMinimum>(pageContext: PageContext): PageContext;
+declare function assertPropertyGetters(pageContext: Record<string, unknown>): void;

package/dist/esm/shared/preparePageContextForPublicUsage.js

@@ -0,0 +1,78 @@
+export { preparePageContextForPublicUsage };
+export { assertPropertyGetters };
+import { assert, assertWarning, compareString, isPropertyGetter } from './utils.js';
+import { addIs404ToPageProps } from './addIs404ToPageProps.js';
+import { prepareGlobalContextForPublicUsage } from './prepareGlobalContextForPublicUsage.js';
+import { getProxyForPublicUsage } from './getProxyForPublicUsage.js';
+function preparePageContextForPublicUsage(pageContext) {
+    assert(!pageContext._isProxyObject);
+    assert(!pageContext.globalContext); // pageContext.globalContext should only be available to users — Vike itself should use pageContext._globalContext instead
+    assert(pageContext._isOriginalObject); // ensure we preserve the original object reference
+    addIs404ToPageProps(pageContext);
+    // TODO/next-major-release: remove
+    if (!('_pageId' in pageContext)) {
+        Object.defineProperty(pageContext, '_pageId', {
+            get() {
+                assertWarning(false, 'pageContext._pageId has been renamed to pageContext.pageId', {
+                    showStackTrace: true,
+                    onlyOnce: true
+                });
+                return pageContext.pageId;
+            },
+            enumerable: false
+        });
+    }
+    // For a more readable `console.log(pageContext)` output
+    sortPageContext(pageContext);
+    const globalContextPublic = prepareGlobalContextForPublicUsage(pageContext._globalContext);
+    const pageContextPublic = getProxyForPublicUsage(pageContext, 'pageContext', 
+    // We must skip it in the client-side because of the reactivity mechanism of UI frameworks like Solid.
+    // - TODO/now: double check whether that's true
+    true, (prop) => {
+        if (prop === 'globalContext') {
+            return globalContextPublic;
+        }
+        if (prop in globalContextPublic) {
+            return globalContextPublic[prop];
+        }
+    });
+    return pageContextPublic;
+}
+// Sort `pageContext` keys alphabetically, in order to make reading the `console.log(pageContext)` output easier
+function sortPageContext(pageContext) {
+    let descriptors = Object.getOwnPropertyDescriptors(pageContext);
+    for (const key of Object.keys(pageContext))
+        delete pageContext[key];
+    descriptors = Object.fromEntries(Object.entries(descriptors).sort(([key1], [key2]) => compareString(key1, key2)));
+    Object.defineProperties(pageContext, descriptors);
+}
+function assertPropertyGetters(pageContext) {
+    /*
+    If the isPropertyGetter() assertions fail then it's most likely because Object.assign() was used instead of `objectAssign()`:
+    ```js
+    const PageContextUrlComputed = getPageContextUrlComputed(pageContext)
+  
+    // ❌ Breaks the property descriptors/getters of pageContext defined by getPageContextUrlComputed() such as pageContext.urlPathname
+    Object.assign(pageContext, pageContextUrlComputed)
+  
+    // ❌ Also breaks property descriptors/getters
+    const pageContext = { ...pageContextUrlComputed }
+  
+    // ✅ Preserves property descriptors/getters (see objectAssign() implementation)
+    objectAssign(pageContext, pageContextUrlComputed)
+    ```
+    */
+    ;
+    [
+        'urlPathname',
+        // TODO/v1-release: remove
+        'urlParsed',
+        // TODO/v1-release: remove
+        'url',
+        // TODO/v1-release: remove
+        'pageExports'
+    ].forEach((prop) => {
+        if (pageContext.prop)
+            assert(isPropertyGetter(pageContext, prop));
+    });
+}

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

@@ -7,7 +7,7 @@ export { logAbortErrorHandled };
 export { getPageContextFromAllRewrites };
 export { AbortRender };
 export { assertNoInfiniteAbortLoop };
-import { isUserHookError } from '../hooks/executeHook.js';
+import { isUserHookError } from '../hooks/execHook.js';
 import { assert, assertInfo, assertUsage, assertUsageUrlPathnameAbsolute, assertUsageUrlRedirectTarget, assertWarning, checkType, hasProp, joinEnglish, objectAssign, truncateString } from './utils.js';
 import pc from '@brillout/picocolors';
 /**

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

@@ -1,3 +1,6 @@
 export { debug };
-import type { Debug } from '../../utils/debug.js';
+export { setCreateDebugger };
+import type { createDebugger, Debug } from '../../utils/debug.js';
+type CreateDebugger = typeof createDebugger;
 declare function debug(...args: Parameters<Debug>): void;
+declare function setCreateDebugger(createDebugger: CreateDebugger): void;

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

@@ -1,11 +1,21 @@
 export { debug };
-var _debug;
+export { setCreateDebugger };
+// Using createDebugger() for isomorphic code without bloating the client-side.
+// On the server-side, this is just a transparent proxy.
+// On the client-side, this is an emtpy shell.
+import { getGlobalObject } from '../../utils/getGlobalObject.js';
+const globalObject = getGlobalObject('route/debug.ts', {});
 function debug(...args) {
-    if (!_debug) {
-        // We use this trick instead of `import { createDebugger } from '../../utils/debug` in order to ensure that the `debug` mechanism is only loaded on the server-side
-        _debug = globalThis.__brillout_debug_createDebugger?.('vike:routing');
-    }
-    if (_debug) {
-        _debug(...args);
+    // Client-side => does nothing
+    if (!globalObject.createDebugger)
+        return;
+    // Server-side => just a proxy
+    if (!globalObject.debug) {
+        globalObject.debug = globalObject.createDebugger('vike:routing');
     }
+    globalObject.debug(...args);
+}
+// Called only on the server-side
+function setCreateDebugger(createDebugger) {
+    globalObject.createDebugger = createDebugger;
 }

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

@@ -1,8 +1,9 @@
 export { executeGuardHook };
-import type { PageConfigUserFriendlyOld, PageFile } from '../getPageFiles.js';
+import type { PageFile } from '../getPageFiles.js';
 import type { PageConfigRuntime } from '../page-configs/PageConfig.js';
-declare function executeGuardHook<T extends PageConfigUserFriendlyOld & {
+import { type PageContextExecuteHook } from '../hooks/execHook.js';
+declare function executeGuardHook<PageContext extends {
     pageId: string;
     _pageFilesAll: PageFile[];
     _pageConfigs: PageConfigRuntime[];
-}>(pageContext: T, prepareForUserConsumption: (pageConfig: T) => T | void): Promise<void>;
+} & PageContextExecuteHook>(pageContext: PageContext, prepareForPublicUsage: (pageConfig: PageContext) => PageContext): Promise<void>;

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

@@ -1,11 +1,12 @@
 export { executeGuardHook };
 import { getHookFromPageContext, getHookTimeoutDefault } from '../hooks/getHook.js';
 import { assert, assertUsage, isCallable } from './utils.js';
-import { executeHook } from '../hooks/executeHook.js';
+import { execHookSingle } from '../hooks/execHook.js';
 const errIntro = 'The guard() hook defined by';
-async function executeGuardHook(pageContext, prepareForUserConsumption) {
+async function executeGuardHook(pageContext, prepareForPublicUsage) {
     let hook;
     if (pageContext._pageFilesAll.length > 0) {
+        // TODO/v1-release: remove
         // V0.4 design
         assert(pageContext._pageConfigs.length === 0);
         hook = findPageGuard(pageContext.pageId, pageContext._pageFilesAll);
@@ -16,13 +17,7 @@ async function executeGuardHook(pageContext, prepareForUserConsumption) {
     }
     if (!hook)
         return;
-    const guard = hook.hookFn;
-    let pageContextForUserConsumption = pageContext;
-    const res = prepareForUserConsumption(pageContext);
-    if (res)
-        pageContextForUserConsumption = res;
-    const hookResult = await executeHook(() => guard(pageContextForUserConsumption), hook, pageContext);
-    assertUsage(hookResult === undefined, `${errIntro} ${hook.hookFilePath} returns a value, but guard() shouldn't return any value`);
+    await execHookSingle(hook, pageContext, prepareForPublicUsage);
 }
 function findPageGuard(pageId, pageFilesAll) {
     const pageRouteFile = pageFilesAll.find((p) => p.pageId === pageId && p.fileType === '.page.route');

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

@@ -3,7 +3,8 @@ import { assertPageContextProvidedByUser } from '../assertPageContextProvidedByU
 import { assertUsage, hasProp, isObjectWithKeys, objectAssign, assertWarning, assertUsageUrlPathnameAbsolute, joinEnglish, assert } from './utils.js';
 import { assertRouteParams, assertSyncRouting } from './resolveRouteFunction.js';
 import pc from '@brillout/picocolors';
-import { executeHook } from '../hooks/executeHook.js';
+import { execHookSync } from '../hooks/execHook.js';
+import { preparePageContextForPublicUsage } from '../preparePageContextForPublicUsage.js';
 async function executeOnBeforeRouteHook(pageContext) {
     const pageContextFromOnBeforeRouteHook = {};
     if (!pageContext._onBeforeRouteHook)
@@ -33,10 +34,10 @@ async function executeOnBeforeRouteHook(pageContext) {
     return pageContextFromOnBeforeRouteHook;
 }
 async function getPageContextFromHook(onBeforeRouteHook, pageContext) {
-    let hookReturn = onBeforeRouteHook.hookFn(pageContext);
+    let { hookReturn } = execHookSync(onBeforeRouteHook, pageContext, preparePageContextForPublicUsage);
     assertSyncRouting(hookReturn, `The onBeforeRoute() hook ${onBeforeRouteHook.hookFilePath}`);
     // TODO/v1-release: make executeOnBeforeRouteHook() and route() sync
-    hookReturn = await executeHook(() => hookReturn, onBeforeRouteHook, pageContext);
+    hookReturn = await hookReturn;
     const errPrefix = `The onBeforeRoute() hook defined by ${onBeforeRouteHook.hookFilePath}`;
     assertUsage(hookReturn === null ||
         hookReturn === undefined ||

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

@@ -6,7 +6,6 @@ if (isBrowser()) {
     assertClientRouting();
 }
 import { assert, assertUsage, isPlainObject, objectAssign } from './utils.js';
-import { assertPageContextUrl } from '../getPageContextUrlComputed.js';
 import { resolvePrecendence } from './resolvePrecedence.js';
 import { resolveRouteString } from './resolveRouteString.js';
 import { resolveRouteFunction } from './resolveRouteFunction.js';
@@ -15,7 +14,6 @@ import { debug } from './debug.js';
 import pc from '@brillout/picocolors';
 async function route(pageContext, skipOnBeforeRouteHook) {
     debug('Pages routes:', pageContext._pageRoutes);
-    assertPageContextUrl(pageContext);
     const pageContextFromRoute = {};
     // onBeforeRoute()
     if (!skipOnBeforeRouteHook) {
@@ -69,8 +67,8 @@ async function route(pageContext, skipOnBeforeRouteHook) {
         }
         // Route Function defined in `.page.route.js`
         if (pageRoute.routeType === 'FUNCTION') {
-            const { routeFunction, routeDefinedAtString } = pageRoute;
-            const match = await resolveRouteFunction(routeFunction, pageContext, routeDefinedAtString);
+            const { routeFunction, routeFunctionFilePath } = pageRoute;
+            const match = await resolveRouteFunction(routeFunction, pageContext, routeFunctionFilePath);
             if (match) {
                 const { routeParams, precedence } = match;
                 routeMatches.push({ pageId, precedence, routeParams, routeType });

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

@@ -17,7 +17,8 @@ type PageRoute = {
     routeDefinedAtString: string;
     routeType: 'STRING';
 } | {
-    routeFunction: Function;
+    routeFunction: (arg: unknown) => unknown;
+    routeFunctionFilePath: string;
     routeDefinedAtString: string;
     routeType: 'FUNCTION';
 });

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

@@ -2,7 +2,7 @@ export { loadPageRoutes };
 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 { isArray, isCallable } from '../utils.js';
 import { getConfigValueRuntime } from '../page-configs/getConfigValueRuntime.js';
 import { getDefinedAtString } from '../page-configs/getConfigDefinedAt.js';
 import { warnDeprecatedAllowKey } from './resolveRouteFunction.js';
@@ -44,6 +44,10 @@ function getPageRoutes(filesystemRoots, pageFilesAll, pageConfigs, allPageIds) {
                         };
                     }
                     else {
+                        const { definedAtData } = configValue;
+                        assert(!isArray(definedAtData) && !definedAtData.definedBy);
+                        const { filePathToShowToUser } = definedAtData;
+                        assert(filePathToShowToUser);
                         assert(isCallable(route));
                         // TODO/next-major: remove
                         if (getConfigValueRuntime(pageConfig, 'iKnowThePerformanceRisksOfAsyncRouteFunctions', 'boolean'))
@@ -52,6 +56,7 @@ function getPageRoutes(filesystemRoots, pageFilesAll, pageConfigs, allPageIds) {
                             pageId,
                             comesFromV1PageConfig,
                             routeFunction: route,
+                            routeFunctionFilePath: filePathToShowToUser,
                             routeDefinedAtString: definedAtString,
                             routeType: 'FUNCTION'
                         };
@@ -125,6 +130,7 @@ function getPageRoutes(filesystemRoots, pageFilesAll, pageConfigs, allPageIds) {
                         pageId,
                         comesFromV1PageConfig,
                         routeFunction,
+                        routeFunctionFilePath: filePath,
                         routeDefinedAtString: filePath,
                         routeType: 'FUNCTION'
                     });

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

@@ -2,8 +2,8 @@ export { resolveRouteFunction };
 export { assertRouteParams };
 export { assertSyncRouting };
 export { warnDeprecatedAllowKey };
-import { PageContextUrlInternal } from '../getPageContextUrlComputed.js';
-declare function resolveRouteFunction(routeFunction: Function, pageContext: PageContextUrlInternal, routeDefinedAtString: string): Promise<null | {
+import type { PageContextUrlInternal } from '../getPageContextUrlComputed.js';
+declare function resolveRouteFunction(routeFunction: (arg: unknown) => unknown, pageContext: PageContextUrlInternal, routeFunctionFilePath: string): Promise<null | {
     precedence: number | null;
     routeParams: Record<string, string>;
 }>;

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

@@ -2,13 +2,17 @@ export { resolveRouteFunction };
 export { assertRouteParams };
 export { assertSyncRouting };
 export { warnDeprecatedAllowKey };
-import { assertPageContextUrl } from '../getPageContextUrlComputed.js';
+import { execHookSync } from '../hooks/execHook.js';
+import { preparePageContextForPublicUsage } from '../preparePageContextForPublicUsage.js';
 import { assert, assertUsage, assertWarning, hasProp, isPlainObject, isPromise } from './utils.js';
 import pc from '@brillout/picocolors';
-async function resolveRouteFunction(routeFunction, pageContext, routeDefinedAtString) {
-    assertPageContextUrl(pageContext);
-    let result = routeFunction(pageContext);
-    assertSyncRouting(result, `The Route Function ${routeDefinedAtString}`);
+async function resolveRouteFunction(routeFunction, pageContext, routeFunctionFilePath) {
+    let { hookReturn: result } = execHookSync({
+        hookFn: routeFunction,
+        hookFilePath: routeFunctionFilePath,
+        hookName: 'route'
+    }, pageContext, preparePageContextForPublicUsage);
+    assertSyncRouting(result, `The Route Function ${routeFunctionFilePath}`);
     // 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 +23,11 @@ async function resolveRouteFunction(routeFunction, pageContext, routeDefinedAtSt
     if (result === true) {
         result = {};
     }
-    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)`);
+    assertUsage(isPlainObject(result), `The Route Function ${routeFunctionFilePath} 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 ${routeDefinedAtString} should be a boolean.`);
+        assertUsage(typeof match === 'boolean', `The ${pc.cyan('match')} value returned by the Route Function ${routeFunctionFilePath} should be a boolean.`);
         if (!match) {
             return null;
         }
@@ -31,14 +35,14 @@ async function resolveRouteFunction(routeFunction, pageContext, routeDefinedAtSt
     let precedence = null;
     if ('precedence' in result) {
         precedence = result.precedence;
-        assertUsage(typeof precedence === 'number', `The ${pc.cyan('precedence')} value returned by the Route Function ${routeDefinedAtString} should be a number.`);
+        assertUsage(typeof precedence === 'number', `The ${pc.cyan('precedence')} value returned by the Route Function ${routeFunctionFilePath} should be a number.`);
     }
-    assertRouteParams(result, `The ${pc.cyan('routeParams')} object returned by the Route Function ${routeDefinedAtString} should`);
+    assertRouteParams(result, `The ${pc.cyan('routeParams')} object returned by the Route Function ${routeFunctionFilePath} 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 ${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')})`);
+        assertUsage(key === 'match' || key === 'routeParams' || key === 'precedence', `The Route Function ${routeFunctionFilePath} 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,