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

package/dist/cjs/node/plugin/plugins/importUserCode/v1-design/getConfigValuesSerialized.js

@@ -53,22 +53,27 @@ function getConfigValueSerialized(value, configName, definedAt) {
         configValueSerialized = (0, stringify_1.stringify)(value, { valueName, forbidReactElements: true });
     }
     catch (err) {
-        let serializationErrMsg = '';
-        if ((0, stringify_1.isJsonSerializerError)(err)) {
-            serializationErrMsg = err.messageCore;
-        }
-        else {
-            // When a property getter throws an error
-            console.error('Serialization error:');
-            console.error(err);
-            serializationErrMsg = 'see serialization error printed above';
+        /*
+        let serializationErrMsg = ''
+        if (isJsonSerializerError(err)) {
+          serializationErrMsg = err.messageCore
+        } else {
+          // When a property getter throws an error
+          console.error('Serialization error:')
+          console.error(err)
+          serializationErrMsg = 'see serialization error printed above'
         }
+        */
         const configValueFilePathToShowToUser = (0, helpers_js_1.getConfigValueFilePathToShowToUser)({ definedAt });
         (0, utils_js_1.assert)(configValueFilePathToShowToUser);
         (0, utils_js_1.assertUsage)(false, [
-            `The value of the config ${picocolors_1.default.cyan(configName)} cannot be defined inside the file ${configValueFilePathToShowToUser}:`,
-            `its value must be defined in an another file and then imported by ${configValueFilePathToShowToUser}. (Because its value isn't serializable: ${serializationErrMsg}.)`,
-            `Only serializable config values can be defined inside +config.h.js files, see https://vike.dev/header-file.`
+            `The code of ${picocolors_1.default.cyan(configName)} cannot live inside ${configValueFilePathToShowToUser},`,
+            'see https://vike.dev/header-file#runtime-code'
+            /* I guess showing this is more confusing than adding value.
+            `(technically speaking: the value of ${pc.cyan(
+              configName
+            )} isn't serializable (${serializationErrMsg}) and it's therefore runtime code that needs to be imported).`
+            //*/
         ].join(' '));
     }
     configValueSerialized = JSON.stringify(configValueSerialized);

package/dist/cjs/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/configDefinitionsBuiltIn.js

@@ -76,6 +76,9 @@ const configDefinitionsBuiltIn = {
     onBeforeRenderEnv: {
         env: { client: true },
         _computed: (configValueSources) => !isConfigSet(configValueSources, 'onBeforeRender') ? null : getConfigEnv(configValueSources, 'onBeforeRender')
+    },
+    hooksTimeout: {
+        env: { server: true, client: true }
     }
 };
 exports.configDefinitionsBuiltIn = configDefinitionsBuiltIn;

package/dist/cjs/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/crawlPlusFiles.js

@@ -51,6 +51,18 @@ async function crawlPlusFiles(userRootDir, outDirAbsoluteFilesystem, isDev) {
 exports.crawlPlusFiles = crawlPlusFiles;
 // Same as fastGlob() but using `$ git ls-files`
 async function gitLsFiles(userRootDir, outDir) {
+    // Test if Git is installed
+    {
+        let stdout;
+        try {
+            const res = await execA('git --version', { cwd: userRootDir });
+            stdout = res.stdout;
+        }
+        catch {
+            return null;
+        }
+        (0, utils_js_1.assert)(stdout.startsWith('git version '));
+    }
     const cmd = [
         'git ls-files',
         ...utils_js_1.scriptFileExtensionList.map((ext) => `"**/+*.${ext}"`),

package/dist/cjs/node/plugin/plugins/importUserCode/v1-design/getVikeConfig.js

@@ -127,6 +127,7 @@ async function loadInterfaceFiles(userRootDir, outDirRoot, isDev, extensions) {
             interfaceFilesByLocationId[locationId].push(interfaceFile);
         }
     }));
+    assertAllConfigsAreKnown(interfaceFilesByLocationId);
     return interfaceFilesByLocationId;
 }
 function getConfigDefinition(configDefinitionsRelevant, configName, filePathToShowToUser) {
@@ -180,6 +181,18 @@ function getInterfaceFileFromConfigFile(configFile, isConfigExtend) {
     });
     return interfaceFile;
 }
+/** Show error message upon unknown config */
+function assertAllConfigsAreKnown(interfaceFilesByLocationId) {
+    Object.entries(interfaceFilesByLocationId).forEach(([locationId, interfaceFiles]) => {
+        const interfaceFilesRelevant = getInterfaceFilesRelevant(interfaceFilesByLocationId, locationId);
+        const configDefinitionsRelevant = getConfigDefinitions(interfaceFilesRelevant);
+        interfaceFiles.forEach((interfaceFile) => {
+            Object.keys(interfaceFile.configMap).forEach((configName) => {
+                assertConfigExists(configName, Object.keys(configDefinitionsRelevant), interfaceFile.filePath.filePathToShowToUser);
+            });
+        });
+    });
+}
 async function loadVikeConfig_withErrorHandling(userRootDir, outDirRoot, isDev, extensions, tolerateInvalidConfig) {
     let hasError = false;
     let ret;
@@ -270,18 +283,23 @@ async function loadVikeConfig(userRootDir, outDirRoot, isDev, extensions) {
         };
         return pageConfig;
     }));
-    // Show error message upon unknown config
-    Object.entries(interfaceFilesByLocationId).forEach(([locationId, interfaceFiles]) => {
-        const interfaceFilesRelevant = getInterfaceFilesRelevant(interfaceFilesByLocationId, locationId);
-        const configDefinitionsRelevant = getConfigDefinitions(interfaceFilesRelevant);
-        interfaceFiles.forEach((interfaceFile) => {
-            Object.keys(interfaceFile.configMap).forEach((configName) => {
-                assertConfigExists(configName, Object.keys(configDefinitionsRelevant), interfaceFile.filePath.filePathToShowToUser);
-            });
-        });
-    });
+    assertPageConfigs(pageConfigs);
     return { pageConfigs, pageConfigGlobal, globalVikeConfig };
 }
+function assertPageConfigs(pageConfigs) {
+    pageConfigs.forEach((pageConfig) => {
+        assertOnBeforeRenderEnv(pageConfig);
+    });
+}
+function assertOnBeforeRenderEnv(pageConfig) {
+    const onBeforeRenderConfig = pageConfig.configValueSources.onBeforeRender?.[0];
+    if (!onBeforeRenderConfig)
+        return;
+    const onBeforeRenderEnv = onBeforeRenderConfig.configEnv;
+    const isClientRouting = !!pageConfig.configValues.clientRouting?.value;
+    // When using Server Routing, loading a onBeforeRender() hook on the client-side hasn't any effect (the Server Routing's client runtime never calls it); it unnecessarily bloats client bundle sizes
+    (0, utils_js_1.assertUsage)(!(onBeforeRenderEnv.client && !isClientRouting), `Page ${pageConfig.pageId} has an onBeforeRender() hook with env ${picocolors_1.default.cyan(JSON.stringify(onBeforeRenderEnv))} which doesn't make sense because the page is using Server Routing: onBeforeRender() can be run in the client only when using Client Routing.`);
+}
 function interfacefileIsAlreaydLoaded(interfaceFile) {
     const configMapValues = Object.values(interfaceFile.configMap);
     const isAlreadyLoaded = configMapValues.some((conf) => 'configValue' in conf);

package/dist/cjs/node/prerender/runPrerender.js

@@ -185,18 +185,16 @@ async function callOnBeforePrerenderStartHooks(prerenderContext, renderContext,
     await Promise.all(renderContext.pageConfigs.map((pageConfig) => concurrencyLimit(async () => {
         const hookName = 'onBeforePrerenderStart';
         const pageConfigLoaded = await (0, loadConfigValues_js_1.loadConfigValues)(pageConfig, false);
-        const configValue = (0, helpers_js_1.getConfigValue)(pageConfigLoaded, hookName);
-        if (!configValue)
+        const hook = (0, getHook_js_1.getHookFromPageConfig)(pageConfigLoaded, hookName);
+        if (!hook)
             return;
-        const hookFn = configValue.value;
-        const hookFilePath = (0, helpers_js_1.getHookFilePathToShowToUser)(configValue);
-        (0, utils_js_1.assert)(hookFilePath);
-        (0, getHook_js_1.assertHookFn)(hookFn, { hookName, hookFilePath });
+        const { hookFn, hookFilePath, hookTimeout } = hook;
         onBeforePrerenderStartHooks.push({
             hookFn,
             hookName: 'onBeforePrerenderStart',
             hookFilePath,
-            pageId: pageConfig.pageId
+            pageId: pageConfig.pageId,
+            hookTimeout
         });
     })));
     // 0.4 design
@@ -220,14 +218,15 @@ async function callOnBeforePrerenderStartHooks(prerenderContext, renderContext,
             hookFn,
             hookName: 'prerender',
             hookFilePath,
-            pageId: p.pageId
+            pageId: p.pageId,
+            hookTimeout: (0, getHook_js_1.getHookTimeoutDefault)('onBeforePrerenderStart')
         });
     })));
-    await Promise.all(onBeforePrerenderStartHooks.map(({ hookFn, hookName, hookFilePath, pageId }) => concurrencyLimit(async () => {
+    await Promise.all(onBeforePrerenderStartHooks.map(({ hookFn, hookName, hookFilePath, pageId, hookTimeout }) => concurrencyLimit(async () => {
         if (doNotPrerenderList.find((p) => p.pageId === pageId)) {
             return;
         }
-        const prerenderResult = await hookFn();
+        const prerenderResult = await (0, utils_js_1.executeHook)(() => hookFn(), { hookName, hookFilePath, hookTimeout });
         const result = normalizeOnPrerenderHookResult(prerenderResult, hookFilePath, hookName);
         result.forEach(({ url, pageContext }) => {
             {
@@ -326,23 +325,21 @@ async function callOnPrerenderStartHook(prerenderContext, renderContext) {
     let onPrerenderStartHook;
     // V1 design
     if (renderContext.pageConfigs.length > 0) {
-        const { pageConfigGlobal } = renderContext;
-        const configValue = pageConfigGlobal.configValues.onPrerenderStart;
-        if (configValue?.value) {
-            const { value: hookFn } = configValue;
-            // config.onPrerenderStart isn't a computed nor a cumulative config => definedAt should always be defined
-            const hookFilePath = (0, helpers_js_1.getHookFilePathToShowToUser)(configValue);
-            (0, utils_js_1.assert)(hookFilePath);
+        const hookName = 'onPrerenderStart';
+        const hook = (0, getHook_js_1.getHookFromPageConfigGlobal)(renderContext.pageConfigGlobal, hookName);
+        if (hook) {
+            (0, utils_js_1.assert)(hook.hookName === 'onPrerenderStart');
             onPrerenderStartHook = {
-                hookFn,
-                hookName: 'onPrerenderStart',
-                hookFilePath
+                ...hook,
+                // Make TypeScript happy
+                hookName
             };
         }
     }
     // Old design
     // TODO/v1-release: remove
     if (renderContext.pageConfigs.length === 0) {
+        const hookTimeout = (0, getHook_js_1.getHookTimeoutDefault)('onBeforePrerender');
         const pageFilesWithOnBeforePrerenderHook = renderContext.pageFilesAll.filter((p) => {
             assertExportNames(p);
             if (!p.exportNames?.includes('onBeforePrerender'))
@@ -368,7 +365,8 @@ async function callOnPrerenderStartHook(prerenderContext, renderContext) {
         onPrerenderStartHook = {
             hookFn: hook.onBeforePrerender,
             hookFilePath: hook.hookFilePath,
-            hookName: 'onBeforePrerender'
+            hookName: 'onBeforePrerender',
+            hookTimeout
         };
     }
     if (!onPrerenderStartHook) {
@@ -403,7 +401,7 @@ async function callOnPrerenderStartHook(prerenderContext, renderContext) {
             });
             return prerenderContext.pageContexts;
         }
-    }), hookName, hookFilePath);
+    }), onPrerenderStartHook);
     if (result === null || result === undefined) {
         return;
     }

package/dist/cjs/node/runtime/html/renderHtml.js

@@ -179,7 +179,7 @@ async function renderTemplate(templateContent, pageContext) {
         };
         (0, utils_js_1.assertUsage)(!(0, utils_js_1.isPromise)(templateVar), getErrMsg('a promise', `Did you forget to ${picocolors_1.default.cyan('await')} the promise?`));
         if (templateVar === undefined || templateVar === null) {
-            (0, utils_js_1.assertWarning)(false, getErrMsg(`${picocolors_1.default.cyan(String(templateVar))} which will be converted to an empty string`, `Pass an empty string instead of ${picocolors_1.default.cyan(String(templateVar))} to remove this warning.`), { onlyOnce: false });
+            (0, utils_js_1.assertWarning)(false, getErrMsg(`${picocolors_1.default.cyan(String(templateVar))} which will be converted to an empty string`, `Pass the empty string ${picocolors_1.default.cyan("''")} instead of ${picocolors_1.default.cyan(String(templateVar))} to remove this warning.`), { onlyOnce: false });
             templateVar = '';
         }
         {

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

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

@@ -12,7 +12,7 @@ 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) {
         (0, utils_js_1.objectAssign)(pageContextFromOnBeforeRouteHook, pageContextFromHook);
         if ((0, utils_js_1.hasProp)(pageContextFromOnBeforeRouteHook, '_pageId', 'string') ||
@@ -37,11 +37,11 @@ async function executeOnBeforeRouteHook(pageContext) {
     return pageContextFromOnBeforeRouteHook;
 }
 exports.executeOnBeforeRouteHook = executeOnBeforeRouteHook;
-async function executeHook(onBeforeRouteHook, pageContext) {
-    let hookReturn = onBeforeRouteHook.onBeforeRoute(pageContext);
+async function getPageContextFromHook(onBeforeRouteHook, pageContext) {
+    let hookReturn = onBeforeRouteHook.hookFn(pageContext);
     (0, resolveRouteFunction_js_1.assertSyncRouting)(hookReturn, `The onBeforeRoute() hook ${onBeforeRouteHook.hookFilePath}`);
     // TODO/v1-release: make executeOnBeforeRouteHook() and route() sync
-    hookReturn = await hookReturn;
+    hookReturn = await (0, utils_js_1.executeHook)(() => hookReturn, onBeforeRouteHook);
     const errPrefix = `The onBeforeRoute() hook defined by ${onBeforeRouteHook.hookFilePath}`;
     (0, utils_js_1.assertUsage)(hookReturn === null ||
         hookReturn === undefined ||