vike 0.4.147 → 0.4.148-commit-7596dcd

package/dist/cjs/node/runtime/renderPage/createHttpResponseObject/assertNoInfiniteHttpRedirect.js

@@ -9,21 +9,21 @@ const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const globalObject = (0, utils_js_1.getGlobalObject)('assertNoInfiniteHttpRedirect.ts', {
     redirectGraph: {}
 });
-function assertNoInfiniteHttpRedirect(urlRedirectOriginal, urlRedirectPathnameLogical) {
-    if (urlRedirectOriginal.startsWith('http')) {
-        // We assume that the redirect points to an external origin, and we can therefore assume that the app doesn't define an infinite loop (in itself).
-        //  - There isn't a reliable way to check whether the redirect points to an external origin or the same origin: the user usually passes the URL without origin.
+function assertNoInfiniteHttpRedirect(urlRedirectTarget, urlLogical) {
+    if ((0, utils_js_1.isUriWithProtocol)(urlRedirectTarget)) {
+        // We assume that urlRedirectTarget points to an origin that is external (not the same origin), and we can therefore assume that the app doesn't define an infinite loop (in itself).
+        //  - There isn't a reliable way to check whether the redirect points to an external origin or the same origin. For same origins, we assume/hope the user to pass the URL without origin.
         //    ```js
-        //    // URL origin is usually missing
+        //    // For same-origin, the user usually/hopefully passes a URL without origin
         //    renderPage({ urlOriginal: '/some/pathname' })
         //    ```
         return;
     }
-    (0, utils_js_1.assert)(urlRedirectOriginal.startsWith('/'));
-    (0, utils_js_1.assert)(urlRedirectPathnameLogical.startsWith('/'));
+    (0, utils_js_1.assert)(urlRedirectTarget.startsWith('/'));
+    (0, utils_js_1.assert)(urlLogical.startsWith('/'));
     const graph = copy(globalObject.redirectGraph);
-    graph[urlRedirectOriginal] ?? (graph[urlRedirectOriginal] = new Set());
-    graph[urlRedirectOriginal].add(urlRedirectPathnameLogical);
+    graph[urlRedirectTarget] ?? (graph[urlRedirectTarget] = new Set());
+    graph[urlRedirectTarget].add(urlLogical);
     validate(graph);
     globalObject.redirectGraph = graph;
 }
@@ -32,6 +32,9 @@ function copy(G) {
     return Object.fromEntries(Object.entries(G).map(([key, val]) => [key, new Set(val)]));
 }
 // Adapted from: https://stackoverflow.com/questions/60904464/detect-cycle-in-directed-graph/60907076#60907076
+function validate(G) {
+    Object.keys(G).forEach((n) => check(G, n, []));
+}
 function check(G, n, path) {
     if (path.includes(n)) {
         const cycle = path.slice(path.indexOf(n)).concat(n);
@@ -39,6 +42,3 @@ function check(G, n, path) {
     }
     G[n]?.forEach((node) => check(G, node, [...path, n]));
 }
-function validate(G) {
-    Object.keys(G).forEach((n) => check(G, n, []));
-}

package/dist/cjs/node/runtime/renderPage/createHttpResponseObject.js

@@ -35,9 +35,9 @@ async function createHttpResponsePageContextJson(pageContextSerialized) {
 }
 exports.createHttpResponsePageContextJson = createHttpResponsePageContextJson;
 function createHttpResponseObjectRedirect({ url, statusCode }, 
-// The URL pathname we assume the redirect to be logically based on
-urlPathnameLogical) {
-    (0, assertNoInfiniteHttpRedirect_js_1.assertNoInfiniteHttpRedirect)(url, urlPathnameLogical);
+// The URL we assume the redirect to be logically based on
+urlLogical) {
+    (0, assertNoInfiniteHttpRedirect_js_1.assertNoInfiniteHttpRedirect)(url, urlLogical);
     (0, utils_js_1.assert)(url);
     (0, utils_js_1.assert)(statusCode);
     (0, utils_js_1.assert)(300 <= statusCode && statusCode <= 399);

package/dist/cjs/node/runtime/renderPage/executeOnBeforeRenderHook.js

@@ -15,7 +15,7 @@ async function executeOnBeforeRenderHooks(pageContext) {
     }
     const onBeforeRender = hook.hookFn;
     (0, preparePageContextForUserConsumptionServerSide_js_1.preparePageContextForUserConsumptionServerSide)(pageContext);
-    const hookResult = await (0, utils_js_1.executeHook)(() => onBeforeRender(pageContext), 'onBeforeRender', hook.hookFilePath);
+    const hookResult = await (0, utils_js_1.executeHook)(() => onBeforeRender(pageContext), hook);
     (0, assertOnBeforeRenderHookReturn_js_1.assertOnBeforeRenderHookReturn)(hookResult, hook.hookFilePath);
     const pageContextFromHook = hookResult?.pageContext;
     Object.assign(pageContext, pageContextFromHook);

package/dist/cjs/node/runtime/renderPage/executeOnRenderHtmlHook.js

@@ -17,7 +17,7 @@ async function executeOnRenderHtmlHook(pageContext) {
     const { renderHook, hookFn } = getRenderHook(pageContext);
     (0, utils_js_1.objectAssign)(pageContext, { _renderHook: renderHook });
     (0, preparePageContextForUserConsumptionServerSide_js_1.preparePageContextForUserConsumptionServerSide)(pageContext);
-    const hookReturnValue = await (0, utils_js_1.executeHook)(() => hookFn(pageContext), renderHook.hookName, renderHook.hookFilePath);
+    const hookReturnValue = await (0, utils_js_1.executeHook)(() => hookFn(pageContext), renderHook);
     const { documentHtml, pageContextProvidedByRenderHook, pageContextPromise, injectFilter } = processHookReturnValue(hookReturnValue, renderHook);
     Object.assign(pageContext, pageContextProvidedByRenderHook);
     (0, utils_js_1.objectAssign)(pageContext, { _pageContextPromise: pageContextPromise });
@@ -56,10 +56,10 @@ function getRenderHook(pageContext) {
         }
         if (hook) {
             (0, utils_js_1.assert)(hookName);
-            const { hookFilePath, hookFn } = hook;
+            const { hookFilePath, hookFn, hookTimeout } = hook;
             hookFound = {
                 hookFn,
-                renderHook: { hookFilePath, hookName }
+                renderHook: { hookFn, hookFilePath, hookName, hookTimeout }
             };
         }
     }

package/dist/cjs/node/runtime/renderPage/getHttpResponseBody.js

@@ -11,7 +11,7 @@ const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const streamDocs = 'See https://vike.dev/stream for more information.';
 function getHttpResponseBody(htmlRender, renderHook) {
     if (typeof htmlRender !== 'string') {
-        (0, utils_js_1.assertUsage)(false, getErrMsg(htmlRender, renderHook, 'body', `Use ${picocolors_1.default.cyan('pageContext.httpResponse.pipe()')} or ${picocolors_1.default.cyan('pageContext.httpResponse.getBody()')} instead`));
+        (0, utils_js_1.assertUsage)(false, getErrMsg(htmlRender, renderHook, 'body', `Use ${picocolors_1.default.cyan('pageContext.httpResponse.pipe()')} instead`));
     }
     const body = htmlRender;
     return body;

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

@@ -155,7 +155,7 @@ async function getRenderContext() {
     const globalContext = (0, globalContext_js_1.getGlobalContext)();
     const { pageFilesAll, allPageIds, pageConfigs, pageConfigGlobal } = await (0, getPageFiles_js_1.getPageFilesAll)(false, globalContext.isProduction);
     const { pageRoutes, onBeforeRouteHook } = await (0, loadPageRoutes_js_1.loadPageRoutes)(pageFilesAll, pageConfigs, pageConfigGlobal, allPageIds);
-    assertNonMixedDesign(pageFilesAll, pageConfigs);
+    assertV1Design(pageFilesAll, pageConfigs);
     const renderContext = {
         pageFilesAll: pageFilesAll,
         pageConfigs,
@@ -167,21 +167,24 @@ async function getRenderContext() {
     return renderContext;
 }
 exports.getRenderContext = getRenderContext;
-function assertNonMixedDesign(pageFilesAll, pageConfigs) {
-    if (pageFilesAll.length === 0 || pageConfigs.length === 0)
-        return;
-    const indent = '- ';
-    const v1Files = (0, utils_js_1.unique)(pageConfigs
-        .map((p) => Object.values(p.configValues)
-        .map(helpers_js_1.getConfigValueFilePathToShowToUser)
-        .filter(utils_js_1.isNotNullish)
-        .map((filePathToShowToUser) => indent + filePathToShowToUser))
-        .flat(2));
-    (0, utils_js_1.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 = (0, utils_js_1.unique)(pageConfigs
+            .map((p) => Object.values(p.configValues)
+            .map(helpers_js_1.getConfigValueFilePathToShowToUser)
+            .filter(utils_js_1.isNotNullish)
+            .map((filePathToShowToUser) => indent + filePathToShowToUser))
+            .flat(2));
+        (0, utils_js_1.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'));
+    }
+    (0, utils_js_1.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/cjs/node/runtime/renderPage.js

@@ -39,17 +39,17 @@ async function renderPage(pageContextInit) {
     (0, assertArguments_js_1.assertArguments)(...arguments);
     (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageContextInit, 'urlOriginal', 'string'));
     (0, utils_js_1.assertEnv)();
-    if (skipRequest(pageContextInit.urlOriginal)) {
-        const pageContextHttpReponseNull = getPageContextHttpResponseNull(pageContextInit);
-        (0, utils_js_1.checkType)(pageContextHttpReponseNull);
-        return pageContextHttpReponseNull;
+    if (isIgnoredUrl(pageContextInit.urlOriginal)) {
+        const pageContextHttpResponseNull = getPageContextHttpResponseNull(pageContextInit);
+        (0, utils_js_1.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();
     (0, utils_js_1.checkType)(pageContextReturn);
@@ -60,8 +60,8 @@ async function renderPageAndPrepare(pageContextInit, httpRequestId) {
     // Invalid config
     const handleInvalidConfig = () => {
         (0, loggerRuntime_js_1.logRuntimeInfo)?.(picocolors_1.default.bold(picocolors_1.default.red("Couldn't load configuration: see error above.")), httpRequestId, 'error');
-        const pageContextHttpReponseNull = getPageContextHttpResponseNull(pageContextInit);
-        return pageContextHttpReponseNull;
+        const pageContextHttpResponseNull = getPageContextHttpResponseNull(pageContextInit);
+        return pageContextHttpResponseNull;
     };
     if (isConfigInvalid_js_1.isConfigInvalid) {
         return handleInvalidConfig();
@@ -77,8 +77,8 @@ async function renderPageAndPrepare(pageContextInit, httpRequestId) {
         // initGlobalContext() and getRenderContext() don't call any user hooks => err isn't thrown from user code
         (0, utils_js_1.assert)(!(0, abort_js_1.isAbortError)(err));
         (0, loggerRuntime_js_1.logRuntimeError)(err, httpRequestId);
-        const pageContextHttpReponseNull = getPageContextHttpResponseNullWithError(err, pageContextInit);
-        return pageContextHttpReponseNull;
+        const pageContextHttpResponseNull = getPageContextHttpResponseNullWithError(err, pageContextInit);
+        return pageContextHttpResponseNull;
     }
     if (isConfigInvalid_js_1.isConfigInvalid) {
         return handleInvalidConfig();
@@ -86,15 +86,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, []);
 }
@@ -177,8 +185,8 @@ async function renderPageAlreadyPrepared(pageContextInit, httpRequestId, renderC
                 if (!handled.pageContextReturn) {
                     const pageContextAbort = errErrorPage._pageContextAbort;
                     (0, utils_js_1.assertWarning)(false, `Failed to render error page because ${picocolors_1.default.cyan(pageContextAbort._abortCall)} was called: make sure ${picocolors_1.default.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;
@@ -186,18 +194,28 @@ async function renderPageAlreadyPrepared(pageContextInit, httpRequestId, renderC
             if ((0, isNewError_js_1.isNewError)(errErrorPage, errNominalPage)) {
                 (0, loggerRuntime_js_1.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;
-    (0, loggerRuntime_js_1.logRuntimeInfo)?.(`HTTP request: ${picocolors_1.default.bold(urlToShowToUser)}`, httpRequestId, 'info', clearErrors);
+    (0, loggerRuntime_js_1.logRuntimeInfo)?.(getRequestInfoMessage(urlOriginal), httpRequestId, 'info', clearErrors);
 }
-function logHttpResponse(urlToShowToUser, httpRequestId, pageContextReturn) {
+function getRequestInfoMessage(urlOriginal) {
+    return `HTTP request: ${picocolors_1.default.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) => picocolors_1.default.bold(isSuccess ? picocolors_1.default.green(String(s)) : picocolors_1.default.red(String(s)));
@@ -211,39 +229,30 @@ function logHttpResponse(urlToShowToUser, httpRequestId, pageContextReturn) {
             .find((header) => header[0] === 'Location');
         (0, utils_js_1.assert)(headerRedirect);
         const urlRedirect = headerRedirect[1];
-        urlToShowToUser = urlRedirect;
+        urlOriginal = urlRedirect;
     }
-    (0, loggerRuntime_js_1.logRuntimeInfo)?.(`HTTP ${type} ${picocolors_1.default.bold(urlToShowToUser)} ${color(statusCode ?? 'ERR')}`, httpRequestId, isNominal ? 'info' : 'error');
+    (0, loggerRuntime_js_1.logRuntimeInfo)?.(`HTTP ${type} ${picocolors_1.default.bold(urlOriginal)} ${color(statusCode ?? 'ERR')}`, httpRequestId, isNominal ? 'info' : 'error');
 }
 function getPageContextHttpResponseNullWithError(err, pageContextInit) {
-    const pageContextHttpReponseNull = {};
-    (0, utils_js_1.objectAssign)(pageContextHttpReponseNull, pageContextInit);
-    (0, utils_js_1.objectAssign)(pageContextHttpReponseNull, {
+    const pageContextHttpResponseNull = {};
+    (0, utils_js_1.objectAssign)(pageContextHttpResponseNull, pageContextInit);
+    (0, utils_js_1.objectAssign)(pageContextHttpResponseNull, {
         httpResponse: null,
         errorWhileRendering: err
     });
-    return pageContextHttpReponseNull;
+    return pageContextHttpResponseNull;
 }
 function getPageContextHttpResponseNull(pageContextInit) {
-    const pageContextHttpReponseNull = {};
-    (0, utils_js_1.objectAssign)(pageContextHttpReponseNull, pageContextInit);
-    (0, utils_js_1.objectAssign)(pageContextHttpReponseNull, {
+    const pageContextHttpResponseNull = {};
+    (0, utils_js_1.objectAssign)(pageContextHttpResponseNull, pageContextInit);
+    (0, utils_js_1.objectAssign)(pageContextHttpResponseNull, {
         httpResponse: null,
         errorWhileRendering: null
     });
-    return pageContextHttpReponseNull;
+    return pageContextHttpResponseNull;
 }
 async function renderPageNominal(pageContext) {
     (0, utils_js_1.objectAssign)(pageContext, { errorWhileRendering: null });
-    // Check Base URL
-    {
-        const { urlWithoutPageContextRequestSuffix } = (0, handlePageContextRequestUrl_js_1.handlePageContextRequestUrl)(pageContext.urlOriginal);
-        const hasBaseServer = (0, utils_js_1.parseUrl)(urlWithoutPageContextRequestSuffix, pageContext._baseServer).hasBaseServer || !!pageContext._urlRewrite;
-        if (!hasBaseServer) {
-            (0, utils_js_1.objectAssign)(pageContext, { httpResponse: null });
-            return pageContext;
-        }
-    }
     // Route
     {
         const pageContextFromRoute = await (0, index_js_1.route)(pageContext);
@@ -309,7 +318,7 @@ function getRequestId() {
     (0, utils_js_1.assert)(httpRequestId >= 1);
     return httpRequestId;
 }
-function skipRequest(urlOriginal) {
+function isIgnoredUrl(urlOriginal) {
     const isViteClientRequest = urlOriginal.endsWith('/@vite/client') || urlOriginal.startsWith('/@fs/');
     (0, utils_js_1.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') ||
@@ -333,10 +342,8 @@ function normalizeUrl(pageContextInit, httpRequestId) {
 function getPermanentRedirect(pageContextInit, httpRequestId) {
     const { redirects, baseServer } = (0, globalContext_js_1.getGlobalContext)();
     const urlWithoutBase = (0, utils_js_1.removeBaseServer)(pageContextInit.urlOriginal, baseServer);
-    let urlOriginalPathnameWithouBase;
     let origin = null;
     let urlTarget = (0, utils_js_1.modifyUrlPathname)(urlWithoutBase, (urlPathname) => {
-        urlOriginalPathnameWithouBase = urlPathname;
         const urlTargetWithOrigin = (0, resolveRedirects_js_1.resolveRedirects)(redirects, urlPathname);
         if (urlTargetWithOrigin === null)
             return null;
@@ -346,13 +353,12 @@ function getPermanentRedirect(pageContextInit, httpRequestId) {
     });
     if (origin)
         urlTarget = (0, utils_js_1.addUrlOrigin)(urlTarget, origin);
-    (0, utils_js_1.assert)(urlOriginalPathnameWithouBase);
     if (urlTarget === urlWithoutBase)
         return null;
     (0, loggerRuntime_js_1.logRuntimeInfo)?.(`Permanent redirect defined by your config.redirects (https://vike.dev/redirects)`, httpRequestId, 'info');
     urlTarget = (0, utils_js_1.prependBase)(urlTarget, baseServer);
     (0, utils_js_1.assert)(urlTarget !== pageContextInit.urlOriginal);
-    const httpResponse = (0, createHttpResponseObject_js_1.createHttpResponseObjectRedirect)({ url: urlTarget, statusCode: 301 }, urlOriginalPathnameWithouBase);
+    const httpResponse = (0, createHttpResponseObject_js_1.createHttpResponseObjectRedirect)({ url: urlTarget, statusCode: 301 }, urlWithoutBase);
     const pageContextHttpResponse = { ...pageContextInit, httpResponse };
     return pageContextHttpResponse;
 }
@@ -396,10 +402,28 @@ async function handleAbortError(errAbort, pageContextsFromRewrite, pageContextIn
             ...pageContextInit,
             ...pageContextAbort
         };
-        const httpResponse = (0, createHttpResponseObject_js_1.createHttpResponseObjectRedirect)(pageContextAbort._urlRedirect, pageContextNominalPageInit.urlPathname);
+        const httpResponse = (0, createHttpResponseObject_js_1.createHttpResponseObjectRedirect)(pageContextAbort._urlRedirect, (() => {
+            const { pathname, searchOriginal } = pageContextNominalPageInit.urlParsed;
+            const urlLogical = (0, utils_js_1.createUrlFromComponents)(null, pathname, searchOriginal, 
+            // The server-side doesn't have access to the hash
+            null);
+            return urlLogical;
+        })());
         (0, utils_js_1.objectAssign)(pageContextReturn, { httpResponse });
         return { pageContextReturn };
     }
     (0, utils_js_1.assert)(pageContextAbort.abortStatusCode);
     return { pageContextAbort };
 }
+function checkBaseUrl(pageContextInit, httpRequestId) {
+    const { baseServer } = (0, globalContext_js_1.getGlobalContext)();
+    const { urlOriginal } = pageContextInit;
+    const { urlWithoutPageContextRequestSuffix } = (0, handlePageContextRequestUrl_js_1.handlePageContextRequestUrl)(urlOriginal);
+    const { hasBaseServer } = (0, utils_js_1.parseUrl)(urlWithoutPageContextRequestSuffix, baseServer);
+    if (!hasBaseServer) {
+        (0, loggerRuntime_js_1.logRuntimeInfo)?.(`${getRequestInfoMessage(urlOriginal)} skipped because URL ${picocolors_1.default.bold(urlOriginal)} doesn't start with Base URL ${picocolors_1.default.bold(baseServer)} (https://vike.dev/base-url)`, httpRequestId, 'info');
+        const pageContextHttpResponseNull = getPageContextHttpResponseNull(pageContextInit);
+        return pageContextHttpResponseNull;
+    }
+    return null;
+}

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

@@ -5,7 +5,7 @@ const utils_js_1 = require("../utils.js");
 const assert_exports_old_design_js_1 = require("./assert_exports_old_design.js");
 const getPageFileObject_js_1 = require("./getPageFileObject.js");
 const fileTypes_js_1 = require("./fileTypes.js");
-const assertPageConfigs_js_1 = require("../page-configs/serialize/assertPageConfigs.js");
+const assertPageConfigsSerialized_js_1 = require("../page-configs/serialize/assertPageConfigsSerialized.js");
 const parsePageConfigs_js_1 = require("../page-configs/serialize/parsePageConfigs.js");
 function parseGlobResults(pageFilesExports) {
     (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageFilesExports, 'isGeneratedFile'));
@@ -21,8 +21,8 @@ function parseGlobResults(pageFilesExports) {
     (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageFilesExports, 'pageConfigsSerialized'));
     (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageFilesExports, 'pageConfigGlobalSerialized'));
     const { pageConfigsSerialized, pageConfigGlobalSerialized } = pageFilesExports;
-    (0, assertPageConfigs_js_1.assertPageConfigsSerialized)(pageConfigsSerialized);
-    (0, assertPageConfigs_js_1.assertPageConfigGlobalSerialized)(pageConfigGlobalSerialized);
+    (0, assertPageConfigsSerialized_js_1.assertPageConfigsSerialized)(pageConfigsSerialized);
+    (0, assertPageConfigsSerialized_js_1.assertPageConfigGlobalSerialized)(pageConfigGlobalSerialized);
     const { pageConfigs, pageConfigGlobal } = (0, parsePageConfigs_js_1.parsePageConfigs)(pageConfigsSerialized, pageConfigGlobalSerialized);
     const pageFilesMap = {};
     parseGlobResult(pageFilesExports.pageFilesLazy).forEach(({ filePath, pageFile, globValue }) => {

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

@@ -14,8 +14,8 @@ function isUserHookError(err) {
     return globalObject.userHookErrors.get(err) ?? false;
 }
 exports.isUserHookError = isUserHookError;
-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_) => {
@@ -29,19 +29,23 @@ function executeHook(hookFn, hookName, hookFilePath) {
         };
     });
     const clearTimeouts = () => {
-        clearTimeout(t1);
-        clearTimeout(t2);
+        if (currentTimeoutWarn)
+            clearTimeout(currentTimeoutWarn);
+        if (currentTimeoutErr)
+            clearTimeout(currentTimeoutErr);
     };
-    const t1 = setTimeout(() => {
-        (0, assert_js_1.assertWarning)(false, `The ${hookName}() hook defined by ${hookFilePath} is taking more than ${(0, humanizeTime_js_1.humanizeTime)(timeoutWarn)}`, { onlyOnce: false });
-    }, timeoutWarn);
-    const t2 = setTimeout(() => {
-        const err = (0, assert_js_1.getProjectError)(`Hook timeout: the ${hookName}() hook defined by ${hookFilePath} didn't finish after ${(0, humanizeTime_js_1.humanizeTime)(timeoutErr)}`);
-        reject(err);
-    }, timeoutErr);
+    const currentTimeoutWarn = isNotDisabled(timeoutWarn) &&
+        setTimeout(() => {
+            (0, assert_js_1.assertWarning)(false, `The ${hookName}() hook defined by ${hookFilePath} is slow: it's taking more than ${(0, humanizeTime_js_1.humanizeTime)(timeoutWarn)} (https://vike.dev/hooksTimeout)`, { onlyOnce: false });
+        }, timeoutWarn);
+    const currentTimeoutErr = isNotDisabled(timeoutErr) &&
+        setTimeout(() => {
+            const err = (0, assert_js_1.getProjectError)(`The ${hookName}() hook defined by ${hookFilePath} timed out: it didn't finish after ${(0, humanizeTime_js_1.humanizeTime)(timeoutErr)} (https://vike.dev/hooksTimeout)`);
+            reject(err);
+        }, timeoutErr);
     (async () => {
         try {
-            const ret = await hookFn();
+            const ret = await hookFnCaller();
             resolve(ret);
         }
         catch (err) {
@@ -54,21 +58,6 @@ function executeHook(hookFn, hookName, hookFilePath) {
     return promise;
 }
 exports.executeHook = executeHook;
-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/cjs/shared/hooks/getHook.js

@@ -1,11 +1,18 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertHookFn = exports.assertHook = exports.getHook = void 0;
+exports.getHookTimeoutDefault = exports.assertHook = exports.getHookFromPageConfigGlobal = exports.getHookFromPageConfig = exports.getHook = void 0;
+const helpers_js_1 = require("../page-configs/helpers.js");
 const utils_js_1 = require("../utils.js");
+const picocolors_1 = __importDefault(require("@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];
     (0, utils_js_1.assert)(file.exportValue === hookFn);
@@ -15,9 +22,41 @@ function getHook(pageContext, hookName) {
     (0, utils_js_1.assert)(hookFilePath);
     (0, utils_js_1.assert)(!hookFilePath.endsWith(' '));
     assertHookFn(hookFn, { hookName, hookFilePath });
-    return { hookFn, hookName, hookFilePath };
+    return { hookFn, hookName, hookFilePath, hookTimeout };
 }
 exports.getHook = getHook;
+function getHookFromPageConfig(pageConfig, hookName) {
+    const configValue = (0, helpers_js_1.getConfigValue)(pageConfig, hookName);
+    const hooksTimeout = (0, helpers_js_1.getConfigValue)(pageConfig, 'hooksTimeout')?.value;
+    if (!configValue)
+        return null;
+    const hookFn = configValue.value;
+    if (!hookFn)
+        return null;
+    const hookFilePath = (0, helpers_js_1.getHookFilePathToShowToUser)(configValue);
+    // hook isn't a computed nor a cumulative config => definedAt should always be defined
+    (0, utils_js_1.assert)(hookFilePath);
+    assertHookFn(hookFn, { hookName, hookFilePath });
+    const hookTimeout = getHookTimeout(hooksTimeout, hookName);
+    return { hookFn, hookName, hookFilePath, hookTimeout };
+}
+exports.getHookFromPageConfig = getHookFromPageConfig;
+function getHookFromPageConfigGlobal(pageConfigGlobal, hookName) {
+    const configValue = pageConfigGlobal.configValues[hookName];
+    if (!configValue)
+        return null;
+    const hookFn = configValue.value;
+    if (!hookFn)
+        return null;
+    const hookFilePath = (0, helpers_js_1.getHookFilePathToShowToUser)(configValue);
+    // hook isn't a computed nor a cumulative config => definedAt should always be defined
+    (0, utils_js_1.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 };
+}
+exports.getHookFromPageConfigGlobal = getHookFromPageConfigGlobal;
 function assertHook(pageContext, hookName) {
     getHook(pageContext, hookName);
 }
@@ -28,4 +67,66 @@ function assertHookFn(hookFn, { hookName, hookFilePath }) {
     (0, utils_js_1.assertUsage)((0, utils_js_1.isCallable)(hookFn), `Hook ${hookName}() defined by ${hookFilePath} should be a function`);
     (0, utils_js_1.checkType)(hookFn);
 }
-exports.assertHookFn = assertHookFn;
+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;
+    (0, utils_js_1.assertUsage)((0, utils_js_1.isObject)(hooksTimeoutProvidedByUser), `Setting ${picocolors_1.default.cyan('hooksTimeout')} should be ${picocolors_1.default.cyan('false')} or an object`);
+    const hooksTimeoutProvidedByUserNormalized = {};
+    Object.entries(hooksTimeoutProvidedByUser).forEach(([hookName, hookTimeoutProvidedbyUser]) => {
+        if (hookTimeoutProvidedbyUser === false) {
+            hooksTimeoutProvidedByUserNormalized[hookName] = { error: false, warning: false };
+            return;
+        }
+        (0, utils_js_1.assertUsage)((0, utils_js_1.isObject)(hookTimeoutProvidedbyUser), `Setting ${picocolors_1.default.cyan(`hooksTimeout.${hookName}`)} should be ${picocolors_1.default.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 ${picocolors_1.default.cyan(`hooksTimeout.${hookName}.${timeoutName}`)} should be`;
+            (0, utils_js_1.assertUsage)(typeof timeoutVal === 'number', `${errPrefix} ${picocolors_1.default.cyan('false')} or a number`);
+            (0, utils_js_1.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
+    };
+}
+exports.getHookTimeoutDefault = getHookTimeoutDefault;

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

@@ -10,7 +10,7 @@ const getExportPath_js_1 = require("../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} ${picocolors_1.default.cyan(configNameStr)} defined ${definedAtStr}`;
     return configDefinedAt;
 }

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

@@ -21,7 +21,7 @@ async function executeGuardHook(pageContext, prepareForUserConsumption) {
     const res = prepareForUserConsumption(pageContext);
     if (res)
         pageContextForUserConsumption = res;
-    const hookResult = await (0, utils_js_1.executeHook)(() => guard(pageContextForUserConsumption), 'guard', hook.hookFilePath);
+    const hookResult = await (0, utils_js_1.executeHook)(() => guard(pageContextForUserConsumption), hook);
     (0, utils_js_1.assertUsage)(hookResult === undefined, `The guard() hook of ${hook.hookFilePath} returns a value, but guard() doesn't accept any return value`);
 }
 exports.executeGuardHook = executeGuardHook;
@@ -35,6 +35,7 @@ function findPageGuard(pageId, pageFilesAll) {
     if (!hookFn)
         return null;
     const hookFilePath = filePath;
+    const hookTimeout = (0, getHook_js_1.getHookTimeoutDefault)('guard');
     (0, utils_js_1.assertUsage)((0, utils_js_1.isCallable)(hookFn), `guard() defined by ${hookFilePath} should be a function`);
-    return { hookFn, hookName: 'guard', hookFilePath };
+    return { hookFn, hookName: 'guard', hookFilePath, hookTimeout };
 }