vike 0.4.232-commit-134207d → 0.4.232-commit-1690f53

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

@@ -67,6 +67,7 @@ const getOutDirs_js_1 = require("../vite/shared/getOutDirs.js");
 const node_fs_1 = __importDefault(require("node:fs"));
 const getProxyForPublicUsage_js_1 = require("../../shared/getProxyForPublicUsage.js");
 const resolveRedirects_js_1 = require("../runtime/renderPage/resolveRedirects.js");
+const utils_js_2 = require("../runtime/utils.js");
 const docLink = 'https://vike.dev/i18n#pre-rendering';
 async function runPrerender(options = {}, trigger) {
     (0, context_js_1.setWasPrerenderRun)(trigger);
@@ -253,7 +254,7 @@ async function callOnBeforePrerenderStartHooks(prerenderContext, globalContext,
         if (doNotPrerenderList.find((p) => p.pageId === pageId))
             return;
         const { hookName, hookFilePath } = hook;
-        const prerenderResult = await (0, execHook_js_1.execHookWithoutPageContext)(() => hook.hookFn(), hook);
+        const prerenderResult = await (0, execHook_js_1.execHookDirectWithoutPageContext)(() => hook.hookFn(), hook);
         const result = normalizeOnPrerenderHookResult(prerenderResult, hookFilePath, hookName);
         // Handle result
         await Promise.all(result.map(async ({ url, pageContext }) => {
@@ -360,7 +361,7 @@ async function createPageContextPrerendering(urlOriginal, prerenderContext, glob
             routeParams: {},
         });
     }
-    (0, utils_js_1.objectAssign)(pageContext, await (0, loadPageConfigsLazyServerSide_js_1.loadPageConfigsLazyServerSide)(pageContext));
+    (0, utils_js_2.augmentType)(pageContext, await (0, loadPageConfigsLazyServerSide_js_1.loadPageConfigsLazyServerSideAndExecHook)(pageContext));
     let usesClientRouter;
     {
         const { pageId } = pageContext;
@@ -481,7 +482,7 @@ async function callOnPrerenderStartHook(prerenderContext, globalContext, concurr
         (0, utils_js_1.preservePropertyGetters)(pageContext);
     });
     const prerenderContextPublic = preparePrerenderContextForPublicUsage(prerenderContext);
-    let result = await (0, execHook_js_1.execHookWithoutPageContext)(() => hookFn(prerenderContextPublic), onPrerenderStartHook);
+    let result = await (0, execHook_js_1.execHookDirectWithoutPageContext)(() => hookFn(prerenderContextPublic), onPrerenderStartHook);
     // Before applying result
     prerenderContext.pageContexts.forEach((pageContext) => {
         ;

package/dist/cjs/node/runtime/renderPage/{executeOnBeforeRenderAndDataHooks.js → execHookDataAndOnBeforeRender.js}

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.executeOnBeforeRenderAndDataHooks = executeOnBeforeRenderAndDataHooks;
+exports.execHookDataAndOnBeforeRender = execHookDataAndOnBeforeRender;
 const assertOnBeforeRenderHookReturn_js_1 = require("../../../shared/assertOnBeforeRenderHookReturn.js");
 const execHookServer_js_1 = require("./execHookServer.js");
-async function executeOnBeforeRenderAndDataHooks(pageContext) {
+async function execHookDataAndOnBeforeRender(pageContext) {
     if (pageContext._pageContextAlreadyProvidedByOnPrerenderHook) {
         return;
     }

package/dist/cjs/node/runtime/renderPage/{executeOnRenderHtmlHook.js → execHookOnRenderHtml.js}

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.executeOnRenderHtmlHook = executeOnRenderHtmlHook;
+exports.execHookOnRenderHtml = execHookOnRenderHtml;
 const renderHtml_js_1 = require("../html/renderHtml.js");
 const getHook_js_1 = require("../../../shared/hooks/getHook.js");
 const utils_js_1 = require("../utils.js");
@@ -14,10 +14,10 @@ const assertHookReturnedObject_js_1 = require("../../../shared/assertHookReturne
 const loggerRuntime_js_1 = require("../loggerRuntime.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const execHook_js_1 = require("../../../shared/hooks/execHook.js");
-async function executeOnRenderHtmlHook(pageContext) {
+async function execHookOnRenderHtml(pageContext) {
     const hook = getRenderHook(pageContext);
     (0, utils_js_1.objectAssign)(pageContext, { _renderHook: hook });
-    const { hookReturn } = await (0, execHook_js_1.execHookSingleWithReturn)(hook, pageContext, preparePageContextForPublicUsageServer_js_1.preparePageContextForPublicUsageServer);
+    const { hookReturn } = await (0, execHook_js_1.execHookDirectSingleWithReturn)(hook, pageContext, preparePageContextForPublicUsageServer_js_1.preparePageContextForPublicUsageServer);
     const { documentHtml, pageContextProvidedByRenderHook, pageContextPromise, injectFilter } = processHookReturnValue(hookReturn, hook);
     Object.assign(pageContext, pageContextProvidedByRenderHook);
     (0, utils_js_1.objectAssign)(pageContext, { _pageContextPromise: pageContextPromise });

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadPageConfigsLazyServerSide = loadPageConfigsLazyServerSide;
+exports.loadPageConfigsLazyServerSideAndExecHook = loadPageConfigsLazyServerSideAndExecHook;
 const getPageFiles_js_1 = require("../../../shared/getPageFiles.js");
 const resolveVikeConfigPublic_js_1 = require("../../../shared/page-configs/resolveVikeConfigPublic.js");
 const analyzePageClientSide_js_1 = require("../../../shared/getPageFiles/analyzePageClientSide.js");
@@ -10,6 +10,13 @@ const debugPageFiles_js_1 = require("./debugPageFiles.js");
 const findPageConfig_js_1 = require("../../../shared/page-configs/findPageConfig.js");
 const analyzePage_js_1 = require("./analyzePage.js");
 const loadConfigValues_js_1 = require("../../../shared/page-configs/loadConfigValues.js");
+const execHookServer_js_1 = require("./execHookServer.js");
+async function loadPageConfigsLazyServerSideAndExecHook(pageContext) {
+    const pageContextAddendum = await loadPageConfigsLazyServerSide(pageContext);
+    (0, utils_js_1.objectAssign)(pageContext, pageContextAddendum);
+    await (0, execHookServer_js_1.execHookServer)('onCreatePageContext', pageContext);
+    return pageContext;
+}
 async function loadPageConfigsLazyServerSide(pageContext) {
     const pageConfig = (0, findPageConfig_js_1.findPageConfig)(pageContext._globalContext._pageConfigs, pageContext.pageId); // Make pageConfig globally available as pageContext._pageConfig ?
     const globalContext = pageContext._globalContext;
@@ -86,18 +93,16 @@ async function loadPageConfigsLazyServerSide(pageContext) {
             return pageAssetsOldFormat;
         },
     });
-    {
-        (0, debugPageFiles_js_1.debugPageFiles)({
-            pageContext,
-            isHtmlOnly,
-            isClientRouting,
-            pageFilesLoaded,
-            pageFilesClientSide,
-            pageFilesServerSide,
-            clientEntries,
-            clientDependencies,
-        });
-    }
+    (0, debugPageFiles_js_1.debugPageFiles)({
+        pageContext,
+        isHtmlOnly,
+        isClientRouting,
+        pageFilesLoaded,
+        pageFilesClientSide,
+        pageFilesServerSide,
+        clientEntries,
+        clientDependencies,
+    });
     return pageContextAddendum;
 }
 async function loadPageUserFiles(pageFilesAll, pageConfig, pageConfigGlobal, pageId, isDev) {

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

@@ -11,12 +11,12 @@ const utils_js_1 = require("../utils.js");
 const serializeContext_js_1 = require("../html/serializeContext.js");
 const createHttpResponse_js_1 = require("./createHttpResponse.js");
 const loadPageConfigsLazyServerSide_js_1 = require("./loadPageConfigsLazyServerSide.js");
-const executeOnRenderHtmlHook_js_1 = require("./executeOnRenderHtmlHook.js");
-const executeOnBeforeRenderAndDataHooks_js_1 = require("./executeOnBeforeRenderAndDataHooks.js");
+const execHookOnRenderHtml_js_1 = require("./execHookOnRenderHtml.js");
+const execHookDataAndOnBeforeRender_js_1 = require("./execHookDataAndOnBeforeRender.js");
 const loggerRuntime_js_1 = require("../loggerRuntime.js");
 const isNewError_js_1 = require("./isNewError.js");
 const preparePageContextForPublicUsageServer_js_1 = require("./preparePageContextForPublicUsageServer.js");
-const executeGuardHook_js_1 = require("../../../shared/route/executeGuardHook.js");
+const execHookGuard_js_1 = require("../../../shared/route/execHookGuard.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const isServerSideError_js_1 = require("../../../shared/misc/isServerSideError.js");
 async function renderPageAlreadyRouted(pageContext) {
@@ -28,16 +28,16 @@ async function renderPageAlreadyRouted(pageContext) {
     (0, utils_js_1.assert)(isError ===
         (pageContext.pageId ===
             (0, error_page_js_1.getErrorPageId)(pageContext._globalContext._pageFilesAll, pageContext._globalContext._pageConfigs)));
-    (0, utils_js_1.objectAssign)(pageContext, await (0, loadPageConfigsLazyServerSide_js_1.loadPageConfigsLazyServerSide)(pageContext));
+    (0, utils_js_1.augmentType)(pageContext, await (0, loadPageConfigsLazyServerSide_js_1.loadPageConfigsLazyServerSideAndExecHook)(pageContext));
     if (!isError) {
-        await (0, executeGuardHook_js_1.executeGuardHook)(pageContext, (pageContext) => (0, preparePageContextForPublicUsageServer_js_1.preparePageContextForPublicUsageServer)(pageContext));
+        await (0, execHookGuard_js_1.execHookGuard)(pageContext, (pageContext) => (0, preparePageContextForPublicUsageServer_js_1.preparePageContextForPublicUsageServer)(pageContext));
     }
     if (!isError) {
-        await (0, executeOnBeforeRenderAndDataHooks_js_1.executeOnBeforeRenderAndDataHooks)(pageContext);
+        await (0, execHookDataAndOnBeforeRender_js_1.execHookDataAndOnBeforeRender)(pageContext);
     }
     else {
         try {
-            await (0, executeOnBeforeRenderAndDataHooks_js_1.executeOnBeforeRenderAndDataHooks)(pageContext);
+            await (0, execHookDataAndOnBeforeRender_js_1.execHookDataAndOnBeforeRender)(pageContext);
         }
         catch (err) {
             if ((0, isNewError_js_1.isNewError)(err, pageContext.errorWhileRendering)) {
@@ -54,7 +54,7 @@ async function renderPageAlreadyRouted(pageContext) {
         (0, utils_js_1.objectAssign)(pageContext, { httpResponse });
         return pageContext;
     }
-    const renderHookResult = await (0, executeOnRenderHtmlHook_js_1.executeOnRenderHtmlHook)(pageContext);
+    const renderHookResult = await (0, execHookOnRenderHtml_js_1.execHookOnRenderHtml)(pageContext);
     const { htmlRender, renderHook } = renderHookResult;
     const httpResponse = await (0, createHttpResponse_js_1.createHttpResponsePage)(htmlRender, renderHook, pageContext);
     (0, utils_js_1.objectAssign)(pageContext, { httpResponse });
@@ -67,10 +67,10 @@ async function prerenderPage(pageContext) {
     });
     /* Should we execute the guard() hook upon pre-rendering? Is there a use case for this?
      *  - It isn't trivial to implement, as it requires to duplicate / factor out the isAbortError() handling
-    await executeGuardHook(pageContext, (pageContext) => preparePageContextForPublicUsageServer(pageContext))
+    await execHookGuard(pageContext, (pageContext) => preparePageContextForPublicUsageServer(pageContext))
     */
-    await (0, executeOnBeforeRenderAndDataHooks_js_1.executeOnBeforeRenderAndDataHooks)(pageContext);
-    const { htmlRender, renderHook } = await (0, executeOnRenderHtmlHook_js_1.executeOnRenderHtmlHook)(pageContext);
+    await (0, execHookDataAndOnBeforeRender_js_1.execHookDataAndOnBeforeRender)(pageContext);
+    const { htmlRender, renderHook } = await (0, execHookOnRenderHtml_js_1.execHookOnRenderHtml)(pageContext);
     (0, utils_js_1.assertUsage)(htmlRender !== null, `Cannot pre-render ${picocolors_1.default.cyan(pageContext.urlOriginal)} because the ${renderHook.hookName}() hook defined by ${renderHook.hookFilePath} didn't return an HTML string.`);
     (0, utils_js_1.assert)(pageContext.isClientSideNavigation === false);
     const documentHtml = await (0, renderHtml_js_1.getHtmlString)(htmlRender);

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

@@ -143,59 +143,66 @@ async function renderPageAlreadyPrepared(pageContextBegin, globalContext, httpRe
     else {
         (0, utils_js_1.assert)(errNominalPage);
         (0, utils_js_1.assert)(pageContextNominalPageSuccess === undefined);
-        (0, utils_js_1.assert)(pageContextNominalPageBegin);
-        (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageContextNominalPageBegin, 'urlOriginal', 'string'));
-        const pageContextErrorPageInit = await getPageContextErrorPageInit(pageContextBegin, errNominalPage, pageContextNominalPageBegin);
-        // Handle `throw redirect()` and `throw render()` while rendering nominal page
-        if ((0, abort_js_1.isAbortError)(errNominalPage)) {
-            const handled = await handleAbortError(errNominalPage, pageContextsFromRewrite, pageContextBegin, pageContextNominalPageBegin, httpRequestId, pageContextErrorPageInit, globalContext);
-            if (handled.pageContextReturn) {
-                // - throw redirect()
-                // - throw render(url)
-                // - throw render(abortStatusCode) if .pageContext.json request
-                return handled.pageContextReturn;
-            }
-            else {
-                // - throw render(abortStatusCode) if not .pageContext.json request
-            }
-            Object.assign(pageContextErrorPageInit, handled.pageContextAbort);
+        return await renderPageOnError(errNominalPage, pageContextBegin, pageContextNominalPageBegin, globalContext, httpRequestId, pageContextsFromRewrite);
+    }
+}
+// When the normal page threw an error
+// - Can be a URL rewrite upon `throw render('/some-url')`
+// - Can be rendering the error page
+// - Can be rendering Vike's generic error page (if no error page is defined, or if the error page throws an error)
+async function renderPageOnError(errNominalPage, pageContextBegin, pageContextNominalPageBegin, globalContext, httpRequestId, pageContextsFromRewrite) {
+    (0, utils_js_1.assert)(pageContextNominalPageBegin);
+    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageContextNominalPageBegin, 'urlOriginal', 'string'));
+    const pageContextErrorPageInit = await getPageContextErrorPageInit(pageContextBegin, errNominalPage, pageContextNominalPageBegin);
+    // Handle `throw redirect()` and `throw render()` while rendering nominal page
+    if ((0, abort_js_1.isAbortError)(errNominalPage)) {
+        const handled = await handleAbortError(errNominalPage, pageContextsFromRewrite, pageContextBegin, pageContextNominalPageBegin, httpRequestId, pageContextErrorPageInit, globalContext);
+        if (handled.pageContextReturn) {
+            // - throw redirect()
+            // - throw render(url)
+            // - throw render(abortStatusCode) if .pageContext.json request
+            return handled.pageContextReturn;
         }
-        {
-            const errorPageId = (0, error_page_js_1.getErrorPageId)(globalContext._pageFilesAll, globalContext._pageConfigs);
-            if (!errorPageId) {
-                (0, utils_js_1.objectAssign)(pageContextErrorPageInit, { pageId: null });
-                return (0, handleErrorWithoutErrorPage_js_1.handleErrorWithoutErrorPage)(pageContextErrorPageInit);
-            }
-            else {
-                (0, utils_js_1.objectAssign)(pageContextErrorPageInit, { pageId: errorPageId });
-            }
+        else {
+            // - throw render(abortStatusCode) if not .pageContext.json request
         }
-        let pageContextErrorPage;
-        try {
-            pageContextErrorPage = await (0, renderPageAlreadyRouted_js_1.renderPageAlreadyRouted)(pageContextErrorPageInit);
+        Object.assign(pageContextErrorPageInit, handled.pageContextAbort);
+    }
+    {
+        const errorPageId = (0, error_page_js_1.getErrorPageId)(globalContext._pageFilesAll, globalContext._pageConfigs);
+        if (!errorPageId) {
+            (0, utils_js_1.objectAssign)(pageContextErrorPageInit, { pageId: null });
+            return (0, handleErrorWithoutErrorPage_js_1.handleErrorWithoutErrorPage)(pageContextErrorPageInit);
         }
-        catch (errErrorPage) {
-            // Handle `throw redirect()` and `throw render()` while rendering error page
-            if ((0, abort_js_1.isAbortError)(errErrorPage)) {
-                const handled = await handleAbortError(errErrorPage, pageContextsFromRewrite, pageContextBegin, pageContextNominalPageBegin, httpRequestId, pageContextErrorPageInit, globalContext);
-                // throw render(abortStatusCode)
-                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 pageContextHttpWithError = getPageContextHttpResponseError(errNominalPage, pageContextBegin);
-                    return pageContextHttpWithError;
-                }
-                // `throw redirect()` / `throw render(url)`
-                return handled.pageContextReturn;
-            }
-            if ((0, isNewError_js_1.isNewError)(errErrorPage, errNominalPage)) {
-                (0, loggerRuntime_js_1.logRuntimeError)(errErrorPage, httpRequestId);
+        else {
+            (0, utils_js_1.objectAssign)(pageContextErrorPageInit, { pageId: errorPageId });
+        }
+    }
+    let pageContextErrorPage;
+    try {
+        pageContextErrorPage = await (0, renderPageAlreadyRouted_js_1.renderPageAlreadyRouted)(pageContextErrorPageInit);
+    }
+    catch (errErrorPage) {
+        // Handle `throw redirect()` and `throw render()` while rendering error page
+        if ((0, abort_js_1.isAbortError)(errErrorPage)) {
+            const handled = await handleAbortError(errErrorPage, pageContextsFromRewrite, pageContextBegin, pageContextNominalPageBegin, httpRequestId, pageContextErrorPageInit, globalContext);
+            // throw render(abortStatusCode)
+            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 pageContextHttpWithError = getPageContextHttpResponseError(errNominalPage, pageContextBegin);
+                return pageContextHttpWithError;
             }
-            const pageContextWithError = getPageContextHttpResponseError(errNominalPage, pageContextBegin);
-            return pageContextWithError;
+            // `throw redirect()` / `throw render(url)`
+            return handled.pageContextReturn;
         }
-        return pageContextErrorPage;
+        if ((0, isNewError_js_1.isNewError)(errErrorPage, errNominalPage)) {
+            (0, loggerRuntime_js_1.logRuntimeError)(errErrorPage, httpRequestId);
+        }
+        const pageContextWithError = getPageContextHttpResponseError(errNominalPage, pageContextBegin);
+        return pageContextWithError;
     }
+    return pageContextErrorPage;
 }
 function logHttpRequest(urlOriginal, httpRequestId) {
     (0, loggerRuntime_js_1.logRuntimeInfo)?.(getRequestInfoMessage(urlOriginal), httpRequestId, 'info');
@@ -417,7 +424,7 @@ pageContextNominalPageBegin, httpRequestId, pageContextErrorPageInit, globalCont
             (0, utils_js_1.objectAssign)(pageContext, { pageId: errorPageId });
             (0, utils_js_1.objectAssign)(pageContext, pageContextAbort);
             (0, utils_js_1.objectAssign)(pageContext, pageContextErrorPageInit, true);
-            (0, utils_js_1.objectAssign)(pageContext, await (0, loadPageConfigsLazyServerSide_js_1.loadPageConfigsLazyServerSide)(pageContext));
+            (0, utils_js_1.augmentType)(pageContext, await (0, loadPageConfigsLazyServerSide_js_1.loadPageConfigsLazyServerSideAndExecHook)(pageContext));
             // We include pageContextInit: we don't only serialize pageContextAbort because the error page may need to access pageContextInit
             pageContextSerialized = (0, serializeContext_js_1.getPageContextClientSerialized)(pageContext);
         }

package/dist/cjs/node/vite/shared/resolveVikeConfigInternal/configDefinitionsBuiltIn.js

@@ -21,8 +21,6 @@ const configDefinitionsBuiltIn = {
     },
     onCreatePageContext: {
         env: { server: true, client: true },
-        // Required because `onCreatePageContext()` is called before routing
-        global: true,
         cumulative: true,
     },
     onCreateGlobalContext: {

package/dist/cjs/shared/createPageContextShared.js

@@ -2,12 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createPageContextShared = createPageContextShared;
 exports.createPageContextObject = createPageContextObject;
-const execHook_js_1 = require("./hooks/execHook.js");
-const preparePageContextForPublicUsage_js_1 = require("./preparePageContextForPublicUsage.js");
 const utils_js_1 = require("./utils.js");
+// TODO/now: make this and parents sync
 async function createPageContextShared(pageContextCreated, pageConfigGlobal, vikeConfigPublicGlobal) {
     (0, utils_js_1.objectAssign)(pageContextCreated, vikeConfigPublicGlobal);
-    await (0, execHook_js_1.execHookGlobal)('onCreatePageContext', pageConfigGlobal, pageContextCreated, pageContextCreated, preparePageContextForPublicUsage_js_1.preparePageContextForPublicUsage);
     return pageContextCreated;
 }
 function createPageContextObject() {

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

@@ -1,13 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.execHook = execHook;
-exports.execHookSingle = execHookSingle;
-exports.execHookSingleWithReturn = execHookSingleWithReturn;
-exports.execHookErrorHandling = execHookErrorHandling;
-exports.execHooksErrorHandling = execHooksErrorHandling;
-exports.execHookWithoutPageContext = execHookWithoutPageContext;
 exports.execHookGlobal = execHookGlobal;
-exports.execHookSync = execHookSync;
+exports.execHookDirect = execHookDirect;
+exports.execHookDirectSingle = execHookDirectSingle;
+exports.execHookDirectSingleWithReturn = execHookDirectSingleWithReturn;
+exports.execHookDirectWithoutPageContext = execHookDirectWithoutPageContext;
+exports.execHookDirectSync = execHookDirectSync;
 exports.getPageContext = getPageContext;
 exports.providePageContext = providePageContext;
 exports.isUserHookError = isUserHookError;
@@ -21,70 +20,48 @@ const globalObject = (0, getGlobalObject_js_1.getGlobalObject)('utils/execHook.t
     userHookErrors: new WeakMap(),
     pageContext: null,
 });
-async function execHookSingle(hook, pageContext, preparePageContextForPublicUsage) {
-    const res = await execHooksErrorHandling([hook], pageContext, preparePageContextForPublicUsage);
-    if ('err' in res)
-        throw res.err;
-    const { hookReturn } = res.hooks[0];
-    (0, assert_js_1.assertUsage)(hookReturn === undefined, `The ${hook.hookName}() hook defined by ${hook.hookFilePath} isn't allowed to return a value`);
-}
-async function execHookSingleWithReturn(hook, pageContext, preparePageContextForPublicUsage) {
-    const res = await execHooksErrorHandling([hook], pageContext, preparePageContextForPublicUsage);
-    if ('err' in res)
-        throw res.err;
-    const { hookReturn } = res.hooks[0];
-    return { hookReturn };
-}
 async function execHook(hookName, pageContext, preparePageContextForPublicUsage) {
-    const res = await execHookErrorHandling(hookName, pageContext, preparePageContextForPublicUsage);
-    if ('err' in res)
-        throw res.err;
-    return res.hooks;
-}
-async function execHookErrorHandling(hookName, pageContext, preparePageContextForPublicUsage) {
     const hooks = (0, getHook_js_1.getHookFromPageContextNew)(hookName, pageContext);
-    return execHooksErrorHandling(hooks, pageContext, preparePageContextForPublicUsage);
-}
-async function execHooksErrorHandling(hooks, pageContext, preparePageContextForPublicUsage) {
-    if (!hooks.length)
-        return { hooks: [] };
-    const pageContextForPublicUsage = preparePageContextForPublicUsage(pageContext);
-    let hooksWithResult;
-    let err;
-    try {
-        hooksWithResult = await Promise.all(hooks.map(async (hook) => {
-            const hookReturn = await execHookAsync(() => hook.hookFn(pageContextForPublicUsage), hook, pageContextForPublicUsage);
-            return { ...hook, hookReturn };
-        }));
-    }
-    catch (err_) {
-        err = err_;
-    }
-    if (hooksWithResult) {
-        return { hooks: hooksWithResult };
-    }
-    else {
-        return { hooks, err };
-    }
+    return await execHookDirect(hooks, pageContext, preparePageContextForPublicUsage);
 }
 async function execHookGlobal(hookName, pageConfigGlobal, pageContext, hookArg, prepareForPublicUsage) {
     const hooks = (0, getHook_js_1.getHookFromPageConfigGlobalCumulative)(pageConfigGlobal, hookName);
     const hookArgForPublicUsage = prepareForPublicUsage(hookArg);
     await Promise.all(hooks.map(async (hook) => {
-        await execHookAsync(() => hook.hookFn(hookArgForPublicUsage), hook, pageContext);
+        await execHookDirectAsync(() => hook.hookFn(hookArgForPublicUsage), hook, pageContext);
     }));
 }
+async function execHookDirect(hooks, pageContext, preparePageContextForPublicUsage) {
+    if (!hooks.length)
+        return [];
+    const pageContextForPublicUsage = preparePageContextForPublicUsage(pageContext);
+    const hooksWithResult = await Promise.all(hooks.map(async (hook) => {
+        const hookReturn = await execHookDirectAsync(() => hook.hookFn(pageContextForPublicUsage), hook, pageContextForPublicUsage);
+        return { ...hook, hookReturn };
+    }));
+    return hooksWithResult;
+}
+async function execHookDirectSingle(hook, pageContext, preparePageContextForPublicUsage) {
+    const hooksWithResult = await execHookDirect([hook], pageContext, preparePageContextForPublicUsage);
+    const { hookReturn } = hooksWithResult[0];
+    (0, assert_js_1.assertUsage)(hookReturn === undefined, `The ${hook.hookName}() hook defined by ${hook.hookFilePath} isn't allowed to return a value`);
+}
+async function execHookDirectSingleWithReturn(hook, pageContext, preparePageContextForPublicUsage) {
+    const hooksWithResult = await execHookDirect([hook], pageContext, preparePageContextForPublicUsage);
+    const { hookReturn } = hooksWithResult[0];
+    return { hookReturn };
+}
 function isUserHookError(err) {
     if (!(0, isObject_js_1.isObject)(err))
         return false;
     return globalObject.userHookErrors.get(err) ?? false;
 }
-async function execHookWithoutPageContext(hookFnCaller, hook) {
+async function execHookDirectWithoutPageContext(hookFnCaller, hook) {
     const { hookName, hookFilePath, hookTimeout } = hook;
-    const hookReturn = await execHookAsync(hookFnCaller, { hookName, hookFilePath, hookTimeout }, null);
+    const hookReturn = await execHookDirectAsync(hookFnCaller, { hookName, hookFilePath, hookTimeout }, null);
     return hookReturn;
 }
-function execHookAsync(hookFnCaller, hook, pageContextForPublicUsage) {
+function execHookDirectAsync(hookFnCaller, hook, pageContextForPublicUsage) {
     const { hookName, hookFilePath, hookTimeout: { error: timeoutErr, warning: timeoutWarn }, } = hook;
     let resolve;
     let reject;
@@ -128,7 +105,7 @@ function execHookAsync(hookFnCaller, hook, pageContextForPublicUsage) {
     })();
     return promise;
 }
-function execHookSync(hook, pageContext, preparePageContextForPublicUsage) {
+function execHookDirectSync(hook, pageContext, preparePageContextForPublicUsage) {
     const pageContextForPublicUsage = preparePageContextForPublicUsage(pageContext);
     providePageContextInternal(pageContextForPublicUsage);
     const hookReturn = hook.hookFn(pageContextForPublicUsage);

package/dist/cjs/shared/route/{executeGuardHook.js → execHookGuard.js}

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.executeGuardHook = executeGuardHook;
+exports.execHookGuard = execHookGuard;
 const getHook_js_1 = require("../hooks/getHook.js");
 const utils_js_1 = require("./utils.js");
 const execHook_js_1 = require("../hooks/execHook.js");
 const errIntro = 'The guard() hook defined by';
-async function executeGuardHook(pageContext, prepareForPublicUsage) {
+async function execHookGuard(pageContext, prepareForPublicUsage) {
     let hook;
     if (pageContext._globalContext._pageFilesAll.length > 0) {
         // TODO/v1-release: remove
@@ -19,7 +19,7 @@ async function executeGuardHook(pageContext, prepareForPublicUsage) {
     }
     if (!hook)
         return;
-    await (0, execHook_js_1.execHookSingle)(hook, pageContext, prepareForPublicUsage);
+    await (0, execHook_js_1.execHookDirectSingle)(hook, pageContext, prepareForPublicUsage);
 }
 function findPageGuard(pageId, pageFilesAll) {
     const pageRouteFile = pageFilesAll.find((p) => p.pageId === pageId && p.fileType === '.page.route');

package/dist/cjs/shared/route/{executeOnBeforeRouteHook.js → execHookOnBeforeRoute.js}

@@ -3,14 +3,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.executeOnBeforeRouteHook = executeOnBeforeRouteHook;
+exports.execHookOnBeforeRoute = execHookOnBeforeRoute;
 const assertPageContextProvidedByUser_js_1 = require("../assertPageContextProvidedByUser.js");
 const utils_js_1 = require("./utils.js");
 const resolveRouteFunction_js_1 = require("./resolveRouteFunction.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const execHook_js_1 = require("../hooks/execHook.js");
 const preparePageContextForPublicUsage_js_1 = require("../preparePageContextForPublicUsage.js");
-async function executeOnBeforeRouteHook(pageContext) {
+async function execHookOnBeforeRoute(pageContext) {
     const pageContextFromOnBeforeRouteHook = {};
     if (!pageContext._globalContext._onBeforeRouteHook)
         return null;
@@ -39,9 +39,9 @@ async function executeOnBeforeRouteHook(pageContext) {
     return pageContextFromOnBeforeRouteHook;
 }
 async function getPageContextFromHook(onBeforeRouteHook, pageContext) {
-    let { hookReturn } = (0, execHook_js_1.execHookSync)(onBeforeRouteHook, pageContext, preparePageContextForPublicUsage_js_1.preparePageContextForPublicUsage);
+    let { hookReturn } = (0, execHook_js_1.execHookDirectSync)(onBeforeRouteHook, pageContext, preparePageContextForPublicUsage_js_1.preparePageContextForPublicUsage);
     (0, resolveRouteFunction_js_1.assertSyncRouting)(hookReturn, `The onBeforeRoute() hook ${onBeforeRouteHook.hookFilePath}`);
-    // TODO/v1-release: make executeOnBeforeRouteHook() and route() sync
+    // TODO/v1-release: make execHookOnBeforeRoute() and route() sync
     hookReturn = await hookReturn;
     const errPrefix = `The onBeforeRoute() hook defined by ${onBeforeRouteHook.hookFilePath}`;
     (0, utils_js_1.assertUsage)(hookReturn === null ||

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

@@ -14,15 +14,16 @@ const utils_js_1 = require("./utils.js");
 const resolvePrecedence_js_1 = require("./resolvePrecedence.js");
 const resolveRouteString_js_1 = require("./resolveRouteString.js");
 const resolveRouteFunction_js_1 = require("./resolveRouteFunction.js");
-const executeOnBeforeRouteHook_js_1 = require("./executeOnBeforeRouteHook.js");
+const execHookOnBeforeRoute_js_1 = require("./execHookOnBeforeRoute.js");
 const debug_js_1 = require("./debug.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+// TODO/next-major-release: make it sync
 async function route(pageContext, skipOnBeforeRouteHook) {
     (0, debug_js_1.debug)('Pages routes:', pageContext._globalContext._pageRoutes);
     const pageContextFromRoute = {};
     // onBeforeRoute()
     if (!skipOnBeforeRouteHook) {
-        const pageContextFromOnBeforeRouteHook = await (0, executeOnBeforeRouteHook_js_1.executeOnBeforeRouteHook)(pageContext);
+        const pageContextFromOnBeforeRouteHook = await (0, execHookOnBeforeRoute_js_1.execHookOnBeforeRoute)(pageContext);
         if (pageContextFromOnBeforeRouteHook) {
             if (pageContextFromOnBeforeRouteHook._routingProvidedByOnBeforeRouteHook) {
                 (0, utils_js_1.assert)(pageContextFromOnBeforeRouteHook.pageId);

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

@@ -12,7 +12,7 @@ const preparePageContextForPublicUsage_js_1 = require("../preparePageContextForP
 const utils_js_1 = require("./utils.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 async function resolveRouteFunction(routeFunction, pageContext, routeFunctionFilePath) {
-    let { hookReturn: result } = (0, execHook_js_1.execHookSync)({
+    let { hookReturn: result } = (0, execHook_js_1.execHookDirectSync)({
         hookFn: routeFunction,
         hookFilePath: routeFunctionFilePath,
         hookName: 'route',

package/dist/cjs/utils/PROJECT_VERSION.js

@@ -2,4 +2,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PROJECT_VERSION = void 0;
 // Automatically updated by @brillout/release-me
-exports.PROJECT_VERSION = '0.4.232-commit-134207d';
+exports.PROJECT_VERSION = '0.4.232-commit-1690f53';

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

@@ -421,8 +421,8 @@ declare function getPageContextFromClientHooks(pageContext: {
 } & {
     urlOriginal: string;
 }>;
-type PageContextExecuteHookClient = VikeConfigPublicPageLazy & PageContextForPublicUsageClient;
-declare function execHookClient(hookName: HookName, pageContext: PageContextExecuteHookClient): Promise<(import("../../shared/hooks/getHook.js").HookLoc & {
+type PageContextExecHookClient = VikeConfigPublicPageLazy & PageContextForPublicUsageClient;
+declare function execHookClient(hookName: HookName, pageContext: PageContextExecHookClient): Promise<(import("../../shared/hooks/getHook.js").HookLoc & {
     hookFn: (arg: import("../../shared/preparePageContextForPublicUsage.js").PageContextPrepareMinimum | import("../../shared/prepareGlobalContextForPublicUsage.js").GlobalContextPrepareMinimum) => unknown;
     hookTimeout: import("../../shared/hooks/getHook.js").HookTimeout;
 } & {

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

@@ -13,7 +13,7 @@ import { getPageContextRequestUrl } from '../../shared/getPageContextRequestUrl.
 import { getPageConfig } from '../../shared/page-configs/helpers.js';
 import { getConfigValueRuntime } from '../../shared/page-configs/getConfigValueRuntime.js';
 import { assertOnBeforeRenderHookReturn } from '../../shared/assertOnBeforeRenderHookReturn.js';
-import { executeGuardHook } from '../../shared/route/executeGuardHook.js';
+import { execHookGuard } from '../../shared/route/execHookGuard.js';
 import { AbortRender, isAbortPageContext } from '../../shared/route/abort.js';
 import { pageContextInitIsPassedToClient } from '../../shared/misc/pageContextInitIsPassedToClient.js';
 import { isServerSideError } from '../../shared/misc/isServerSideError.js';
@@ -34,7 +34,7 @@ function getPageContextFromHooks_serialized() {
 async function getPageContextFromHooks_isHydration(pageContext) {
     for (const hookName of ['data', 'onBeforeRender']) {
         if (hookClientOnlyExists(hookName, pageContext)) {
-            await executeDataLikeHook(hookName, pageContext);
+            await execHookDataLike(hookName, pageContext);
         }
     }
     return pageContext;
@@ -78,7 +78,7 @@ async function getPageContextFromClientHooks(pageContext, isErrorPage) {
                 !pageContext._hasPageContextFromServer) {
                 // 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 data() and onBeforeRender()?
-                await executeGuardHook(pageContext, (pageContext) => preparePageContextForPublicUsageClient(pageContext));
+                await execHookGuard(pageContext, (pageContext) => preparePageContextForPublicUsageClient(pageContext));
             }
         }
         else {
@@ -86,7 +86,7 @@ async function getPageContextFromClientHooks(pageContext, isErrorPage) {
                 if (hookName === 'data')
                     dataHookExec = true;
                 // This won't do anything if no hook has been defined or if the hook's env.client is false.
-                await executeDataLikeHook(hookName, pageContext);
+                await execHookDataLike(hookName, pageContext);
             }
         }
     }
@@ -101,17 +101,17 @@ async function getPageContextFromClientHooks(pageContext, isErrorPage) {
 async function execHookClient(hookName, pageContext) {
     return await execHook(hookName, pageContext, (p) => preparePageContextForPublicUsageClient(p));
 }
-async function executeDataLikeHook(hookName, pageContext) {
+async function execHookDataLike(hookName, pageContext) {
     let pageContextFromHook;
     if (hookName === 'data') {
-        pageContextFromHook = await executeDataHook(pageContext);
+        pageContextFromHook = await execHookData(pageContext);
     }
     else {
-        pageContextFromHook = await executeOnBeforeRenderHook(pageContext);
+        pageContextFromHook = await execHookOnBeforeRender(pageContext);
     }
     Object.assign(pageContext, pageContextFromHook);
 }
-async function executeDataHook(pageContext) {
+async function execHookData(pageContext) {
     const res = await execHookClient('data', pageContext);
     const hook = res[0]; // TO-DO/soon: support cumulative
     if (!hook)
@@ -120,7 +120,7 @@ async function executeDataHook(pageContext) {
     const pageContextAddendum = { data: hookReturn };
     return pageContextAddendum;
 }
-async function executeOnBeforeRenderHook(pageContext) {
+async function execHookOnBeforeRender(pageContext) {
     const res = await execHookClient('onBeforeRender', pageContext);
     const hook = res[0]; // TO-DO/soon: support cumulative
     if (!hook)