vike 0.4.232 → 0.4.233-commit-e534fd6

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

@@ -2,16 +2,16 @@ export { renderPageAlreadyRouted };
 export { prerenderPage };
 import { getErrorPageId } from '../../../shared/error-page.js';
 import { getHtmlString } from '../html/renderHtml.js';
-import { assert, assertUsage, hasProp, objectAssign } from '../utils.js';
+import { assert, assertUsage, augmentType, hasProp, objectAssign } from '../utils.js';
 import { getPageContextClientSerialized } from '../html/serializeContext.js';
 import { createHttpResponsePage, createHttpResponsePageContextJson } from './createHttpResponse.js';
-import { loadPageConfigsLazyServerSide, } from './loadPageConfigsLazyServerSide.js';
-import { executeOnRenderHtmlHook } from './executeOnRenderHtmlHook.js';
-import { executeOnBeforeRenderAndDataHooks } from './executeOnBeforeRenderAndDataHooks.js';
+import { loadPageConfigsLazyServerSideAndExecHook, } from './loadPageConfigsLazyServerSide.js';
+import { execHookOnRenderHtml } from './execHookOnRenderHtml.js';
+import { execHookDataAndOnBeforeRender } from './execHookDataAndOnBeforeRender.js';
 import { logRuntimeError } from '../loggerRuntime.js';
 import { isNewError } from './isNewError.js';
 import { preparePageContextForPublicUsageServer } from './preparePageContextForPublicUsageServer.js';
-import { executeGuardHook } from '../../../shared/route/executeGuardHook.js';
+import { execHookGuard } from '../../../shared/route/execHookGuard.js';
 import pc from '@brillout/picocolors';
 import { isServerSideError } from '../../../shared/misc/isServerSideError.js';
 async function renderPageAlreadyRouted(pageContext) {
@@ -23,16 +23,16 @@ async function renderPageAlreadyRouted(pageContext) {
     assert(isError ===
         (pageContext.pageId ===
             getErrorPageId(pageContext._globalContext._pageFilesAll, pageContext._globalContext._pageConfigs)));
-    objectAssign(pageContext, await loadPageConfigsLazyServerSide(pageContext));
+    augmentType(pageContext, await loadPageConfigsLazyServerSideAndExecHook(pageContext));
     if (!isError) {
-        await executeGuardHook(pageContext, (pageContext) => preparePageContextForPublicUsageServer(pageContext));
+        await execHookGuard(pageContext, (pageContext) => preparePageContextForPublicUsageServer(pageContext));
     }
     if (!isError) {
-        await executeOnBeforeRenderAndDataHooks(pageContext);
+        await execHookDataAndOnBeforeRender(pageContext);
     }
     else {
         try {
-            await executeOnBeforeRenderAndDataHooks(pageContext);
+            await execHookDataAndOnBeforeRender(pageContext);
         }
         catch (err) {
             if (isNewError(err, pageContext.errorWhileRendering)) {
@@ -49,7 +49,7 @@ async function renderPageAlreadyRouted(pageContext) {
         objectAssign(pageContext, { httpResponse });
         return pageContext;
     }
-    const renderHookResult = await executeOnRenderHtmlHook(pageContext);
+    const renderHookResult = await execHookOnRenderHtml(pageContext);
     const { htmlRender, renderHook } = renderHookResult;
     const httpResponse = await createHttpResponsePage(htmlRender, renderHook, pageContext);
     objectAssign(pageContext, { httpResponse });
@@ -62,10 +62,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 executeOnBeforeRenderAndDataHooks(pageContext);
-    const { htmlRender, renderHook } = await executeOnRenderHtmlHook(pageContext);
+    await execHookDataAndOnBeforeRender(pageContext);
+    const { htmlRender, renderHook } = await execHookOnRenderHtml(pageContext);
     assertUsage(htmlRender !== null, `Cannot pre-render ${pc.cyan(pageContext.urlOriginal)} because the ${renderHook.hookName}() hook defined by ${renderHook.hookFilePath} didn't return an HTML string.`);
     assert(pageContext.isClientSideNavigation === false);
     const documentHtml = await getHtmlString(htmlRender);

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

@@ -3,7 +3,7 @@ export { renderPage_addAsyncHookwrapper };
 import { renderPageAlreadyRouted } from './renderPage/renderPageAlreadyRouted.js';
 import { createPageContextServerSide, createPageContextServerSideWithoutGlobalContext, } from './renderPage/createPageContextServerSide.js';
 import { route } from '../../shared/route/index.js';
-import { assert, hasProp, objectAssign, isUrl, parseUrl, onSetupRuntime, assertWarning, getGlobalObject, checkType, assertUsage, normalizeUrlPathname, removeBaseServer, modifyUrlPathname, prependBase, removeUrlOrigin, setUrlOrigin, isUri, getUrlPretty, } from './utils.js';
+import { assert, hasProp, objectAssign, isUrl, parseUrl, onSetupRuntime, assertWarning, getGlobalObject, checkType, assertUsage, normalizeUrlPathname, removeBaseServer, modifyUrlPathname, prependBase, removeUrlOrigin, setUrlOrigin, isUri, getUrlPretty, augmentType, } from './utils.js';
 import { assertNoInfiniteAbortLoop, getPageContextFromAllRewrites, isAbortError, logAbortErrorHandled, } from '../../shared/route/abort.js';
 import { getGlobalContextServerInternal, initGlobalContext_renderPage, } from './globalContext.js';
 import { handlePageContextRequestUrl } from './renderPage/handlePageContextRequestUrl.js';
@@ -16,7 +16,7 @@ import pc from '@brillout/picocolors';
 import { getPageContextClientSerializedAbort, getPageContextClientSerialized } from './html/serializeContext.js';
 import { getErrorPageId } from '../../shared/error-page.js';
 import { handleErrorWithoutErrorPage } from './renderPage/handleErrorWithoutErrorPage.js';
-import { loadPageConfigsLazyServerSide } from './renderPage/loadPageConfigsLazyServerSide.js';
+import { loadPageConfigsLazyServerSideAndExecHook } from './renderPage/loadPageConfigsLazyServerSide.js';
 import { resolveRedirects } from './renderPage/resolveRedirects.js';
 import { getVikeConfigError } from '../shared/getVikeConfigError.js';
 const globalObject = getGlobalObject('runtime/renderPage.ts', { httpRequestsCount: 0 });
@@ -138,59 +138,66 @@ async function renderPageAlreadyPrepared(pageContextBegin, globalContext, httpRe
     else {
         assert(errNominalPage);
         assert(pageContextNominalPageSuccess === undefined);
-        assert(pageContextNominalPageBegin);
-        assert(hasProp(pageContextNominalPageBegin, 'urlOriginal', 'string'));
-        const pageContextErrorPageInit = await getPageContextErrorPageInit(pageContextBegin, errNominalPage, pageContextNominalPageBegin);
-        // Handle `throw redirect()` and `throw render()` while rendering nominal page
-        if (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) {
+    assert(pageContextNominalPageBegin);
+    assert(hasProp(pageContextNominalPageBegin, 'urlOriginal', 'string'));
+    const pageContextErrorPageInit = await getPageContextErrorPageInit(pageContextBegin, errNominalPage, pageContextNominalPageBegin);
+    // Handle `throw redirect()` and `throw render()` while rendering nominal page
+    if (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 = getErrorPageId(globalContext._pageFilesAll, globalContext._pageConfigs);
-            if (!errorPageId) {
-                objectAssign(pageContextErrorPageInit, { pageId: null });
-                return handleErrorWithoutErrorPage(pageContextErrorPageInit);
-            }
-            else {
-                objectAssign(pageContextErrorPageInit, { pageId: errorPageId });
-            }
+        else {
+            // - throw render(abortStatusCode) if not .pageContext.json request
         }
-        let pageContextErrorPage;
-        try {
-            pageContextErrorPage = await renderPageAlreadyRouted(pageContextErrorPageInit);
+        Object.assign(pageContextErrorPageInit, handled.pageContextAbort);
+    }
+    {
+        const errorPageId = getErrorPageId(globalContext._pageFilesAll, globalContext._pageConfigs);
+        if (!errorPageId) {
+            objectAssign(pageContextErrorPageInit, { pageId: null });
+            return handleErrorWithoutErrorPage(pageContextErrorPageInit);
         }
-        catch (errErrorPage) {
-            // Handle `throw redirect()` and `throw render()` while rendering error page
-            if (isAbortError(errErrorPage)) {
-                const handled = await handleAbortError(errErrorPage, pageContextsFromRewrite, pageContextBegin, pageContextNominalPageBegin, httpRequestId, pageContextErrorPageInit, globalContext);
-                // throw render(abortStatusCode)
-                if (!handled.pageContextReturn) {
-                    const pageContextAbort = errErrorPage._pageContextAbort;
-                    assertWarning(false, `Failed to render error page because ${pc.cyan(pageContextAbort._abortCall)} was called: make sure ${pc.cyan(pageContextAbort._abortCaller)} doesn't occur while the error page is being rendered.`, { onlyOnce: false });
-                    const pageContextHttpWithError = getPageContextHttpResponseError(errNominalPage, pageContextBegin);
-                    return pageContextHttpWithError;
-                }
-                // `throw redirect()` / `throw render(url)`
-                return handled.pageContextReturn;
-            }
-            if (isNewError(errErrorPage, errNominalPage)) {
-                logRuntimeError(errErrorPage, httpRequestId);
+        else {
+            objectAssign(pageContextErrorPageInit, { pageId: errorPageId });
+        }
+    }
+    let pageContextErrorPage;
+    try {
+        pageContextErrorPage = await renderPageAlreadyRouted(pageContextErrorPageInit);
+    }
+    catch (errErrorPage) {
+        // Handle `throw redirect()` and `throw render()` while rendering error page
+        if (isAbortError(errErrorPage)) {
+            const handled = await handleAbortError(errErrorPage, pageContextsFromRewrite, pageContextBegin, pageContextNominalPageBegin, httpRequestId, pageContextErrorPageInit, globalContext);
+            // throw render(abortStatusCode)
+            if (!handled.pageContextReturn) {
+                const pageContextAbort = errErrorPage._pageContextAbort;
+                assertWarning(false, `Failed to render error page because ${pc.cyan(pageContextAbort._abortCall)} was called: make sure ${pc.cyan(pageContextAbort._abortCaller)} doesn't occur while the error page is being rendered.`, { onlyOnce: false });
+                const pageContextHttpWithError = getPageContextHttpResponseError(errNominalPage, pageContextBegin);
+                return pageContextHttpWithError;
             }
-            const pageContextWithError = getPageContextHttpResponseError(errNominalPage, pageContextBegin);
-            return pageContextWithError;
+            // `throw redirect()` / `throw render(url)`
+            return handled.pageContextReturn;
         }
-        return pageContextErrorPage;
+        if (isNewError(errErrorPage, errNominalPage)) {
+            logRuntimeError(errErrorPage, httpRequestId);
+        }
+        const pageContextWithError = getPageContextHttpResponseError(errNominalPage, pageContextBegin);
+        return pageContextWithError;
     }
+    return pageContextErrorPage;
 }
 function logHttpRequest(urlOriginal, httpRequestId) {
     logRuntimeInfo?.(getRequestInfoMessage(urlOriginal), httpRequestId, 'info');
@@ -412,7 +419,7 @@ pageContextNominalPageBegin, httpRequestId, pageContextErrorPageInit, globalCont
             objectAssign(pageContext, { pageId: errorPageId });
             objectAssign(pageContext, pageContextAbort);
             objectAssign(pageContext, pageContextErrorPageInit, true);
-            objectAssign(pageContext, await loadPageConfigsLazyServerSide(pageContext));
+            augmentType(pageContext, await loadPageConfigsLazyServerSideAndExecHook(pageContext));
             // We include pageContextInit: we don't only serialize pageContextAbort because the error page may need to access pageContextInit
             pageContextSerialized = getPageContextClientSerialized(pageContext);
         }

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

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

package/dist/esm/shared/createPageContextShared.js

@@ -1,11 +1,9 @@
 export { createPageContextShared };
 export { createPageContextObject };
-import { execHookGlobal } from './hooks/execHook.js';
-import { preparePageContextForPublicUsage } from './preparePageContextForPublicUsage.js';
 import { changeEnumerable, objectAssign } from './utils.js';
+// TODO/now: make this and parents sync
 async function createPageContextShared(pageContextCreated, pageConfigGlobal, vikeConfigPublicGlobal) {
     objectAssign(pageContextCreated, vikeConfigPublicGlobal);
-    await execHookGlobal('onCreatePageContext', pageConfigGlobal, pageContextCreated, pageContextCreated, preparePageContextForPublicUsage);
     return pageContextCreated;
 }
 function createPageContextObject() {

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

@@ -1,15 +1,14 @@
 export { execHook };
-export { execHookSingle };
-export { execHookSingleWithReturn };
-export { execHookErrorHandling };
-export { execHooksErrorHandling };
-export { execHookWithoutPageContext };
 export { execHookGlobal };
-export { execHookSync };
+export { execHookDirect };
+export { execHookDirectSingle };
+export { execHookDirectSingleWithReturn };
+export { execHookDirectWithoutPageContext };
+export { execHookDirectSync };
 export { getPageContext };
 export { providePageContext };
 export { isUserHookError };
-export type { PageContextExecuteHook };
+export type { PageContextExecHook };
 import type { PageContextClient, PageContextServer } from '../../types/PageContext.js';
 import type { Hook, HookLoc } from './getHook.js';
 import type { VikeConfigPublicPageLazy } from '../getPageFiles.js';
@@ -19,34 +18,21 @@ import type { PageContextForPublicUsageServer } from '../../node/runtime/renderP
 import type { PageContextForPublicUsageClientShared } from '../../client/shared/preparePageContextForPublicUsageClientShared.js';
 import { type PageContextPrepareMinimum } from '../preparePageContextForPublicUsage.js';
 import type { GlobalContextPrepareMinimum } from '../prepareGlobalContextForPublicUsage.js';
-type PageContextExecuteHook = VikeConfigPublicPageLazy & PageContextForPublicUsage;
+type PageContextExecHook = VikeConfigPublicPageLazy & PageContextForPublicUsage;
 type PageContextForPublicUsage = PageContextForPublicUsageServer | PageContextForPublicUsageClientShared;
 type HookWithResult = Hook & {
     hookReturn: unknown;
 };
-declare function execHookSingle<PageContext extends PageContextExecuteHook>(hook: Hook, pageContext: PageContext, preparePageContextForPublicUsage: (pageContext: PageContext) => PageContext): Promise<void>;
-declare function execHookSingleWithReturn<PageContext extends PageContextExecuteHook>(hook: Hook, pageContext: PageContext, preparePageContextForPublicUsage: (pageContext: PageContext) => PageContext): Promise<{
+declare function execHook<PageContext extends PageContextExecHook>(hookName: HookName, pageContext: PageContext, preparePageContextForPublicUsage: (pageContext: PageContext) => PageContext): Promise<HookWithResult[]>;
+declare function execHookGlobal<HookArg extends PageContextPrepareMinimum | GlobalContextPrepareMinimum>(hookName: HookNameGlobal, pageConfigGlobal: PageConfigGlobalRuntime, pageContext: PageContextPrepareMinimum | null, hookArg: HookArg, prepareForPublicUsage: (hookArg: HookArg) => HookArg): Promise<void>;
+declare function execHookDirect<PageContext extends PageContextPrepareMinimum>(hooks: Hook[], pageContext: PageContext, preparePageContextForPublicUsage: (pageContext: PageContext) => PageContext): Promise<HookWithResult[]>;
+declare function execHookDirectSingle<PageContext extends PageContextExecHook>(hook: Hook, pageContext: PageContext, preparePageContextForPublicUsage: (pageContext: PageContext) => PageContext): Promise<void>;
+declare function execHookDirectSingleWithReturn<PageContext extends PageContextExecHook>(hook: Hook, pageContext: PageContext, preparePageContextForPublicUsage: (pageContext: PageContext) => PageContext): Promise<{
     hookReturn: unknown;
 }>;
-declare function execHook<PageContext extends PageContextExecuteHook>(hookName: HookName, pageContext: PageContext, preparePageContextForPublicUsage: (pageContext: PageContext) => PageContext): Promise<HookWithResult[]>;
-declare function execHookErrorHandling<PageContext extends PageContextExecuteHook>(hookName: HookName, pageContext: PageContext, preparePageContextForPublicUsage: (pageContext: PageContext) => PageContext): Promise<{
-    hooks: HookWithResult[];
-    err?: undefined;
-} | {
-    hooks: Hook[];
-    err: unknown;
-}>;
-declare function execHooksErrorHandling<PageContext extends PageContextPrepareMinimum>(hooks: Hook[], pageContext: PageContext, preparePageContextForPublicUsage: (pageContext: PageContext) => PageContext): Promise<{
-    hooks: HookWithResult[];
-    err?: undefined;
-} | {
-    hooks: Hook[];
-    err: unknown;
-}>;
-declare function execHookGlobal<HookArg extends PageContextPrepareMinimum | GlobalContextPrepareMinimum>(hookName: HookNameGlobal, pageConfigGlobal: PageConfigGlobalRuntime, pageContext: PageContextPrepareMinimum | null, hookArg: HookArg, prepareForPublicUsage: (hookArg: HookArg) => HookArg): Promise<void>;
 declare function isUserHookError(err: unknown): false | HookLoc;
-declare function execHookWithoutPageContext<HookReturn>(hookFnCaller: () => HookReturn, hook: Omit<Hook, 'hookFn'>): Promise<HookReturn>;
-declare function execHookSync<PageContext extends PageContextPrepareMinimum>(hook: Omit<Hook, 'hookTimeout'>, pageContext: PageContext, preparePageContextForPublicUsage: (pageContext: PageContext) => PageContext): {
+declare function execHookDirectWithoutPageContext<HookReturn>(hookFnCaller: () => HookReturn, hook: Omit<Hook, 'hookFn'>): Promise<HookReturn>;
+declare function execHookDirectSync<PageContext extends PageContextPrepareMinimum>(hook: Omit<Hook, 'hookTimeout'>, pageContext: PageContext, preparePageContextForPublicUsage: (pageContext: PageContext) => PageContext): {
     hookReturn: unknown;
 };
 /**

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

@@ -1,11 +1,10 @@
 export { execHook };
-export { execHookSingle };
-export { execHookSingleWithReturn };
-export { execHookErrorHandling };
-export { execHooksErrorHandling };
-export { execHookWithoutPageContext };
 export { execHookGlobal };
-export { execHookSync };
+export { execHookDirect };
+export { execHookDirectSingle };
+export { execHookDirectSingleWithReturn };
+export { execHookDirectWithoutPageContext };
+export { execHookDirectSync };
 export { getPageContext };
 export { providePageContext };
 export { isUserHookError };
@@ -19,70 +18,48 @@ const globalObject = getGlobalObject('utils/execHook.ts', {
     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];
-    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 = 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 = 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];
+    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 (!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;
@@ -126,7 +103,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/esm/shared/route/execHookGuard.d.ts

@@ -0,0 +1,8 @@
+export { execHookGuard };
+import { type PageContextExecHook } from '../hooks/execHook.js';
+import type { GlobalContextInternal } from '../createGlobalContextShared.js';
+declare function execHookGuard<PageContext extends {
+    pageId: string;
+} & {
+    _globalContext: GlobalContextInternal;
+} & PageContextExecHook>(pageContext: PageContext, prepareForPublicUsage: (pageConfig: PageContext) => PageContext): Promise<void>;

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

@@ -1,9 +1,9 @@
-export { executeGuardHook };
+export { execHookGuard };
 import { getHookFromPageContext, getHookTimeoutDefault } from '../hooks/getHook.js';
 import { assert, assertUsage, isCallable } from './utils.js';
-import { execHookSingle } from '../hooks/execHook.js';
+import { execHookDirectSingle } from '../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
@@ -17,7 +17,7 @@ async function executeGuardHook(pageContext, prepareForPublicUsage) {
     }
     if (!hook)
         return;
-    await execHookSingle(hook, pageContext, prepareForPublicUsage);
+    await execHookDirectSingle(hook, pageContext, prepareForPublicUsage);
 }
 function findPageGuard(pageId, pageFilesAll) {
     const pageRouteFile = pageFilesAll.find((p) => p.pageId === pageId && p.fileType === '.page.route');

package/dist/esm/shared/route/{executeOnBeforeRouteHook.d.ts → execHookOnBeforeRoute.d.ts}

@@ -1,6 +1,6 @@
-export { executeOnBeforeRouteHook };
+export { execHookOnBeforeRoute };
 import type { PageContextForRoute, PageContextFromRoute } from './index.js';
-declare function executeOnBeforeRouteHook(pageContext: PageContextForRoute): Promise<null | ({
+declare function execHookOnBeforeRoute(pageContext: PageContextForRoute): Promise<null | ({
     _routingProvidedByOnBeforeRouteHook: true;
 } & PageContextFromRoute) | {
     _routingProvidedByOnBeforeRouteHook: false;

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

@@ -1,11 +1,11 @@
-export { executeOnBeforeRouteHook };
+export { execHookOnBeforeRoute };
 import { assertPageContextProvidedByUser } from '../assertPageContextProvidedByUser.js';
 import { assertUsage, hasProp, isObjectWithKeys, objectAssign, assertWarning, assertUsageUrlPathnameAbsolute, joinEnglish, assert, } from './utils.js';
 import { assertRouteParams, assertSyncRouting } from './resolveRouteFunction.js';
 import pc from '@brillout/picocolors';
-import { execHookSync } from '../hooks/execHook.js';
+import { execHookDirectSync } from '../hooks/execHook.js';
 import { preparePageContextForPublicUsage, } from '../preparePageContextForPublicUsage.js';
-async function executeOnBeforeRouteHook(pageContext) {
+async function execHookOnBeforeRoute(pageContext) {
     const pageContextFromOnBeforeRouteHook = {};
     if (!pageContext._globalContext._onBeforeRouteHook)
         return null;
@@ -34,9 +34,9 @@ async function executeOnBeforeRouteHook(pageContext) {
     return pageContextFromOnBeforeRouteHook;
 }
 async function getPageContextFromHook(onBeforeRouteHook, pageContext) {
-    let { hookReturn } = execHookSync(onBeforeRouteHook, pageContext, preparePageContextForPublicUsage);
+    let { hookReturn } = execHookDirectSync(onBeforeRouteHook, pageContext, preparePageContextForPublicUsage);
     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}`;
     assertUsage(hookReturn === null ||

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

@@ -9,15 +9,16 @@ import { assert, assertUsage, isPlainObject, objectAssign } from './utils.js';
 import { resolvePrecedence } from './resolvePrecedence.js';
 import { resolveRouteString } from './resolveRouteString.js';
 import { resolveRouteFunction } from './resolveRouteFunction.js';
-import { executeOnBeforeRouteHook } from './executeOnBeforeRouteHook.js';
+import { execHookOnBeforeRoute } from './execHookOnBeforeRoute.js';
 import { debug } from './debug.js';
 import pc from '@brillout/picocolors';
+// TODO/next-major-release: make it sync
 async function route(pageContext, skipOnBeforeRouteHook) {
     debug('Pages routes:', pageContext._globalContext._pageRoutes);
     const pageContextFromRoute = {};
     // onBeforeRoute()
     if (!skipOnBeforeRouteHook) {
-        const pageContextFromOnBeforeRouteHook = await executeOnBeforeRouteHook(pageContext);
+        const pageContextFromOnBeforeRouteHook = await execHookOnBeforeRoute(pageContext);
         if (pageContextFromOnBeforeRouteHook) {
             if (pageContextFromOnBeforeRouteHook._routingProvidedByOnBeforeRouteHook) {
                 assert(pageContextFromOnBeforeRouteHook.pageId);

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

@@ -2,12 +2,12 @@ export { resolveRouteFunction };
 export { assertRouteParams };
 export { assertSyncRouting };
 export { warnDeprecatedAllowKey };
-import { execHookSync } from '../hooks/execHook.js';
+import { execHookDirectSync } from '../hooks/execHook.js';
 import { preparePageContextForPublicUsage } from '../preparePageContextForPublicUsage.js';
 import { assert, assertUsage, assertWarning, hasProp, isPlainObject, isPromise } from './utils.js';
 import pc from '@brillout/picocolors';
 async function resolveRouteFunction(routeFunction, pageContext, routeFunctionFilePath) {
-    let { hookReturn: result } = execHookSync({
+    let { hookReturn: result } = execHookDirectSync({
         hookFn: routeFunction,
         hookFilePath: routeFunctionFilePath,
         hookName: 'route',

package/dist/esm/utils/PROJECT_VERSION.d.ts

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.232";
+export declare const PROJECT_VERSION: "0.4.233-commit-e534fd6";

package/dist/esm/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.232';
+export const PROJECT_VERSION = '0.4.233-commit-e534fd6';

package/dist/esm/utils/styleFileRE.js

@@ -1,2 +1,3 @@
 // Copied from https://github.com/vitejs/vite/blob/d649daba7682791178b711d9a3e44a6b5d00990c/packages/vite/src/node/plugins/css.ts#L90-L91
+// spellcheck-ignore
 export const styleFileRE = /\.(css|less|sass|scss|styl|stylus|pcss|postcss)($|\?)/;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.232",
+  "version": "0.4.233-commit-e534fd6",
   "repository": "https://github.com/vikejs/vike",
   "exports": {
     "./server": {

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

@@ -1,6 +0,0 @@
-export { executeOnBeforeRenderAndDataHooks };
-import { type PageContextExecuteHookServer } from './execHookServer.js';
-declare function executeOnBeforeRenderAndDataHooks(pageContext: {
-    pageId: string;
-    _pageContextAlreadyProvidedByOnPrerenderHook?: true;
-} & PageContextExecuteHookServer): Promise<void>;

package/dist/esm/shared/route/executeGuardHook.d.ts

@@ -1,8 +0,0 @@
-export { executeGuardHook };
-import { type PageContextExecuteHook } from '../hooks/execHook.js';
-import type { GlobalContextInternal } from '../createGlobalContextShared.js';
-declare function executeGuardHook<PageContext extends {
-    pageId: string;
-} & {
-    _globalContext: GlobalContextInternal;
-} & PageContextExecuteHook>(pageContext: PageContext, prepareForPublicUsage: (pageConfig: PageContext) => PageContext): Promise<void>;