vike 0.4.147 → 0.4.148-commit-7596dcd

package/dist/esm/node/runtime/renderPage/renderPageAlreadyRouted.d.ts

@@ -12,7 +12,7 @@ import { HttpResponse } from './createHttpResponseObject.js';
 import { PageContext_loadPageFilesServerSide, type PageFiles } from './loadPageFilesServerSide.js';
 import type { PageConfigRuntime, PageConfigGlobalRuntime } from '../../../shared/page-configs/PageConfig.js';
 import { type PageRoutes } from '../../../shared/route/loadPageRoutes.js';
-import type { OnBeforeRouteHook } from '../../../shared/route/executeOnBeforeRouteHook.js';
+import type { Hook } from '../../../shared/hooks/getHook.js';
 type PageContextAfterRender = {
     httpResponse: null | HttpResponse;
     errorWhileRendering: null | Error;
@@ -46,7 +46,7 @@ declare function prerenderPage(pageContext: PageContextInitEnhanced & PageFiles
         _pageConfigGlobal: PageConfigGlobalRuntime;
         _allPageIds: string[];
         _pageRoutes: PageRoutes;
-        _onBeforeRouteHook: OnBeforeRouteHook | null;
+        _onBeforeRouteHook: Hook | null;
         _pageContextInit: {
             urlOriginal: string;
         };
@@ -93,7 +93,7 @@ declare function prerenderPage(pageContext: PageContextInitEnhanced & PageFiles
         _pageConfigGlobal: PageConfigGlobalRuntime;
         _allPageIds: string[];
         _pageRoutes: PageRoutes;
-        _onBeforeRouteHook: OnBeforeRouteHook | null;
+        _onBeforeRouteHook: Hook | null;
         _pageContextInit: {
             urlOriginal: string;
         };
@@ -141,7 +141,7 @@ declare function prerender404Page(renderContext: RenderContext, pageContextInit_
         _pageConfigGlobal: PageConfigGlobalRuntime;
         _allPageIds: string[];
         _pageRoutes: PageRoutes;
-        _onBeforeRouteHook: OnBeforeRouteHook | null;
+        _onBeforeRouteHook: Hook | null;
         _pageContextInit: {
             urlOriginal: string;
         };
@@ -188,7 +188,7 @@ declare function prerender404Page(renderContext: RenderContext, pageContextInit_
         _pageConfigGlobal: PageConfigGlobalRuntime;
         _allPageIds: string[];
         _pageRoutes: PageRoutes;
-        _onBeforeRouteHook: OnBeforeRouteHook | null;
+        _onBeforeRouteHook: Hook | null;
         _pageContextInit: {
             urlOriginal: string;
         };
@@ -243,7 +243,7 @@ declare function getPageContextInitEnhanced(pageContextInit: {
     _pageConfigGlobal: PageConfigGlobalRuntime;
     _allPageIds: string[];
     _pageRoutes: PageRoutes;
-    _onBeforeRouteHook: OnBeforeRouteHook | null;
+    _onBeforeRouteHook: Hook | null;
     _pageContextInit: {
         urlOriginal: string;
     };
@@ -260,6 +260,6 @@ type RenderContext = {
     pageConfigGlobal: PageConfigGlobalRuntime;
     allPageIds: string[];
     pageRoutes: PageRoutes;
-    onBeforeRouteHook: OnBeforeRouteHook | null;
+    onBeforeRouteHook: Hook | null;
 };
 declare function getRenderContext(): Promise<RenderContext>;

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

@@ -6,7 +6,7 @@ export { getRenderContext };
 import { getErrorPageId } from '../../../shared/error-page.js';
 import { getHtmlString } from '../html/renderHtml.js';
 import { getPageFilesAll } from '../../../shared/getPageFiles.js';
-import { assert, assertUsage, hasProp, isNotNullish, objectAssign, unique } from '../utils.js';
+import { assert, assertUsage, assertWarning, hasProp, isNotNullish, objectAssign, unique } from '../utils.js';
 import { serializePageContextClientSide } from '../html/serializePageContextClientSide.js';
 import { addUrlComputedProps } from '../../../shared/addUrlComputedProps.js';
 import { getGlobalContext } from '../globalContext.js';
@@ -150,7 +150,7 @@ async function getRenderContext() {
     const globalContext = getGlobalContext();
     const { pageFilesAll, allPageIds, pageConfigs, pageConfigGlobal } = await getPageFilesAll(false, globalContext.isProduction);
     const { pageRoutes, onBeforeRouteHook } = await loadPageRoutes(pageFilesAll, pageConfigs, pageConfigGlobal, allPageIds);
-    assertNonMixedDesign(pageFilesAll, pageConfigs);
+    assertV1Design(pageFilesAll, pageConfigs);
     const renderContext = {
         pageFilesAll: pageFilesAll,
         pageConfigs,
@@ -161,21 +161,24 @@ async function getRenderContext() {
     };
     return renderContext;
 }
-function assertNonMixedDesign(pageFilesAll, pageConfigs) {
-    if (pageFilesAll.length === 0 || pageConfigs.length === 0)
-        return;
-    const indent = '- ';
-    const v1Files = unique(pageConfigs
-        .map((p) => Object.values(p.configValues)
-        .map(getConfigValueFilePathToShowToUser)
-        .filter(isNotNullish)
-        .map((filePathToShowToUser) => indent + filePathToShowToUser))
-        .flat(2));
-    assertUsage(false, [
-        'Mixing the new V1 design with the old V0.4 design is forbidden.',
-        'V1 files:',
-        ...v1Files,
-        'V0.4 files:',
-        ...pageFilesAll.map((p) => indent + p.filePath)
-    ].join('\n'));
+function assertV1Design(pageFilesAll, pageConfigs) {
+    const isV1Design = pageConfigs.length !== 0;
+    const isDesignOld = pageFilesAll.length !== 0;
+    if (isV1Design && isDesignOld) {
+        const indent = '- ';
+        const v1Files = unique(pageConfigs
+            .map((p) => Object.values(p.configValues)
+            .map(getConfigValueFilePathToShowToUser)
+            .filter(isNotNullish)
+            .map((filePathToShowToUser) => indent + filePathToShowToUser))
+            .flat(2));
+        assertUsage(false, [
+            'Mixing the new V1 design with the old V0.4 design is forbidden.',
+            'V1 files:',
+            ...v1Files,
+            'V0.4 files:',
+            ...pageFilesAll.map((p) => indent + p.filePath)
+        ].join('\n'));
+    }
+    assertWarning(!isDesignOld, 'You are using the old deprecated design, update to the new V1 design, see https://vike.dev/migration/v1-design', { onlyOnce: true });
 }

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

@@ -2,7 +2,7 @@ export { renderPage };
 export { renderPage_addWrapper };
 import { getRenderContext, getPageContextInitEnhanced, renderPageAlreadyRouted } from './renderPage/renderPageAlreadyRouted.js';
 import { route } from '../../shared/route/index.js';
-import { assert, hasProp, objectAssign, isParsable, parseUrl, assertEnv, assertWarning, getGlobalObject, checkType, assertUsage, normalizeUrlPathname, removeBaseServer, modifyUrlPathname, prependBase, removeUrlOrigin, addUrlOrigin } from './utils.js';
+import { assert, hasProp, objectAssign, isParsable, parseUrl, assertEnv, assertWarning, getGlobalObject, checkType, assertUsage, normalizeUrlPathname, removeBaseServer, modifyUrlPathname, prependBase, removeUrlOrigin, addUrlOrigin, createUrlFromComponents } from './utils.js';
 import { assertNoInfiniteAbortLoop, getPageContextFromAllRewrites, isAbortError, logAbortErrorHandled } from '../../shared/route/abort.js';
 import { getGlobalContext, initGlobalContext } from './globalContext.js';
 import { handlePageContextRequestUrl } from './renderPage/handlePageContextRequestUrl.js';
@@ -34,17 +34,17 @@ async function renderPage(pageContextInit) {
     assertArguments(...arguments);
     assert(hasProp(pageContextInit, 'urlOriginal', 'string'));
     assertEnv();
-    if (skipRequest(pageContextInit.urlOriginal)) {
-        const pageContextHttpReponseNull = getPageContextHttpResponseNull(pageContextInit);
-        checkType(pageContextHttpReponseNull);
-        return pageContextHttpReponseNull;
+    if (isIgnoredUrl(pageContextInit.urlOriginal)) {
+        const pageContextHttpResponseNull = getPageContextHttpResponseNull(pageContextInit);
+        checkType(pageContextHttpResponseNull);
+        return pageContextHttpResponseNull;
     }
     const httpRequestId = getRequestId();
-    const urlToShowToUser = pageContextInit.urlOriginal;
-    logHttpRequest(urlToShowToUser, httpRequestId);
+    const { urlOriginal } = pageContextInit;
+    logHttpRequest(urlOriginal, httpRequestId);
     globalObject.pendingRequestsCount++;
     const { pageContextReturn, onRequestDone } = await renderPage_wrapper(httpRequestId, () => renderPageAndPrepare(pageContextInit, httpRequestId));
-    logHttpResponse(urlToShowToUser, httpRequestId, pageContextReturn);
+    logHttpResponse(urlOriginal, httpRequestId, pageContextReturn);
     globalObject.pendingRequestsCount--;
     onRequestDone();
     checkType(pageContextReturn);
@@ -54,8 +54,8 @@ async function renderPageAndPrepare(pageContextInit, httpRequestId) {
     // Invalid config
     const handleInvalidConfig = () => {
         logRuntimeInfo?.(pc.bold(pc.red("Couldn't load configuration: see error above.")), httpRequestId, 'error');
-        const pageContextHttpReponseNull = getPageContextHttpResponseNull(pageContextInit);
-        return pageContextHttpReponseNull;
+        const pageContextHttpResponseNull = getPageContextHttpResponseNull(pageContextInit);
+        return pageContextHttpResponseNull;
     };
     if (isConfigInvalid) {
         return handleInvalidConfig();
@@ -71,8 +71,8 @@ async function renderPageAndPrepare(pageContextInit, httpRequestId) {
         // initGlobalContext() and getRenderContext() don't call any user hooks => err isn't thrown from user code
         assert(!isAbortError(err));
         logRuntimeError(err, httpRequestId);
-        const pageContextHttpReponseNull = getPageContextHttpResponseNullWithError(err, pageContextInit);
-        return pageContextHttpReponseNull;
+        const pageContextHttpResponseNull = getPageContextHttpResponseNullWithError(err, pageContextInit);
+        return pageContextHttpResponseNull;
     }
     if (isConfigInvalid) {
         return handleInvalidConfig();
@@ -80,15 +80,23 @@ async function renderPageAndPrepare(pageContextInit, httpRequestId) {
     else {
         // From now on, renderContext.pageConfigs contains all the configuration data; getVikeConfig() isn't called anymore for this request
     }
+    // Check Base URL
+    {
+        const pageContextHttpResponse = checkBaseUrl(pageContextInit, httpRequestId);
+        if (pageContextHttpResponse)
+            return pageContextHttpResponse;
+    }
+    // Normalize URL
     {
-        const pageContextHttpReponse = normalizeUrl(pageContextInit, httpRequestId);
-        if (pageContextHttpReponse)
-            return pageContextHttpReponse;
+        const pageContextHttpResponse = normalizeUrl(pageContextInit, httpRequestId);
+        if (pageContextHttpResponse)
+            return pageContextHttpResponse;
     }
+    // Permanent redirects (HTTP status code `301`)
     {
-        const pageContextHttpReponse = getPermanentRedirect(pageContextInit, httpRequestId);
-        if (pageContextHttpReponse)
-            return pageContextHttpReponse;
+        const pageContextHttpResponse = getPermanentRedirect(pageContextInit, httpRequestId);
+        if (pageContextHttpResponse)
+            return pageContextHttpResponse;
     }
     return await renderPageAlreadyPrepared(pageContextInit, httpRequestId, renderContext, []);
 }
@@ -171,8 +179,8 @@ async function renderPageAlreadyPrepared(pageContextInit, httpRequestId, renderC
                 if (!handled.pageContextReturn) {
                     const pageContextAbort = errErrorPage._pageContextAbort;
                     assertWarning(false, `Failed to render error page because ${pc.cyan(pageContextAbort._abortCall)} was called: make sure ${pc.cyan(pageContextAbort._abortCaller)} doesn't occur while the error page is being rendered.`, { onlyOnce: false });
-                    const pageContextHttpReponseNull = getPageContextHttpResponseNullWithError(errNominalPage, pageContextInit);
-                    return pageContextHttpReponseNull;
+                    const pageContextHttpResponseNull = getPageContextHttpResponseNullWithError(errNominalPage, pageContextInit);
+                    return pageContextHttpResponseNull;
                 }
                 // `throw redirect()` / `throw render(url)`
                 return handled.pageContextReturn;
@@ -180,18 +188,28 @@ async function renderPageAlreadyPrepared(pageContextInit, httpRequestId, renderC
             if (isNewError(errErrorPage, errNominalPage)) {
                 logRuntimeError(errErrorPage, httpRequestId);
             }
-            const pageContextHttpReponseNull = getPageContextHttpResponseNullWithError(errNominalPage, pageContextInit);
-            return pageContextHttpReponseNull;
+            const pageContextHttpResponseNull = getPageContextHttpResponseNullWithError(errNominalPage, pageContextInit);
+            return pageContextHttpResponseNull;
         }
         return pageContextErrorPage;
     }
 }
-function logHttpRequest(urlToShowToUser, httpRequestId) {
+function logHttpRequest(urlOriginal, httpRequestId) {
     const clearErrors = globalObject.pendingRequestsCount === 0;
-    logRuntimeInfo?.(`HTTP request: ${pc.bold(urlToShowToUser)}`, httpRequestId, 'info', clearErrors);
+    logRuntimeInfo?.(getRequestInfoMessage(urlOriginal), httpRequestId, 'info', clearErrors);
 }
-function logHttpResponse(urlToShowToUser, httpRequestId, pageContextReturn) {
+function getRequestInfoMessage(urlOriginal) {
+    return `HTTP request: ${pc.bold(urlOriginal)}`;
+}
+function logHttpResponse(urlOriginal, httpRequestId, pageContextReturn) {
     const statusCode = pageContextReturn.httpResponse?.statusCode ?? null;
+    {
+        // If URL doesn't include Base URL
+        const { errorWhileRendering } = pageContextReturn;
+        const isSkipped = statusCode === null && (errorWhileRendering === null || errorWhileRendering === undefined);
+        if (isSkipped)
+            return;
+    }
     const isSuccess = statusCode !== null && statusCode >= 200 && statusCode <= 399;
     const isNominal = isSuccess || statusCode === 404;
     const color = (s) => pc.bold(isSuccess ? pc.green(String(s)) : pc.red(String(s)));
@@ -205,39 +223,30 @@ function logHttpResponse(urlToShowToUser, httpRequestId, pageContextReturn) {
             .find((header) => header[0] === 'Location');
         assert(headerRedirect);
         const urlRedirect = headerRedirect[1];
-        urlToShowToUser = urlRedirect;
+        urlOriginal = urlRedirect;
     }
-    logRuntimeInfo?.(`HTTP ${type} ${pc.bold(urlToShowToUser)} ${color(statusCode ?? 'ERR')}`, httpRequestId, isNominal ? 'info' : 'error');
+    logRuntimeInfo?.(`HTTP ${type} ${pc.bold(urlOriginal)} ${color(statusCode ?? 'ERR')}`, httpRequestId, isNominal ? 'info' : 'error');
 }
 function getPageContextHttpResponseNullWithError(err, pageContextInit) {
-    const pageContextHttpReponseNull = {};
-    objectAssign(pageContextHttpReponseNull, pageContextInit);
-    objectAssign(pageContextHttpReponseNull, {
+    const pageContextHttpResponseNull = {};
+    objectAssign(pageContextHttpResponseNull, pageContextInit);
+    objectAssign(pageContextHttpResponseNull, {
         httpResponse: null,
         errorWhileRendering: err
     });
-    return pageContextHttpReponseNull;
+    return pageContextHttpResponseNull;
 }
 function getPageContextHttpResponseNull(pageContextInit) {
-    const pageContextHttpReponseNull = {};
-    objectAssign(pageContextHttpReponseNull, pageContextInit);
-    objectAssign(pageContextHttpReponseNull, {
+    const pageContextHttpResponseNull = {};
+    objectAssign(pageContextHttpResponseNull, pageContextInit);
+    objectAssign(pageContextHttpResponseNull, {
         httpResponse: null,
         errorWhileRendering: null
     });
-    return pageContextHttpReponseNull;
+    return pageContextHttpResponseNull;
 }
 async function renderPageNominal(pageContext) {
     objectAssign(pageContext, { errorWhileRendering: null });
-    // Check Base URL
-    {
-        const { urlWithoutPageContextRequestSuffix } = handlePageContextRequestUrl(pageContext.urlOriginal);
-        const hasBaseServer = parseUrl(urlWithoutPageContextRequestSuffix, pageContext._baseServer).hasBaseServer || !!pageContext._urlRewrite;
-        if (!hasBaseServer) {
-            objectAssign(pageContext, { httpResponse: null });
-            return pageContext;
-        }
-    }
     // Route
     {
         const pageContextFromRoute = await route(pageContext);
@@ -303,7 +312,7 @@ function getRequestId() {
     assert(httpRequestId >= 1);
     return httpRequestId;
 }
-function skipRequest(urlOriginal) {
+function isIgnoredUrl(urlOriginal) {
     const isViteClientRequest = urlOriginal.endsWith('/@vite/client') || urlOriginal.startsWith('/@fs/');
     assertWarning(!isViteClientRequest, `The vike middleware renderPage() was called with the URL ${urlOriginal} which is unexpected because the HTTP request should have already been handled by Vite's development middleware. Make sure to 1. install Vite's development middleware and 2. add Vite's middleware *before* Vike's middleware, see https://vike.dev/renderPage`, { onlyOnce: true });
     return (urlOriginal.endsWith('/__vite_ping') ||
@@ -327,10 +336,8 @@ function normalizeUrl(pageContextInit, httpRequestId) {
 function getPermanentRedirect(pageContextInit, httpRequestId) {
     const { redirects, baseServer } = getGlobalContext();
     const urlWithoutBase = removeBaseServer(pageContextInit.urlOriginal, baseServer);
-    let urlOriginalPathnameWithouBase;
     let origin = null;
     let urlTarget = modifyUrlPathname(urlWithoutBase, (urlPathname) => {
-        urlOriginalPathnameWithouBase = urlPathname;
         const urlTargetWithOrigin = resolveRedirects(redirects, urlPathname);
         if (urlTargetWithOrigin === null)
             return null;
@@ -340,13 +347,12 @@ function getPermanentRedirect(pageContextInit, httpRequestId) {
     });
     if (origin)
         urlTarget = addUrlOrigin(urlTarget, origin);
-    assert(urlOriginalPathnameWithouBase);
     if (urlTarget === urlWithoutBase)
         return null;
     logRuntimeInfo?.(`Permanent redirect defined by your config.redirects (https://vike.dev/redirects)`, httpRequestId, 'info');
     urlTarget = prependBase(urlTarget, baseServer);
     assert(urlTarget !== pageContextInit.urlOriginal);
-    const httpResponse = createHttpResponseObjectRedirect({ url: urlTarget, statusCode: 301 }, urlOriginalPathnameWithouBase);
+    const httpResponse = createHttpResponseObjectRedirect({ url: urlTarget, statusCode: 301 }, urlWithoutBase);
     const pageContextHttpResponse = { ...pageContextInit, httpResponse };
     return pageContextHttpResponse;
 }
@@ -390,10 +396,28 @@ async function handleAbortError(errAbort, pageContextsFromRewrite, pageContextIn
             ...pageContextInit,
             ...pageContextAbort
         };
-        const httpResponse = createHttpResponseObjectRedirect(pageContextAbort._urlRedirect, pageContextNominalPageInit.urlPathname);
+        const httpResponse = createHttpResponseObjectRedirect(pageContextAbort._urlRedirect, (() => {
+            const { pathname, searchOriginal } = pageContextNominalPageInit.urlParsed;
+            const urlLogical = createUrlFromComponents(null, pathname, searchOriginal, 
+            // The server-side doesn't have access to the hash
+            null);
+            return urlLogical;
+        })());
         objectAssign(pageContextReturn, { httpResponse });
         return { pageContextReturn };
     }
     assert(pageContextAbort.abortStatusCode);
     return { pageContextAbort };
 }
+function checkBaseUrl(pageContextInit, httpRequestId) {
+    const { baseServer } = getGlobalContext();
+    const { urlOriginal } = pageContextInit;
+    const { urlWithoutPageContextRequestSuffix } = handlePageContextRequestUrl(urlOriginal);
+    const { hasBaseServer } = parseUrl(urlWithoutPageContextRequestSuffix, baseServer);
+    if (!hasBaseServer) {
+        logRuntimeInfo?.(`${getRequestInfoMessage(urlOriginal)} skipped because URL ${pc.bold(urlOriginal)} doesn't start with Base URL ${pc.bold(baseServer)} (https://vike.dev/base-url)`, httpRequestId, 'info');
+        const pageContextHttpResponseNull = getPageContextHttpResponseNull(pageContextInit);
+        return pageContextHttpResponseNull;
+    }
+    return null;
+}

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

@@ -3,7 +3,7 @@ import { assert, hasProp, isCallable, isObject, cast, assertUsage } from '../uti
 import { assertExportValues } from './assert_exports_old_design.js';
 import { getPageFileObject } from './getPageFileObject.js';
 import { fileTypes } from './fileTypes.js';
-import { assertPageConfigGlobalSerialized, assertPageConfigsSerialized } from '../page-configs/serialize/assertPageConfigs.js';
+import { assertPageConfigGlobalSerialized, assertPageConfigsSerialized } from '../page-configs/serialize/assertPageConfigsSerialized.js';
 import { parsePageConfigs } from '../page-configs/serialize/parsePageConfigs.js';
 function parseGlobResults(pageFilesExports) {
     assert(hasProp(pageFilesExports, 'isGeneratedFile'));

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

@@ -1,5 +1,5 @@
 export { executeHook };
 export { isUserHookError };
-import type { HookLoc, HookName } from './getHook.js';
+import type { Hook, HookLoc } from './getHook.js';
 declare function isUserHookError(err: unknown): false | HookLoc;
-declare function executeHook<T = unknown>(hookFn: () => T, hookName: HookName, hookFilePath: string): Promise<T>;
+declare function executeHook<T = unknown>(hookFnCaller: () => T, hook: Omit<Hook, 'hookFn'>): Promise<T>;

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
+    };
+}