vike 0.4.229-commit-7056ef0 → 0.4.229-commit-e27d672

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

@@ -0,0 +1,162 @@
+export { execHook };
+export { execHookSingle };
+export { execHookSingleWithReturn };
+export { execHookErrorHandling };
+export { execHooksErrorHandling };
+export { execHookWithoutPageContext };
+export { execHookGlobal };
+export { execHookSync };
+export { getPageContext };
+export { providePageContext };
+export { isUserHookError };
+import { getProjectError, assertWarning, assertUsage } from '../../utils/assert.js';
+import { getGlobalObject } from '../../utils/getGlobalObject.js';
+import { humanizeTime } from '../../utils/humanizeTime.js';
+import { isObject } from '../../utils/isObject.js';
+import { getHookFromPageConfigGlobalCumulative, getHookFromPageContextNew } from './getHook.js';
+import { preparePageContextForPublicUsage } from '../preparePageContextForPublicUsage.js';
+const globalObject = getGlobalObject('utils/execHook.ts', {
+    userHookErrors: new WeakMap(),
+    pageContext: null
+});
+async function execHookSingle(hook, pageContext, preparePageContextForPublicUsage) {
+    const res = await execHooksErrorHandling([hook], pageContext, preparePageContextForPublicUsage);
+    if ('err' in res)
+        throw res.err;
+    const { hookReturn } = res.hooks[0];
+    assertUsage(hookReturn === undefined, `The ${hook.hookName}() hook defined by ${hook.hookFilePath} isn't allowed to return a value`);
+}
+async function execHookSingleWithReturn(hook, pageContext, preparePageContextForPublicUsage) {
+    const res = await execHooksErrorHandling([hook], pageContext, preparePageContextForPublicUsage);
+    if ('err' in res)
+        throw res.err;
+    const { hookReturn } = res.hooks[0];
+    return { hookReturn };
+}
+async function execHook(hookName, pageContext, preparePageContextForPublicUsage) {
+    const res = await execHookErrorHandling(hookName, pageContext, preparePageContextForPublicUsage);
+    if ('err' in res)
+        throw res.err;
+    return res.hooks;
+}
+async function execHookErrorHandling(hookName, pageContext, preparePageContextForPublicUsage) {
+    const hooks = getHookFromPageContextNew(hookName, pageContext);
+    return execHooksErrorHandling(hooks, pageContext, preparePageContextForPublicUsage);
+}
+async function execHooksErrorHandling(hooks, pageContext, preparePageContextForPublicUsage) {
+    if (!hooks.length)
+        return { hooks: [] };
+    const pageContextForPublicUsage = preparePageContextForPublicUsage(pageContext);
+    let hooksWithResult;
+    let err;
+    try {
+        hooksWithResult = await Promise.all(hooks.map(async (hook) => {
+            const hookReturn = await execHookAsync(() => hook.hookFn(pageContextForPublicUsage), hook, pageContextForPublicUsage);
+            return { ...hook, hookReturn };
+        }));
+    }
+    catch (err_) {
+        err = err_;
+    }
+    if (hooksWithResult) {
+        return { hooks: hooksWithResult };
+    }
+    else {
+        return { hooks, err };
+    }
+}
+async function execHookGlobal(hookName, pageConfigGlobal, pageContext, hookArg, prepareForPublicUsage) {
+    const hooks = getHookFromPageConfigGlobalCumulative(pageConfigGlobal, hookName);
+    const hookArgForPublicUsage = prepareForPublicUsage(hookArg);
+    await Promise.all(hooks.map(async (hook) => {
+        await execHookAsync(() => hook.hookFn(hookArgForPublicUsage), hook, pageContext);
+    }));
+}
+function isUserHookError(err) {
+    if (!isObject(err))
+        return false;
+    return globalObject.userHookErrors.get(err) ?? false;
+}
+async function execHookWithoutPageContext(hookFnCaller, hook) {
+    const { hookName, hookFilePath, hookTimeout } = hook;
+    const hookReturn = await execHookAsync(hookFnCaller, { hookName, hookFilePath, hookTimeout }, null);
+    return hookReturn;
+}
+function execHookAsync(hookFnCaller, hook, pageContextForPublicUsage) {
+    const { hookName, hookFilePath, hookTimeout: { error: timeoutErr, warning: timeoutWarn } } = hook;
+    let resolve;
+    let reject;
+    const promise = new Promise((resolve_, reject_) => {
+        resolve = (ret) => {
+            clearTimeouts();
+            resolve_(ret);
+        };
+        reject = (err) => {
+            clearTimeouts();
+            reject_(err);
+        };
+    });
+    const clearTimeouts = () => {
+        if (currentTimeoutWarn)
+            clearTimeout(currentTimeoutWarn);
+        if (currentTimeoutErr)
+            clearTimeout(currentTimeoutErr);
+    };
+    const currentTimeoutWarn = isNotDisabled(timeoutWarn) &&
+        setTimeout(() => {
+            assertWarning(false, `The ${hookName}() hook defined by ${hookFilePath} is slow: it's taking more than ${humanizeTime(timeoutWarn)} (https://vike.dev/hooksTimeout)`, { onlyOnce: false });
+        }, timeoutWarn);
+    const currentTimeoutErr = isNotDisabled(timeoutErr) &&
+        setTimeout(() => {
+            const err = getProjectError(`The ${hookName}() hook defined by ${hookFilePath} timed out: it didn't finish after ${humanizeTime(timeoutErr)} (https://vike.dev/hooksTimeout)`);
+            reject(err);
+        }, timeoutErr);
+    (async () => {
+        try {
+            providePageContext(pageContextForPublicUsage);
+            const ret = await hookFnCaller();
+            resolve(ret);
+        }
+        catch (err) {
+            if (isObject(err)) {
+                globalObject.userHookErrors.set(err, { hookName, hookFilePath });
+            }
+            reject(err);
+        }
+    })();
+    return promise;
+}
+function execHookSync(hook, pageContext, preparePageContextForPublicUsage) {
+    const pageContextForPublicUsage = preparePageContextForPublicUsage(pageContext);
+    providePageContext(pageContextForPublicUsage);
+    const hookReturn = hook.hookFn(pageContextForPublicUsage);
+    return { hookReturn };
+}
+function isNotDisabled(timeout) {
+    return !!timeout && timeout !== Infinity;
+}
+/**
+ * Access `pageContext` object inside Vike hooks, in order to create universal hooks.
+ *
+ * https://vike.dev/getPageContext
+ */
+function getPageContext() {
+    const { pageContext } = globalObject;
+    if (!pageContext)
+        return pageContext;
+    const pageContextForPublicUsage = preparePageContextForPublicUsage(pageContext);
+    return pageContextForPublicUsage;
+}
+/**
+ * Provide `pageContext` for universal hooks.
+ *
+ * https://vike.dev/getPageContext
+ */
+function providePageContext(pageContext) {
+    globalObject.pageContext = pageContext;
+    // Promise.resolve() is quicker than process.nextTick() and setImmediate()
+    // https://stackoverflow.com/questions/67949576/process-nexttick-before-promise-resolve-then
+    Promise.resolve().then(() => {
+        globalObject.pageContext = null;
+    });
+}

package/dist/esm/shared/hooks/getHook.d.ts

@@ -12,6 +12,8 @@ export { getHookTimeoutDefault };
 import type { PageConfigUserFriendlyOld } from '../getPageFiles.js';
 import type { HookNameOld, HookNamePage, HookNameGlobal, HookName } from '../page-configs/Config.js';
 import type { PageConfigGlobalRuntime, PageConfigRuntime } from '../page-configs/PageConfig.js';
+import type { GlobalContextPrepareMinimum } from '../prepareGlobalContextForPublicUsage.js';
+import type { PageContextPrepareMinimum } from '../preparePageContextForPublicUsage.js';
 type Hook = HookLoc & {
     hookFn: HookFn;
     hookTimeout: HookTimeout;
@@ -20,7 +22,7 @@ type HookLoc = {
     hookName: HookNameOld;
     hookFilePath: string;
 };
-type HookFn = (arg: object) => unknown;
+type HookFn = (arg: PageContextPrepareMinimum | GlobalContextPrepareMinimum) => unknown;
 type HookTimeout = {
     error: number | false;
     warning: number | false;

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

@@ -46,8 +46,8 @@ import type { GlobalContext, PageContextClient, PageContextServer } from '../typ
 import type { InlineConfig } from 'vite';
 type HookNameOld = HookName | HookNameOldDesign;
 type HookName = HookNamePage | HookNameGlobal;
-type HookNamePage = 'onHydrationEnd' | 'onBeforePrerenderStart' | 'onBeforeRender' | 'onPageTransitionStart' | 'onPageTransitionEnd' | 'onRenderHtml' | 'onRenderClient' | 'guard' | 'data' | 'onData';
-type HookNameGlobal = 'onBeforePrerender' | 'onBeforeRoute' | 'onPrerenderStart' | 'onCreatePageContext' | 'onCreateGlobalContext';
+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';
@@ -347,7 +347,7 @@ type ConfigBuiltIn = {
      *  https://vike.dev/data
      */
     data?: DataAsync<unknown> | DataSync<unknown> | ImportString | null;
-    /** TODO/now
+    /** Hook called as soon as `pageContext.data` is available.
      *
      *  https://vike.dev/onData
      */

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

@@ -4,7 +4,7 @@ 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 getUserFriendlyConfigsPageEager(pageConfigGlobalValues, pageConfig, pageConfigValues) {
     const pageConfigUserFriendly = getUserFriendlyConfigs_public({ pageConfigGlobalValues, pageConfigValues });
@@ -92,7 +92,7 @@ pageConfigGlobal) {
             configsComputed: {}
         };
     }
-    const pageExports = createObjectWithDeprecationWarning();
+    const pageExports = {};
     const exports = {};
     Object.entries(exportsAll).forEach(([exportName, values]) => {
         values.forEach(({ exportValue, _fileType, _isFromDefaultExport }) => {
@@ -115,9 +115,23 @@ pageConfigGlobal) {
         // 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
@@ -244,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,13 @@
+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 & {
+    globalContext: GlobalContextPrepareMinimum;
+};
+declare function assertPropertyGetters(pageContext: Record<string, unknown>): void;

package/dist/esm/shared/preparePageContextForPublicUsage.js

@@ -0,0 +1,73 @@
+export { preparePageContextForPublicUsage };
+export { assertPropertyGetters };
+import { assert, assertWarning, compareString, isPropertyGetter, objectAssign } from './utils.js';
+import { addIs404ToPageProps } from './addIs404ToPageProps.js';
+import { prepareGlobalContextForPublicUsage } from './prepareGlobalContextForPublicUsage.js';
+import { getProxyForPublicUsage } from './getProxyForPublicUsage.js';
+function preparePageContextForPublicUsage(pageContext) {
+    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
+    const globalContextPublic = prepareGlobalContextForPublicUsage(pageContext._globalContext);
+    objectAssign(pageContext, {
+        globalContext: globalContextPublic
+    });
+    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 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, pageContext.globalContext);
+    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/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,

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

@@ -7,7 +7,10 @@ export type { GlobalContextClient };
 export type { PageContextWithServerRouting };
 export type { PageContextClientWithServerRouting };
 export type { GlobalContextClientWithServerRouting };
-export type { PageContextBuiltInServerInternal };
+export type { PageContextInternalServer };
+export type { PageContextInternalClient };
+export type { PageContextInternalClient_ServerRouting };
+export type { PageContextInternalClient_ClientRouting };
 export type { PageContextBuiltInServer_deprecated as PageContextBuiltInServer };
 export type { PageContextBuiltInClientWithClientRouting_deprecated as PageContextBuiltInClientWithClientRouting };
 export type { PageContextBuiltInClientWithServerRouting_deprecated as PageContextBuiltInClientWithServerRouting };
@@ -235,8 +238,15 @@ type PageContextClientCommon = {
      */
     isPrerendering: false;
 };
-/** For Vike internal use */
-type PageContextBuiltInServerInternal = Omit<PageContextBuiltInCommon<unknown> & PageContextUrlInternal, 'data'>;
+type PageContextInternalServer = Omit<PageContextBuiltInCommon<unknown> & PageContextUrlInternal, 'data' | 'globalContext'>;
+type OnlyUsers = 'data' | 'Page' | 'globalContext';
+type PageContextInternalClient = Omit<PageContextInternalClient_ClientRouting | PageContextInternalClient_ServerRouting, OnlyUsers>;
+type PageContextInternalClient_ClientRouting = Omit<PageContextBuiltInClientWithClientRouting<unknown>, OnlyUsers | 'previousPageContext'> & {
+    previousPageContext: {
+        pageId: string;
+    } | null;
+};
+type PageContextInternalClient_ServerRouting = Omit<PageContextBuiltInClientWithServerRouting<unknown>, OnlyUsers>;
 /** @deprecated
  * Replace:
  *   ```

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

@@ -23,3 +23,4 @@ export * from '../utils/changeEnumerable.js';
 export * from '../utils/objectDefineProperty.js';
 export * from '../utils/isScriptFile.js';
 export * from '../utils/objectFilter.js';
+export * from '../utils/getPropAccessNotation.js';

package/dist/esm/shared/utils.js

@@ -27,3 +27,4 @@ export * from '../utils/changeEnumerable.js';
 export * from '../utils/objectDefineProperty.js';
 export * from '../utils/isScriptFile.js';
 export * from '../utils/objectFilter.js';
+export * from '../utils/getPropAccessNotation.js';

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

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.229-commit-7056ef0";
+export declare const PROJECT_VERSION: "0.4.229-commit-e27d672";

package/dist/esm/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.229-commit-7056ef0';
+export const PROJECT_VERSION = '0.4.229-commit-e27d672';