vike 0.4.147 → 0.4.148-commit-7596dcd

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 ||

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

@@ -7,6 +7,7 @@ const deduceRouteStringFromFilesystemPath_js_1 = require("./deduceRouteStringFro
 const utils_js_2 = require("../utils.js");
 const helpers_js_1 = require("../page-configs/helpers.js");
 const resolveRouteFunction_js_1 = require("./resolveRouteFunction.js");
+const getHook_js_1 = require("../hooks/getHook.js");
 async function loadPageRoutes(
 // Remove all arguments and use GlobalContext instead?
 pageFilesAll, pageConfigs, pageConfigGlobal, allPageIds) {
@@ -139,20 +140,8 @@ function getPageRoutes(filesystemRoots, pageFilesAll, pageConfigs, allPageIds) {
 function getGlobalHooks(pageFilesAll, pageConfigs, pageConfigGlobal) {
     // V1 Design
     if (pageConfigs.length > 0) {
-        const hookName = 'onBeforeRoute';
-        if (pageConfigGlobal.configValues[hookName]?.value) {
-            const configValue = pageConfigGlobal.configValues[hookName];
-            const { value: hookFn } = configValue;
-            const hookFilePath = (0, helpers_js_1.getHookFilePathToShowToUser)(configValue);
-            const hookDefinedAt = (0, helpers_js_1.getConfigDefinedAtString)('Hook', hookName, configValue);
-            (0, utils_js_1.assertUsage)((0, utils_js_2.isCallable)(hookFn), `${hookDefinedAt} should be a function.`);
-            const onBeforeRouteHook = {
-                hookFilePath: hookFilePath,
-                onBeforeRoute: hookFn
-            };
-            return { onBeforeRouteHook, filesystemRoots: null };
-        }
-        return { onBeforeRouteHook: null, filesystemRoots: null };
+        const hook = (0, getHook_js_1.getHookFromPageConfigGlobal)(pageConfigGlobal, 'onBeforeRoute');
+        return { onBeforeRouteHook: hook, filesystemRoots: null };
     }
     // Old design
     // TODO/v1-release: remove
@@ -165,7 +154,13 @@ function getGlobalHooks(pageFilesAll, pageConfigs, pageConfigGlobal) {
         if ('onBeforeRoute' in fileExports) {
             (0, utils_js_1.assertUsage)((0, utils_js_1.hasProp)(fileExports, 'onBeforeRoute', 'function'), `\`export { onBeforeRoute }\` of ${filePath} should be a function.`);
             const { onBeforeRoute } = fileExports;
-            onBeforeRouteHook = { hookFilePath: `${filePath} > \`export { onBeforeRoute }\``, onBeforeRoute };
+            const hookName = 'onBeforeRoute';
+            onBeforeRouteHook = {
+                hookFilePath: filePath,
+                hookFn: onBeforeRoute,
+                hookName,
+                hookTimeout: (0, getHook_js_1.getHookTimeoutDefault)(hookName)
+            };
         }
         if ('filesystemRoutingRoot' in fileExports) {
             (0, utils_js_1.assertUsage)((0, utils_js_1.hasProp)(fileExports, 'filesystemRoutingRoot', 'string'), `\`export { filesystemRoutingRoot }\` of ${filePath} should be a string.`);

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

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveRouteStringRedirect = exports.resolveRedirects = void 0;
 const assertIsNotBrowser_js_1 = require("../../utils/assertIsNotBrowser.js");
+const parseUrl_extras_js_1 = require("../../utils/parseUrl-extras.js");
 const utils_js_1 = require("../utils.js");
 const resolveRouteString_js_1 = require("./resolveRouteString.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
@@ -23,9 +24,9 @@ exports.resolveRedirects = resolveRedirects;
 function resolveRouteStringRedirect(urlSource, urlTarget, urlPathname) {
     (0, resolveRouteString_js_1.assertRouteString)(urlSource, `${configSrc} Invalid`);
     (0, utils_js_1.assertUsage)(urlTarget.startsWith('/') ||
-        urlTarget.startsWith('http://') ||
-        urlTarget.startsWith('https://') ||
-        urlTarget === '*', `${configSrc} Invalid redirection target URL ${picocolors_1.default.cyan(urlTarget)}: the target URL should start with ${picocolors_1.default.cyan('/')}, ${picocolors_1.default.cyan('http://')}, ${picocolors_1.default.cyan('https://')}, or be ${picocolors_1.default.cyan('*')}`);
+        // Is allowing any protocol a safety issue? https://github.com/vikejs/vike/pull/1292#issuecomment-1828043917
+        (0, parseUrl_extras_js_1.isUriWithProtocol)(urlTarget) ||
+        urlTarget === '*', `${configSrc} Invalid redirection target URL ${picocolors_1.default.cyan(urlTarget)}: the target URL should start with ${picocolors_1.default.cyan('/')}, a valid protocol (${picocolors_1.default.cyan('https:')}, ${picocolors_1.default.cyan('http:')}, ${picocolors_1.default.cyan('ipfs:')}, ${picocolors_1.default.cyan('magnet:')}, ...), or be ${picocolors_1.default.cyan('*')}`);
     assertParams(urlSource, urlTarget);
     const match = (0, resolveRouteString_js_1.resolveRouteString)(urlSource, urlPathname);
     if (!match)
@@ -37,10 +38,12 @@ function resolveRouteStringRedirect(urlSource, urlTarget, urlPathname) {
         }
         urlResolved = urlResolved.replaceAll(key, val);
     });
-    (0, utils_js_1.assert)(!urlResolved.includes('@'));
+    if (!urlResolved.startsWith('mailto:')) {
+        (0, utils_js_1.assertUsage)(!urlResolved.includes('@'), 'URL should not contain "@" unless it is a mailto link.');
+    }
     if (urlResolved === urlPathname)
         return null;
-    (0, utils_js_1.assert)(urlTarget.startsWith('/') || urlTarget.startsWith('http'));
+    (0, utils_js_1.assert)(urlResolved.startsWith('/') || (0, parseUrl_extras_js_1.isUriWithProtocol)(urlResolved));
     return urlResolved;
 }
 exports.resolveRouteStringRedirect = resolveRouteStringRedirect;

package/dist/cjs/utils/parseUrl-extras.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.addUrlOrigin = exports.removeUrlOrigin = exports.modifyUrlPathname = exports.removeBaseServer = exports.normalizeUrlPathname = exports.isBaseAssets = exports.prependBase = void 0;
+exports.isUriWithProtocol = exports.addUrlOrigin = exports.removeUrlOrigin = exports.modifyUrlPathname = exports.removeBaseServer = exports.normalizeUrlPathname = exports.isBaseAssets = exports.prependBase = void 0;
 const parseUrl_js_1 = require("./parseUrl.js");
 const assert_js_1 = require("./assert.js");
 const slice_js_1 = require("./slice.js");
@@ -103,3 +103,8 @@ function addUrlOrigin(url, origin) {
     return urlModified;
 }
 exports.addUrlOrigin = addUrlOrigin;
+function isUriWithProtocol(uri) {
+    // https://en.wikipedia.org/wiki/List_of_URI_schemes
+    return /^[a-z0-9][a-z0-9\.\+\-]*:/i.test(uri);
+}
+exports.isUriWithProtocol = isUriWithProtocol;

package/dist/cjs/utils/parseUrl.js

@@ -55,7 +55,7 @@ function parseUrl(url, baseServer) {
         searchAll[key] = [...(searchAll.hasOwnProperty(key) ? searchAll[key] : []), val];
     });
     // Origin + pathname
-    const { origin, pathname: pathnameResolved } = parsePathname(urlWithoutHashNorSearch, baseServer);
+    const { origin, pathname: pathnameResolved } = getPathname(urlWithoutHashNorSearch, baseServer);
     (0, assert_js_1.assert)(origin === null || origin === decodeSafe(origin)); // AFAICT decoding the origin is useless
     (0, assert_js_1.assert)(pathnameResolved.startsWith('/'));
     (0, assert_js_1.assert)(origin === null || url.startsWith(origin));
@@ -91,35 +91,43 @@ function decodeSafe(urlComponent) {
     return urlComponent;
 }
 function decodePathname(urlPathname) {
+    urlPathname = urlPathname.replace(/\s+$/, '');
     urlPathname = urlPathname
         .split('/')
         .map((dir) => decodeSafe(dir).split('/').join('%2F'))
         .join('/');
-    urlPathname = urlPathname.replace(/\s/g, '');
     return urlPathname;
 }
-function parsePathname(urlWithoutHashNorSearch, baseServer) {
+function getPathname(url, baseServer) {
+    // Search and hash already extracted
+    (0, assert_js_1.assert)(!url.includes('?') && !url.includes('#'));
+    // url has origin
     {
-        const { origin, pathname } = parseOrigin(urlWithoutHashNorSearch);
+        const { origin, pathname } = parseOrigin(url);
         if (origin) {
             return { origin, pathname };
         }
-        (0, assert_js_1.assert)(pathname === urlWithoutHashNorSearch);
+        (0, assert_js_1.assert)(pathname === url);
     }
-    if (urlWithoutHashNorSearch.startsWith('/')) {
-        return { origin: null, pathname: urlWithoutHashNorSearch };
+    // url doesn't have origin
+    if (url.startsWith('/')) {
+        return { origin: null, pathname: url };
     }
     else {
-        // In the browser, this is the Base URL of the current URL
+        // url is a relative path
+        // In the browser, this is the Base URL of the current URL.
         // Safe access `window?.document?.baseURI` for users who shim `window` in Node.js
-        let baseURI = typeof window !== 'undefined' && window?.document?.baseURI;
-        if (baseURI)
-            baseURI = parseOrigin(baseURI).pathname;
-        const base = baseURI || baseServer;
-        const pathname = resolveUrlPathnameRelative(urlWithoutHashNorSearch, base);
-        // We need to parse the origin in case `base === window.document.baseURI`
-        const parsed = parseOrigin(pathname);
-        return parsed;
+        const baseURI = typeof window !== 'undefined' ? window?.document?.baseURI : undefined;
+        let base;
+        if (baseURI) {
+            const baseURIPathaname = parseOrigin(baseURI.split('?')[0]).pathname;
+            base = baseURIPathaname;
+        }
+        else {
+            base = baseServer;
+        }
+        const pathname = resolveUrlPathnameRelative(url, base);
+        return { origin: null, pathname };
     }
 }
 function parseOrigin(url) {

package/dist/cjs/utils/projectInfo.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PROJECT_VERSION = exports.projectInfo = void 0;
 const assertSingleInstance_js_1 = require("./assertSingleInstance.js");
-const PROJECT_VERSION = '0.4.147';
+const PROJECT_VERSION = '0.4.148-commit-7596dcd';
 exports.PROJECT_VERSION = PROJECT_VERSION;
 const projectInfo = {
     projectName: 'Vike',

package/dist/esm/client/client-routing-runtime/createPageContext.d.ts

@@ -11,7 +11,7 @@ declare function createPageContext(urlOriginal: string): Promise<{
     _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
     _allPageIds: string[];
     _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
-    _onBeforeRouteHook: import("../../shared/route/executeOnBeforeRouteHook.js").OnBeforeRouteHook | null;
+    _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
 } & import("../../shared/addUrlComputedProps.js").PageContextUrlComputedPropsClient & {
     _urlRewrite: string | null;
 }>;

package/dist/esm/client/client-routing-runtime/getPageContextFromHooks.js

@@ -27,7 +27,7 @@ async function getPageContextFromHooks_firstRender(pageContext) {
     objectAssign(pageContextFromHooks, await loadPageFilesClientSide(pageContextFromHooks._pageId, pageContext));
     {
         const pageContextForHook = { ...pageContext, ...pageContextFromHooks };
-        if (await onBeforeRenderClientOnlyExists(pageContextForHook)) {
+        if (onBeforeRenderClientOnlyExists(pageContextForHook)) {
             const pageContextFromHook = await executeOnBeforeRenderHookClientSide(pageContextForHook);
             objectAssign(pageContextFromHooks, pageContextFromHook);
         }
@@ -57,13 +57,17 @@ async function getPageContextFromHooks_uponNavigation(pageContext) {
 }
 async function getPageContextAlreadyRouted(pageContext, isErrorPage) {
     let pageContextFromHooks = {};
+    objectAssign(pageContextFromHooks, { _hasPageContextFromClient: false });
     objectAssign(pageContextFromHooks, await loadPageFilesClientSide(pageContext._pageId, pageContext));
+    let pageContextFetchedFromServer = false;
     // Needs to be called before any client-side hook, because it may contain pageContextInit.user which is needed for guard() and onBeforeRender()
     if (
     // For the error page, we cannot fetch pageContext from the server because the pageContext JSON request is based on the URL
     !isErrorPage &&
+        // true if pageContextInit has some client data or the onBeforeRender hook is server-side only:
         (await hasPageContextServer({ ...pageContext, ...pageContextFromHooks }))) {
         const pageContextFromServer = await fetchPageContextFromServer(pageContext);
+        pageContextFetchedFromServer = true;
         if (!pageContextFromServer['_isError']) {
             objectAssign(pageContextFromHooks, pageContextFromServer);
         }
@@ -72,6 +76,7 @@ async function getPageContextAlreadyRouted(pageContext, isErrorPage) {
             assert(errorPageId);
             pageContextFromHooks = {};
             objectAssign(pageContextFromHooks, {
+                _hasPageContextFromClient: false,
                 isHydration: false,
                 _pageId: errorPageId
             });
@@ -91,25 +96,29 @@ async function getPageContextAlreadyRouted(pageContext, isErrorPage) {
         if (!isErrorPage) {
             // Should we really call the guard() hook on the client-side? Shouldn't we make the guard() hook a server-side only hook? Or maybe make its env configurable like onBeforeRender()?
             await executeGuardHook({
-                _hasPageContextFromClient: false,
                 ...pageContext,
                 ...pageContextFromHooks
             }, (pageContext) => preparePageContextForUserConsumptionClientSide(pageContext, true));
         }
     }
+    // For the error page, we also execute the client-side onBeforeRender() hook, but maybe we shouldn't? The server-side does it as well (but maybe it shouldn't).
     {
-        // For the error page, we also execute the client-side onBeforeRender() hook, but maybe we shouldn't? The server-side does it as well (but maybe it shouldn't).
-        const pageContextFromOnBeforeRender = await executeOnBeforeRenderHookClientSide({
-            ...pageContext,
-            ...pageContextFromHooks
-        });
-        objectAssign(pageContextFromHooks, pageContextFromOnBeforeRender);
+        const pageContextForHook = { ...pageContext, ...pageContextFromHooks };
+        if (onBeforeRenderClientOnlyExists(pageContextForHook) || !pageContextFetchedFromServer) {
+            // This won't do anything if no hook has been defined or if the hook's env.client is false.
+            const pageContextFromHook = await executeOnBeforeRenderHookClientSide(pageContextForHook);
+            objectAssign(pageContextFromHooks, pageContextFromHook);
+        }
+        else {
+            assert(pageContextFetchedFromServer);
+        }
     }
     return pageContextFromHooks;
 }
 async function executeOnBeforeRenderHookClientSide(pageContext) {
     const hook = getHook(pageContext, 'onBeforeRender');
     if (!hook) {
+        // No hook defined or hook's env.client is false
         const pageContextFromOnBeforeRender = {
             _hasPageContextFromClient: false
         };
@@ -123,7 +132,7 @@ async function executeOnBeforeRenderHookClientSide(pageContext) {
         ...pageContext,
         ...pageContextFromOnBeforeRender
     }, true);
-    const hookResult = await executeHook(() => onBeforeRender(pageContextForUserConsumption), 'onBeforeRender', hook.hookFilePath);
+    const hookResult = await executeHook(() => onBeforeRender(pageContextForUserConsumption), hook);
     assertOnBeforeRenderHookReturn(hookResult, hook.hookFilePath);
     const pageContextFromHook = hookResult?.pageContext;
     objectAssign(pageContextFromOnBeforeRender, pageContextFromHook);
@@ -164,7 +173,7 @@ async function onBeforeRenderServerOnlyExists(pageContext) {
         return hasOnBeforeRenderServerSideOnlyHook;
     }
 }
-async function onBeforeRenderClientOnlyExists(pageContext) {
+function onBeforeRenderClientOnlyExists(pageContext) {
     if (pageContext._pageConfigs.length > 0) {
         // V1
         const pageConfig = getPageConfig(pageContext._pageId, pageContext._pageConfigs);
@@ -174,6 +183,7 @@ async function onBeforeRenderClientOnlyExists(pageContext) {
     }
     else {
         // TODO/v1-release: remove
+        // Client-only onBeforeRender() hooks were never supported for the V0.4 design
         return false;
     }
 }

package/dist/esm/client/client-routing-runtime/onBrowserHistoryNavigation.js

@@ -14,8 +14,8 @@ function onBrowserHistoryNavigation() {
     //     - By user clicking on a hash link `<a href="#some-hash" />`
     //       - The popstate event is *only* triggered if `href` starts with '#' (even if `href` is '/#some-hash' while the current URL's pathname is '/' then the popstate still isn't triggered)
     //     - By JavaScript: `location.hash = 'some-hash'`
-    // - The `event` of `window.addEventListener('popstate', (event) => /*...*/)` is useless: the History API doesn't provide the previous state (the popped state), see https://stackoverflow.com/questions/48055323/is-history-state-always-the-same-as-popstate-event-state
-    window.addEventListener('popstate', () => {
+    // - The `event` argument of `window.addEventListener('popstate', (event) => /*...*/)` is useless: the History API doesn't provide the previous state (the popped state), see https://stackoverflow.com/questions/48055323/is-history-state-always-the-same-as-popstate-event-state
+    window.addEventListener('popstate', (ev) => {
         const currentState = getState();
         const scrollTarget = currentState.historyState.scrollPosition || 'scroll-to-top-or-hash';
         const isUserLandPushStateNavigation = currentState.historyState.triggedBy === 'user';

package/dist/esm/client/client-routing-runtime/renderPageClientSide.js

@@ -7,7 +7,7 @@ import { createPageContext } from './createPageContext.js';
 import { addLinkPrefetchHandlers } from './prefetch.js';
 import { assertInfo, assertWarning, isReact } from './utils.js';
 import { executeOnRenderClientHook } from '../shared/executeOnRenderClientHook.js';
-import { assertHook } from '../../shared/hooks/getHook.js';
+import { assertHook, getHook } from '../../shared/hooks/getHook.js';
 import { isErrorFetchingStaticAssets } from '../shared/loadPageFilesClientSide.js';
 import { pushHistory } from './history.js';
 import { assertNoInfiniteAbortLoop, getPageContextFromAllRewrites, isAbortError, logAbortErrorHandled } from '../../shared/route/abort.js';
@@ -85,7 +85,11 @@ async function renderPageClientSide(renderArgs) {
     const callTransitionHooks = !isFirstRender;
     if (callTransitionHooks) {
         if (!globalObject.isTransitioning) {
-            await globalObject.onPageTransitionStart?.(pageContext);
+            if (globalObject.onPageTransitionStart) {
+                const hook = globalObject.onPageTransitionStart;
+                const { hookFn } = hook;
+                await executeHook(() => hookFn(pageContext), hook);
+            }
             globalObject.isTransitioning = true;
             if (abortRender())
                 return;
@@ -207,13 +211,14 @@ async function renderPageClientSide(renderArgs) {
     objectAssign(pageContext, pageContextFromHooks);
     // Set global onPageTransitionStart()
     assertHook(pageContext, 'onPageTransitionStart');
-    globalObject.onPageTransitionStart = pageContext.exports.onPageTransitionStart;
+    const onPageTransitionStartHook = getHook(pageContext, 'onPageTransitionStart');
+    globalObject.onPageTransitionStart = onPageTransitionStartHook;
     // Set global hydrationCanBeAborted
     if (pageContext.exports.hydrationCanBeAborted) {
         setHydrationCanBeAborted();
     }
     else {
-        assertWarning(!isReact(), 'You seem to be using React; we recommend setting hydrationCanBeAborted to true, see https://vike.dev/clientRouting', { onlyOnce: true });
+        assertWarning(!isReact(), 'You seem to be using React; we recommend setting hydrationCanBeAborted to true, see https://vike.dev/hydrationCanBeAborted', { onlyOnce: true });
     }
     // There wasn't any `await` but result may change because we just called setHydrationCanBeAborted()
     if (abortRender())
@@ -242,11 +247,10 @@ async function renderPageClientSide(renderArgs) {
     // onHydrationEnd()
     if (isFirstRender) {
         assertHook(pageContext, 'onHydrationEnd');
-        const { onHydrationEnd } = pageContext.exports;
-        if (onHydrationEnd) {
-            const hookFilePath = pageContext.exportsAll.onHydrationEnd[0].exportSource;
-            assert(hookFilePath);
-            await executeHook(() => onHydrationEnd(pageContext), 'onHydrationEnd', hookFilePath);
+        const hook = getHook(pageContext, 'onHydrationEnd');
+        if (hook) {
+            const { hookFn } = hook;
+            await executeHook(() => hookFn(pageContext), hook);
             if (abortRender(true))
                 return;
         }
@@ -256,9 +260,11 @@ async function renderPageClientSide(renderArgs) {
         return;
     // onPageTransitionEnd()
     if (callTransitionHooks) {
-        if (pageContext.exports.onPageTransitionEnd) {
-            assertHook(pageContext, 'onPageTransitionEnd');
-            await pageContext.exports.onPageTransitionEnd(pageContext);
+        assertHook(pageContext, 'onPageTransitionEnd');
+        const hook = getHook(pageContext, 'onPageTransitionEnd');
+        if (hook) {
+            const { hookFn } = hook;
+            await executeHook(() => hookFn(pageContext), hook);
             if (abortRender(true))
                 return;
         }

package/dist/esm/client/shared/executeOnRenderClientHook.js

@@ -45,7 +45,7 @@ async function executeOnRenderClientHook(pageContext, isClientRouting) {
     const renderHook = hook.hookFn;
     assert(hookName);
     // We don't use a try-catch wrapper because rendering errors are usually handled by the UI framework. (E.g. React's Error Boundaries.)
-    const hookResult = await executeHook(() => renderHook(pageContextForUserConsumption), hookName, hook.hookFilePath);
+    const hookResult = await executeHook(() => renderHook(pageContextForUserConsumption), hook);
     assertUsage(hookResult === undefined, `The ${hookName}() hook defined by ${hook.hookFilePath} isn't allowed to return a value`);
 }
 function getUrlToShowToUser(pageContext) {

package/dist/esm/client/shared/getPageContextSerializedInHtml.js

@@ -4,7 +4,7 @@ export { getPageContextSerializedInHtml };
 function getPageContextSerializedInHtml() {
     const id = 'vike_pageContext';
     const elem = document.getElementById(id);
-    assertUsage(elem, `The element #${id} (which vike automatically injects into the HTML) is missing from the DOM. This may happen if your HTML is malformed. Make sure your HTML isn't malformed, and make sure you don't remove #${id} from the HTML nor from the DOM.`);
+    assertUsage(elem, `The element #${id} (which Vike automatically injects into the HTML) is missing from the DOM. This may happen if your HTML is malformed. Make sure your HTML isn't malformed, and make sure you don't remove #${id} from the HTML nor from the DOM.`);
     const pageContextJson = elem.textContent;
     assert(pageContextJson);
     const pageContextSerializedInHtml = parse(pageContextJson);

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

@@ -1,7 +1,7 @@
 export { getConfigValuesSerialized };
 export { assertConfigValueIsSerializable };
 import { assert, assertUsage, getPropAccessNotation } from '../../../utils.js';
-import { isJsonSerializerError, stringify } from '@brillout/json-serializer/stringify';
+import { stringify } from '@brillout/json-serializer/stringify';
 import pc from '@brillout/picocolors';
 import { getConfigValueFilePathToShowToUser } from '../../../../../shared/page-configs/helpers.js';
 import { serializeConfigValue } from '../../../../../shared/page-configs/serialize/serializeConfigValue.js';
@@ -47,22 +47,27 @@ function getConfigValueSerialized(value, configName, definedAt) {
         configValueSerialized = stringify(value, { valueName, forbidReactElements: true });
     }
     catch (err) {
-        let serializationErrMsg = '';
+        /*
+        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';
+          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 = getConfigValueFilePathToShowToUser({ definedAt });
         assert(configValueFilePathToShowToUser);
         assertUsage(false, [
-            `The value of the config ${pc.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 ${pc.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/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/configDefinitionsBuiltIn.js

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

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/crawlPlusFiles.d.ts

@@ -0,0 +1,5 @@
+export { crawlPlusFiles };
+declare function crawlPlusFiles(userRootDir: string, outDirAbsoluteFilesystem: string, isDev: boolean): Promise<{
+    filePathRelativeToUserRootDir: string;
+    filePathAbsoluteFilesystem: string;
+}[]>;

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

@@ -0,0 +1,110 @@
+export { crawlPlusFiles };
+import { assertPosixPath, assert, toPosixPath, assertWarning, scriptFileExtensionList, scriptFileExtensions } from '../../../../utils.js';
+import path from 'path';
+import glob from 'fast-glob';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+const execA = promisify(exec);
+async function crawlPlusFiles(userRootDir, outDirAbsoluteFilesystem, isDev) {
+    assertPosixPath(userRootDir);
+    assertPosixPath(outDirAbsoluteFilesystem);
+    assert(outDirAbsoluteFilesystem.startsWith(userRootDir));
+    const outDir = path.posix.relative(userRootDir, outDirAbsoluteFilesystem);
+    assert(!outDir.startsWith('.'));
+    const timeBase = new Date().getTime();
+    let files = [];
+    const res = await gitLsFiles(userRootDir, outDir);
+    if (res &&
+        // Fallback to fast-glob for users that dynamically generate plus files (we assume generetad plus files to be skipped because they are usually included in .gitignore)
+        res.length > 0) {
+        files = res;
+    }
+    else {
+        files = await fastGlob(userRootDir, outDir);
+    }
+    {
+        const time = new Date().getTime() - timeBase;
+        if (isDev) {
+            // We only warn in dev, because while building it's expected to take a long time as fast-glob is competing for resources with other tasks
+            assertWarning(time < 2 * 1000, `Crawling your user files took an unexpected long time (${time}ms). Create a new issue on Vike's GitHub.`, {
+                onlyOnce: 'slow-page-files-search'
+            });
+        }
+    }
+    const plusFiles = files.map((p) => {
+        p = toPosixPath(p);
+        assert(!p.startsWith(userRootDir));
+        const filePathRelativeToUserRootDir = path.posix.join('/', p);
+        const filePathAbsoluteFilesystem = path.posix.join(userRootDir, p);
+        return {
+            filePathRelativeToUserRootDir,
+            filePathAbsoluteFilesystem
+        };
+    });
+    return plusFiles;
+}
+// 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;
+        }
+        assert(stdout.startsWith('git version '));
+    }
+    const cmd = [
+        'git ls-files',
+        ...scriptFileExtensionList.map((ext) => `"**/+*.${ext}"`),
+        ...getIgnorePatterns(outDir).map((pattern) => `--exclude="${pattern}"`),
+        // --others lists untracked files only (but using .gitignore because --exclude-standard)
+        // --cached adds the tracked files to the output
+        '--others --cached --exclude-standard'
+    ].join(' ');
+    let stdout;
+    try {
+        const res = await execA(cmd, { cwd: userRootDir });
+        stdout = res.stdout;
+    }
+    catch (err) {
+        if (err.message.includes('not a git repository'))
+            return null;
+        throw err;
+    }
+    let files = stdout.split('\n').filter(Boolean);
+    assert(!outDir.startsWith('/'));
+    files = files.filter(
+    // We have to repeat the same exclusion logic here because the `git ls-files` option --exclude only applies to untracked files. (We use --exclude only to speed up the command.)
+    (file) => getIgnoreFilter(file, outDir));
+    return files;
+}
+// Same as gitLsFiles() but using fast-glob
+async function fastGlob(userRootDir, outDir) {
+    const files = await glob(`**/+*.${scriptFileExtensions}`, {
+        ignore: getIgnorePatterns(outDir),
+        cwd: userRootDir,
+        dot: false
+    });
+    return files;
+}
+// Same as getIgnoreFilter() but as glob pattern
+function getIgnorePatterns(outDir) {
+    return [
+        '**/node_modules/**',
+        `${outDir}/**`,
+        // Allow:
+        // ```
+        // +Page.js
+        // +Page.telefunc.js
+        // ```
+        '**/*.telefunc.*'
+    ];
+}
+// Same as getIgnorePatterns() but for Array.filter()
+function getIgnoreFilter(file, outDir) {
+    return !file.includes('node_modules/') && !file.includes('.telefunc.') && !file.startsWith(`${outDir}/`);
+}