vike 0.4.147-commit-f9a91f3 → 0.4.148-commit-7596dcd

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

@@ -12,8 +12,8 @@ function isUserHookError(err) {
         return false;
     return globalObject.userHookErrors.get(err) ?? false;
 }
-function executeHook(hookFn, hookName, hookFilePath) {
-    const { timeoutErr, timeoutWarn } = getTimeouts(hookName);
+function executeHook(hookFnCaller, hook) {
+    const { hookName, hookFilePath, hookTimeout: { error: timeoutErr, warning: timeoutWarn } } = hook;
     let resolve;
     let reject;
     const promise = new Promise((resolve_, reject_) => {
@@ -27,19 +27,23 @@ function executeHook(hookFn, hookName, hookFilePath) {
         };
     });
     const clearTimeouts = () => {
-        clearTimeout(t1);
-        clearTimeout(t2);
+        if (currentTimeoutWarn)
+            clearTimeout(currentTimeoutWarn);
+        if (currentTimeoutErr)
+            clearTimeout(currentTimeoutErr);
     };
-    const t1 = setTimeout(() => {
-        assertWarning(false, `The ${hookName}() hook defined by ${hookFilePath} is taking more than ${humanizeTime(timeoutWarn)}`, { onlyOnce: false });
-    }, timeoutWarn);
-    const t2 = setTimeout(() => {
-        const err = getProjectError(`Hook timeout: the ${hookName}() hook defined by ${hookFilePath} didn't finish after ${humanizeTime(timeoutErr)}`);
-        reject(err);
-    }, timeoutErr);
+    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 {
-            const ret = await hookFn();
+            const ret = await hookFnCaller();
             resolve(ret);
         }
         catch (err) {
@@ -51,21 +55,6 @@ function executeHook(hookFn, hookName, hookFilePath) {
     })();
     return promise;
 }
-function getTimeouts(hookName) {
-    if (hookName === 'onBeforeRoute') {
-        return {
-            timeoutErr: 5 * 1000,
-            timeoutWarn: 1 * 1000
-        };
-    }
-    if (hookName === 'onBeforePrerender') {
-        return {
-            timeoutErr: 10 * 60 * 1000,
-            timeoutWarn: 30 * 1000
-        };
-    }
-    return {
-        timeoutErr: 40 * 1000,
-        timeoutWarn: 4 * 1000
-    };
+function isNotDisabled(timeout) {
+    return !!timeout && timeout !== Infinity;
 }

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

@@ -1,24 +1,34 @@
 export { getHook };
+export { getHookFromPageConfig };
+export { getHookFromPageConfigGlobal };
 export { assertHook };
-export { assertHookFn };
 export type { Hook };
 export type { HookName };
 export type { HookLoc };
-import { PageContextExports } from '../getPageFiles.js';
-import type { HookName } from '../page-configs/Config.js';
+export type { HookTimeout };
+export type { HooksTimeoutProvidedByUser };
+export { getHookTimeoutDefault };
+import type { PageContextExports } from '../getPageFiles.js';
+import type { HookName, HookNamePage, HookNameGlobal } from '../page-configs/Config.js';
+import type { PageConfigBuildTime, PageConfigGlobalRuntime, PageConfigRuntime } from '../page-configs/PageConfig.js';
 type Hook = HookLoc & {
     hookFn: HookFn;
+    hookTimeout: HookTimeout;
 };
 type HookLoc = {
     hookName: HookName;
     hookFilePath: string;
 };
 type HookFn = (arg: unknown) => unknown;
+type HookTimeout = {
+    error: number | false;
+    warning: number | false;
+};
+type HooksTimeoutProvidedByUser = false | Partial<Record<HookName, false | Partial<HookTimeout>>>;
 declare function getHook(pageContext: PageContextExports, hookName: HookName): null | Hook;
+declare function getHookFromPageConfig(pageConfig: PageConfigRuntime | PageConfigBuildTime, hookName: HookNamePage): null | Hook;
+declare function getHookFromPageConfigGlobal(pageConfigGlobal: PageConfigGlobalRuntime, hookName: HookNameGlobal): null | Hook;
 declare function assertHook<TPageContext extends PageContextExports, THookName extends PropertyKey & HookName>(pageContext: TPageContext, hookName: THookName): asserts pageContext is TPageContext & {
     exports: Record<THookName, Function | undefined>;
 };
-declare function assertHookFn(hookFn: unknown, { hookName, hookFilePath }: {
-    hookName: HookName;
-    hookFilePath: string;
-}): asserts hookFn is HookFn;
+declare function getHookTimeoutDefault(hookName: HookName): HookTimeout;

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

@@ -1,11 +1,19 @@
 export { getHook };
+export { getHookFromPageConfig };
+export { getHookFromPageConfigGlobal };
 export { assertHook };
-export { assertHookFn };
-import { assert, assertUsage, checkType, isCallable } from '../utils.js';
+// TODO/v1-release: remove
+// We export for old V0.4 design which doesn't support config.hooksTimeout
+export { getHookTimeoutDefault };
+import { getConfigValue, getHookFilePathToShowToUser } from '../page-configs/helpers.js';
+import { assert, assertUsage, checkType, isCallable, isObject } from '../utils.js';
+import pc from '@brillout/picocolors';
 function getHook(pageContext, hookName) {
     if (!(hookName in pageContext.exports)) {
         return null;
     }
+    const { hooksTimeout } = pageContext.config;
+    const hookTimeout = getHookTimeout(hooksTimeout, hookName);
     const hookFn = pageContext.exports[hookName];
     const file = pageContext.exportsAll[hookName][0];
     assert(file.exportValue === hookFn);
@@ -15,7 +23,37 @@ function getHook(pageContext, hookName) {
     assert(hookFilePath);
     assert(!hookFilePath.endsWith(' '));
     assertHookFn(hookFn, { hookName, hookFilePath });
-    return { hookFn, hookName, hookFilePath };
+    return { hookFn, hookName, hookFilePath, hookTimeout };
+}
+function getHookFromPageConfig(pageConfig, hookName) {
+    const configValue = getConfigValue(pageConfig, hookName);
+    const hooksTimeout = getConfigValue(pageConfig, 'hooksTimeout')?.value;
+    if (!configValue)
+        return null;
+    const hookFn = configValue.value;
+    if (!hookFn)
+        return null;
+    const hookFilePath = getHookFilePathToShowToUser(configValue);
+    // hook isn't a computed nor a cumulative config => definedAt should always be defined
+    assert(hookFilePath);
+    assertHookFn(hookFn, { hookName, hookFilePath });
+    const hookTimeout = getHookTimeout(hooksTimeout, hookName);
+    return { hookFn, hookName, hookFilePath, hookTimeout };
+}
+function getHookFromPageConfigGlobal(pageConfigGlobal, hookName) {
+    const configValue = pageConfigGlobal.configValues[hookName];
+    if (!configValue)
+        return null;
+    const hookFn = configValue.value;
+    if (!hookFn)
+        return null;
+    const hookFilePath = getHookFilePathToShowToUser(configValue);
+    // hook isn't a computed nor a cumulative config => definedAt should always be defined
+    assert(hookFilePath);
+    assertHookFn(hookFn, { hookName, hookFilePath });
+    // We could use the global value of config.hooksTimeout but it requires some non-trivial refactoring
+    const hookTimeout = getHookTimeoutDefault(hookName);
+    return { hookFn, hookName, hookFilePath, hookTimeout };
 }
 function assertHook(pageContext, hookName) {
     getHook(pageContext, hookName);
@@ -26,3 +64,65 @@ function assertHookFn(hookFn, { hookName, hookFilePath }) {
     assertUsage(isCallable(hookFn), `Hook ${hookName}() defined by ${hookFilePath} should be a function`);
     checkType(hookFn);
 }
+function getHookTimeout(hooksTimeoutProvidedByUser, hookName) {
+    const hooksTimeoutProvidedbyUserNormalized = getHooksTimeoutProvidedByUserNormalized(hooksTimeoutProvidedByUser);
+    if (hooksTimeoutProvidedbyUserNormalized === false)
+        return { error: false, warning: false };
+    const providedbyUser = hooksTimeoutProvidedbyUserNormalized[hookName];
+    const hookTimeout = getHookTimeoutDefault(hookName);
+    if (providedbyUser?.error !== undefined)
+        hookTimeout.error = providedbyUser.error;
+    if (providedbyUser?.warning !== undefined)
+        hookTimeout.warning = providedbyUser.warning;
+    return hookTimeout;
+}
+// Ideally this should be called only once and at build-time (to avoid bloating the client-side bundle), but we didn't implement any mechanism to valide config values at build-time yet
+function getHooksTimeoutProvidedByUserNormalized(hooksTimeoutProvidedByUser) {
+    if (hooksTimeoutProvidedByUser === undefined)
+        return {};
+    if (hooksTimeoutProvidedByUser === false)
+        return false;
+    assertUsage(isObject(hooksTimeoutProvidedByUser), `Setting ${pc.cyan('hooksTimeout')} should be ${pc.cyan('false')} or an object`);
+    const hooksTimeoutProvidedByUserNormalized = {};
+    Object.entries(hooksTimeoutProvidedByUser).forEach(([hookName, hookTimeoutProvidedbyUser]) => {
+        if (hookTimeoutProvidedbyUser === false) {
+            hooksTimeoutProvidedByUserNormalized[hookName] = { error: false, warning: false };
+            return;
+        }
+        assertUsage(isObject(hookTimeoutProvidedbyUser), `Setting ${pc.cyan(`hooksTimeout.${hookName}`)} should be ${pc.cyan('false')} or an object`);
+        const [error, warning] = ['error', 'warning'].map((timeoutName) => {
+            const timeoutVal = hookTimeoutProvidedbyUser[timeoutName];
+            if (timeoutVal === undefined || timeoutVal === false)
+                return timeoutVal;
+            const errPrefix = `Setting ${pc.cyan(`hooksTimeout.${hookName}.${timeoutName}`)} should be`;
+            assertUsage(typeof timeoutVal === 'number', `${errPrefix} ${pc.cyan('false')} or a number`);
+            assertUsage(timeoutVal > 0, `${errPrefix} a positive number`);
+            return timeoutVal;
+        });
+        hooksTimeoutProvidedByUserNormalized[hookName] = { error, warning };
+    });
+    return hooksTimeoutProvidedByUserNormalized;
+}
+function getHookTimeoutDefault(hookName) {
+    if (hookName === 'onBeforeRoute') {
+        return {
+            error: 5 * 1000,
+            warning: 1 * 1000
+        };
+    }
+    if (hookName === 'onPrerenderStart' ||
+        hookName === 'onBeforePrerenderStart' ||
+        // TODO/v1-release: remove
+        // Old V0.4 design hooks (https://vike.dev/migration/v1-design#renamed-hooks)
+        hookName === 'onBeforePrerender' ||
+        hookName === 'prerender') {
+        return {
+            error: 10 * 60 * 1000,
+            warning: 30 * 1000
+        };
+    }
+    return {
+        error: 30 * 1000,
+        warning: 4 * 1000
+    };
+}

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

@@ -3,6 +3,8 @@ export type { ConfigBuiltIn };
 export type { ConfigNameBuiltIn };
 export type { ConfigMeta };
 export type { HookName };
+export type { HookNamePage };
+export type { HookNameGlobal };
 export type { GuardAsync };
 export type { GuardSync };
 export type { OnBeforePrerenderStartAsync };
@@ -30,9 +32,13 @@ import type { ConfigDefinition } from '../../node/plugin/plugins/importUserCode/
 import type { DocumentHtml } from '../../node/runtime/html/renderHtml.js';
 import type { ConfigVikeUserProvided } from '../ConfigVike.js';
 import type { Vike, VikePackages } from '../VikeNamespace.js';
+import type { HooksTimeoutProvidedByUser } from '../hooks/getHook.js';
 import type { PageContextClient, PageContextServer } from '../types.js';
-type HookName = 'onHydrationEnd' | 'onBeforePrerender' | 'onBeforePrerenderStart' | 'onBeforeRender' | 'onBeforeRoute' | 'onPageTransitionStart' | 'onPageTransitionEnd' | 'onPrerenderStart' | 'onRenderHtml' | 'onRenderClient' | 'guard' | 'render';
-type ConfigNameBuiltIn = Exclude<keyof Config, keyof ConfigVikeUserProvided | 'onBeforeRoute' | 'onPrerenderStart'> | 'prerender' | 'isClientSideRenderable' | 'onBeforeRenderEnv';
+type HookName = HookNamePage | HookNameGlobal | HookNameOldDesign;
+type HookNamePage = 'onHydrationEnd' | 'onBeforePrerenderStart' | 'onBeforeRender' | 'onPageTransitionStart' | 'onPageTransitionEnd' | 'onRenderHtml' | 'onRenderClient' | 'guard';
+type HookNameGlobal = 'onBeforePrerender' | 'onBeforeRoute' | 'onPrerenderStart';
+type HookNameOldDesign = 'render' | 'prerender';
+type ConfigNameBuiltIn = Exclude<keyof Config, keyof ConfigVikeUserProvided | 'onBeforeRoute' | 'onPrerenderStart'> | 'prerender' | 'isClientSideRenderable' | 'onBeforeRenderEnv' | 'hooksTimeout';
 type Config = ConfigBuiltIn & Vike.Config & (VikePackages.ConfigVikeReact | VikePackages.ConfigVikeVue | VikePackages.ConfigVikeSolid | VikePackages.ConfigVikeSvelte);
 /** Protect page(s), e.g. forbid unauthorized access.
  *
@@ -102,32 +108,32 @@ type OnBeforeRouteSync = (pageContext: PageContextServer) => {
 };
 /** Hook called after the page is hydrated.
  *
- * https://vike.dev/clientRouting
+ * https://vike.dev/onHydrationEnd
  */
 type OnHydrationEndAsync = (pageContext: PageContextClient) => Promise<void>;
 /** Hook called after the page is hydrated.
  *
- * https://vike.dev/clientRouting
+ * https://vike.dev/onHydrationEnd
  */
 type OnHydrationEndSync = (pageContext: PageContextClient) => void;
 /** Hook called after the user navigates to a new page.
  *
- * https://vike.dev/clientRouting
+ * https://vike.dev/onPageTransitionEnd
  */
 type OnPageTransitionEndAsync = (pageContext: PageContextClient) => Promise<void>;
 /** Hook called after the user navigates to a new page.
  *
- * https://vike.dev/clientRouting
+ * https://vike.dev/onPageTransitionEnd
  */
 type OnPageTransitionEndSync = (pageContext: PageContextClient) => void;
 /** Hook called before the user navigates to a new page.
  *
- * https://vike.dev/clientRouting
+ * https://vike.dev/onPageTransitionStart
  */
 type OnPageTransitionStartAsync = (pageContext: PageContextClient) => Promise<void>;
 /** Hook called before the user navigates to a new page.
  *
- * https://vike.dev/clientRouting
+ * https://vike.dev/onPageTransitionStart
  */
 type OnPageTransitionStartSync = (pageContext: PageContextClient) => void;
 /** Page Hook called when pre-rendering starts.
@@ -275,22 +281,22 @@ type ConfigBuiltIn = {
     onBeforeRoute?: OnBeforeRouteAsync | OnBeforeRouteSync | ImportString;
     /** Hook called after the page is hydrated.
      *
-     * https://vike.dev/clientRouting
+     * https://vike.dev/onHydrationEnd
      */
     onHydrationEnd?: OnHydrationEndAsync | OnHydrationEndSync | ImportString;
     /** Hook called before the user navigates to a new page.
      *
-     * https://vike.dev/clientRouting
+     * https://vike.dev/onPageTransitionStart
      */
     onPageTransitionStart?: OnPageTransitionStartAsync | OnPageTransitionStartSync | ImportString;
     /** Hook called after the user navigates to a new page.
      *
-     * https://vike.dev/clientRouting
+     * https://vike.dev/onPageTransitionEnd
      */
     onPageTransitionEnd?: OnPageTransitionEndAsync | OnPageTransitionEndSync | ImportString;
     /** Whether the UI framework (React/Vue/Solid/...) allows the page's hydration to be aborted.
      *
-     * https://vike.dev/clientRouting
+     * https://vike.dev/hydrationCanBeAborted
      */
     hydrationCanBeAborted?: boolean | ImportString;
     /** Additional client code.
@@ -310,9 +316,11 @@ type ConfigBuiltIn = {
     meta?: ConfigMeta | ImportString;
     /** Prefetch links.
      *
-     * https://vike.dev/clientRouting#link-prefetching
+     * https://vike.dev/prefetchStaticAssets
      */
     prefetchStaticAssets?: PrefetchStaticAssets | ImportString;
+    /** Modify the tiemouts of hooks. */
+    hooksTimeout?: HooksTimeoutProvidedByUser;
 };
 type ConfigMeta = Record<string, ConfigDefinition>;
 type ImportString = `import:${string}`;

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

@@ -1,7 +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 }: {
+declare function getConfigDefinedAtString<ConfigName extends string, SentenceBegin extends 'Config' | 'config'>(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

@@ -6,7 +6,7 @@ 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' ? '()' : ''}`;
+    let configNameStr = `${configName}${ /*sentenceBegin === 'Hook' ? '()' :*/''}`;
     const configDefinedAt = `${sentenceBegin} ${pc.cyan(configNameStr)} defined ${definedAtStr}`;
     return configDefinedAt;
 }

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

@@ -1,5 +1,5 @@
 export { executeGuardHook };
-import { getHook } from '../hooks/getHook.js';
+import { getHook, getHookTimeoutDefault } from '../hooks/getHook.js';
 import { assert, assertUsage, executeHook, isCallable } from './utils.js';
 async function executeGuardHook(pageContext, prepareForUserConsumption) {
     let hook;
@@ -19,7 +19,7 @@ async function executeGuardHook(pageContext, prepareForUserConsumption) {
     const res = prepareForUserConsumption(pageContext);
     if (res)
         pageContextForUserConsumption = res;
-    const hookResult = await executeHook(() => guard(pageContextForUserConsumption), 'guard', hook.hookFilePath);
+    const hookResult = await executeHook(() => guard(pageContextForUserConsumption), hook);
     assertUsage(hookResult === undefined, `The guard() hook of ${hook.hookFilePath} returns a value, but guard() doesn't accept any return value`);
 }
 function findPageGuard(pageId, pageFilesAll) {
@@ -32,6 +32,7 @@ function findPageGuard(pageId, pageFilesAll) {
     if (!hookFn)
         return null;
     const hookFilePath = filePath;
+    const hookTimeout = getHookTimeoutDefault('guard');
     assertUsage(isCallable(hookFn), `guard() defined by ${hookFilePath} should be a function`);
-    return { hookFn, hookName: 'guard', hookFilePath };
+    return { hookFn, hookName: 'guard', hookFilePath, hookTimeout };
 }

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

@@ -1,12 +1,5 @@
-import type { PageContextForRoute, PageContextFromRoute } from './index.js';
 export { executeOnBeforeRouteHook };
-export type { OnBeforeRouteHook };
-type OnBeforeRouteHook = {
-    hookFilePath: string;
-    onBeforeRoute: (pageContext: {
-        urlOriginal: string;
-    } & Record<string, unknown>) => unknown;
-};
+import type { PageContextForRoute, PageContextFromRoute } from './index.js';
 declare function executeOnBeforeRouteHook(pageContext: PageContextForRoute): Promise<null | ({
     _routingProvidedByOnBeforeRouteHook: true;
 } & PageContextFromRoute) | {

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

@@ -1,13 +1,13 @@
+export { executeOnBeforeRouteHook };
 import { assertPageContextProvidedByUser } from '../assertPageContextProvidedByUser.js';
-import { assertUsage, hasProp, isObjectWithKeys, objectAssign, assertWarning, assertUsageUrl, joinEnglish, assert } from './utils.js';
+import { assertUsage, hasProp, isObjectWithKeys, objectAssign, assertWarning, assertUsageUrl, joinEnglish, assert, executeHook } from './utils.js';
 import { assertRouteParams, assertSyncRouting } from './resolveRouteFunction.js';
 import pc from '@brillout/picocolors';
-export { executeOnBeforeRouteHook };
 async function executeOnBeforeRouteHook(pageContext) {
     const pageContextFromOnBeforeRouteHook = {};
     if (!pageContext._onBeforeRouteHook)
         return null;
-    const pageContextFromHook = await executeHook(pageContext._onBeforeRouteHook, pageContext);
+    const pageContextFromHook = await getPageContextFromHook(pageContext._onBeforeRouteHook, pageContext);
     if (pageContextFromHook) {
         objectAssign(pageContextFromOnBeforeRouteHook, pageContextFromHook);
         if (hasProp(pageContextFromOnBeforeRouteHook, '_pageId', 'string') ||
@@ -31,11 +31,11 @@ async function executeOnBeforeRouteHook(pageContext) {
     });
     return pageContextFromOnBeforeRouteHook;
 }
-async function executeHook(onBeforeRouteHook, pageContext) {
-    let hookReturn = onBeforeRouteHook.onBeforeRoute(pageContext);
+async function getPageContextFromHook(onBeforeRouteHook, pageContext) {
+    let hookReturn = onBeforeRouteHook.hookFn(pageContext);
     assertSyncRouting(hookReturn, `The onBeforeRoute() hook ${onBeforeRouteHook.hookFilePath}`);
     // TODO/v1-release: make executeOnBeforeRouteHook() and route() sync
-    hookReturn = await hookReturn;
+    hookReturn = await executeHook(() => hookReturn, onBeforeRouteHook);
     const errPrefix = `The onBeforeRoute() hook defined by ${onBeforeRouteHook.hookFilePath}`;
     assertUsage(hookReturn === null ||
         hookReturn === undefined ||

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

@@ -5,16 +5,16 @@ export type { PageRoutes };
 export type { RouteMatches };
 import type { PageFile } from '../getPageFiles.js';
 import { PageContextUrlComputedPropsInternal, PageContextUrlSources } from '../addUrlComputedProps.js';
-import { type OnBeforeRouteHook } from './executeOnBeforeRouteHook.js';
 import type { PageRoutes, RouteType } from './loadPageRoutes.js';
 import type { PageConfigRuntime, PageConfigGlobalRuntime } from '../page-configs/PageConfig.js';
+import type { Hook } from '../hooks/getHook.js';
 type PageContextForRoute = PageContextUrlComputedPropsInternal & {
     _pageFilesAll: PageFile[];
     _pageConfigs: PageConfigRuntime[];
     _allPageIds: string[];
     _pageConfigGlobal: PageConfigGlobalRuntime;
     _pageRoutes: PageRoutes;
-    _onBeforeRouteHook: OnBeforeRouteHook | null;
+    _onBeforeRouteHook: Hook | null;
 } & PageContextUrlSources;
 type PageContextFromRoute = {
     _pageId: string | null;

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

@@ -2,8 +2,8 @@ export { loadPageRoutes };
 export type { PageRoutes };
 export type { RouteType };
 import type { PageFile } from '../getPageFiles.js';
-import type { OnBeforeRouteHook } from './executeOnBeforeRouteHook.js';
 import type { PageConfigRuntime, PageConfigGlobalRuntime } from '../page-configs/PageConfig.js';
+import { type Hook } from '../hooks/getHook.js';
 type PageRoute = {
     pageId: string;
     comesFromV1PageConfig: boolean;
@@ -25,5 +25,5 @@ type PageRoutes = PageRoute[];
 type RouteType = 'STRING' | 'FUNCTION' | 'FILESYSTEM';
 declare function loadPageRoutes(pageFilesAll: PageFile[], pageConfigs: PageConfigRuntime[], pageConfigGlobal: PageConfigGlobalRuntime, allPageIds: string[]): Promise<{
     pageRoutes: PageRoutes;
-    onBeforeRouteHook: null | OnBeforeRouteHook;
+    onBeforeRouteHook: null | Hook;
 }>;

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

@@ -3,8 +3,9 @@ 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 { getConfigDefinedAtString, getConfigValue, getDefinedAtString, getHookFilePathToShowToUser } from '../page-configs/helpers.js';
+import { getConfigValue, getDefinedAtString } from '../page-configs/helpers.js';
 import { warnDeprecatedAllowKey } from './resolveRouteFunction.js';
+import { getHookFromPageConfigGlobal, getHookTimeoutDefault } from '../hooks/getHook.js';
 async function loadPageRoutes(
 // Remove all arguments and use GlobalContext instead?
 pageFilesAll, pageConfigs, pageConfigGlobal, allPageIds) {
@@ -136,20 +137,8 @@ function getPageRoutes(filesystemRoots, pageFilesAll, pageConfigs, allPageIds) {
 function getGlobalHooks(pageFilesAll, pageConfigs, pageConfigGlobal) {
     // V1 Design
     if (pageConfigs.length > 0) {
-        const hookName = 'onBeforeRoute';
-        if (pageConfigGlobal.configValues[hookName]?.value) {
-            const configValue = pageConfigGlobal.configValues[hookName];
-            const { value: hookFn } = configValue;
-            const hookFilePath = getHookFilePathToShowToUser(configValue);
-            const hookDefinedAt = getConfigDefinedAtString('Hook', hookName, configValue);
-            assertUsage(isCallable(hookFn), `${hookDefinedAt} should be a function.`);
-            const onBeforeRouteHook = {
-                hookFilePath: hookFilePath,
-                onBeforeRoute: hookFn
-            };
-            return { onBeforeRouteHook, filesystemRoots: null };
-        }
-        return { onBeforeRouteHook: null, filesystemRoots: null };
+        const hook = getHookFromPageConfigGlobal(pageConfigGlobal, 'onBeforeRoute');
+        return { onBeforeRouteHook: hook, filesystemRoots: null };
     }
     // Old design
     // TODO/v1-release: remove
@@ -162,7 +151,13 @@ function getGlobalHooks(pageFilesAll, pageConfigs, pageConfigGlobal) {
         if ('onBeforeRoute' in fileExports) {
             assertUsage(hasProp(fileExports, 'onBeforeRoute', 'function'), `\`export { onBeforeRoute }\` of ${filePath} should be a function.`);
             const { onBeforeRoute } = fileExports;
-            onBeforeRouteHook = { hookFilePath: `${filePath} > \`export { onBeforeRoute }\``, onBeforeRoute };
+            const hookName = 'onBeforeRoute';
+            onBeforeRouteHook = {
+                hookFilePath: filePath,
+                hookFn: onBeforeRoute,
+                hookName,
+                hookTimeout: getHookTimeoutDefault(hookName)
+            };
         }
         if ('filesystemRoutingRoot' in fileExports) {
             assertUsage(hasProp(fileExports, 'filesystemRoutingRoot', 'string'), `\`export { filesystemRoutingRoot }\` of ${filePath} should be a string.`);

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

@@ -1,13 +1,13 @@
 export { projectInfo };
 export type { ProjectTag };
 export { PROJECT_VERSION };
-declare const PROJECT_VERSION: "0.4.147-commit-f9a91f3";
+declare const PROJECT_VERSION: "0.4.148-commit-7596dcd";
 type PackageName = typeof projectInfo.npmPackageName;
 type ProjectVersion = typeof projectInfo.projectVersion;
 type ProjectTag = `[${PackageName}]` | `[${PackageName}@${ProjectVersion}]`;
 declare const projectInfo: {
     projectName: "Vike";
-    projectVersion: "0.4.147-commit-f9a91f3";
+    projectVersion: "0.4.148-commit-7596dcd";
     npmPackageName: "vike";
     githubRepository: "https://github.com/vikejs/vike";
 };

package/dist/esm/utils/projectInfo.js

@@ -1,7 +1,7 @@
 export { projectInfo };
 export { PROJECT_VERSION };
 import { onProjectInfo } from './assertSingleInstance.js';
-const PROJECT_VERSION = '0.4.147-commit-f9a91f3';
+const PROJECT_VERSION = '0.4.148-commit-7596dcd';
 const projectInfo = {
     projectName: 'Vike',
     projectVersion: PROJECT_VERSION,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.147-commit-f9a91f3",
+  "version": "0.4.148-commit-7596dcd",
   "scripts": {
     "dev": "tsc --watch",
     "build": "rimraf dist/ && pnpm run build:esm && pnpm run build:cjs",