vike 0.4.232-commit-ec54a7e → 0.4.232-commit-1690f53

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

@@ -8,8 +8,8 @@ import { getPageContextFromClientHooks, getPageContextFromServerHooks, getPageCo
 import { createPageContextClientSide } from './createPageContextClientSide.js';
 import { addLinkPrefetchHandlers, addLinkPrefetchHandlers_unwatch, addLinkPrefetchHandlers_watch, getPageContextPrefetched, populatePageContextPrefetchCache, } from './prefetch.js';
 import { assertInfo, assertWarning, isReact } from './utils.js';
-import { executeOnRenderClientHook } from '../shared/executeOnRenderClientHook.js';
-import { isErrorFetchingStaticAssets, loadPageConfigsLazy, } from '../shared/loadPageConfigsLazyClientSide.js';
+import { execHookOnRenderClient } from '../shared/execHookOnRenderClient.js';
+import { isErrorFetchingStaticAssets, loadPageConfigsLazyClientSide, } from '../shared/loadPageConfigsLazyClientSide.js';
 import { pushHistoryState } from './history.js';
 import { assertNoInfiniteAbortLoop, getPageContextFromAllRewrites, isAbortError, logAbortErrorHandled, } from '../../shared/route/abort.js';
 import { route } from '../../shared/route/index.js';
@@ -20,7 +20,7 @@ import { getErrorPageId } from '../../shared/error-page.js';
 import { setPageContextCurrent } from './getPageContextCurrent.js';
 import { getRouteStringParameterList } from '../../shared/route/resolveRouteString.js';
 import { getCurrentUrl } from '../shared/getCurrentUrl.js';
-import { execHooksErrorHandling, execHookErrorHandling, execHook, } from '../../shared/hooks/execHook.js';
+import { execHookDirect, execHook } from '../../shared/hooks/execHook.js';
 import { preparePageContextForPublicUsageClient, } from './preparePageContextForPublicUsageClient.js';
 import { getHookFromPageContextNew } from '../../shared/hooks/getHook.js';
 import { preparePageContextForPublicUsageClientMinimal } from '../shared/preparePageContextForPublicUsageClientShared.js';
@@ -73,9 +73,11 @@ async function renderPageClientSide(renderArgs) {
             if (!globalObject.isTransitioning) {
                 globalObject.isTransitioning = true;
                 const hooks = getHookFromPageContextNew('onPageTransitionStart', previousPageContext);
-                const res = await execHooksErrorHandling(hooks, pageContext, preparePageContextForPublicUsageClientMinimal);
-                if ('err' in res) {
-                    await onError(res.err);
+                try {
+                    await execHookDirect(hooks, pageContext, preparePageContextForPublicUsageClientMinimal);
+                }
+                catch (err) {
+                    await onError(err);
                     return;
                 }
                 if (isRenderOutdated())
@@ -134,23 +136,17 @@ async function renderPageClientSide(renderArgs) {
             assert(!('urlOriginal' in pageContextFromRoute));
             objectAssign(pageContext, pageContextFromRoute);
         }
-        let pageContextAugmented;
-        try {
-            pageContextAugmented = await loadPageConfigsLazyClientSide(pageContext);
-        }
-        catch (err) {
-            if (handleErrorFetchingStaticAssets(err, pageContext, isFirstRender)) {
-                return;
-            }
-            else {
-                // A user file has a syntax error
-                await onError(err);
-                return;
-            }
-        }
-        augmentType(pageContext, pageContextAugmented);
-        if (isRenderOutdated())
+        const res = await loadPageConfigsLazyClientSideAndExecHook(pageContext, isFirstRender, isRenderOutdated);
+        /* Already called inside loadPageConfigsLazyClientSideAndExecHook()
+        if (isRenderOutdated()) return
+        */
+        if (res.skip)
             return;
+        if ('err' in res) {
+            await onError(res.err);
+            return;
+        }
+        augmentType(pageContext, res.pageContext);
         setPageContextCurrent(pageContext);
         // Set global hydrationCanBeAborted
         if (pageContext.exports.hydrationCanBeAborted) {
@@ -317,23 +313,17 @@ async function renderPageClientSide(renderArgs) {
             redirectHard(urlOriginal);
             return;
         }
-        let pageContextAugmented;
-        try {
-            pageContextAugmented = await loadPageConfigsLazyClientSide(pageContext);
-        }
-        catch (err) {
-            if (handleErrorFetchingStaticAssets(err, pageContext, isFirstRender)) {
-                return;
-            }
-            else {
-                // A user file has a syntax error
-                onError(err);
-                return;
-            }
-        }
-        augmentType(pageContext, pageContextAugmented);
-        if (isRenderOutdated())
+        const res = await loadPageConfigsLazyClientSideAndExecHook(pageContext, isFirstRender, isRenderOutdated);
+        /* Already called inside loadPageConfigsLazyClientSideAndExecHook()
+        if (isRenderOutdated()) return
+        */
+        if (res.skip)
             return;
+        if ('err' in res) {
+            onError(res.err);
+            return;
+        }
+        augmentType(pageContext, res.pageContext);
         setPageContextCurrent(pageContext);
         let pageContextFromServerHooks;
         try {
@@ -389,7 +379,7 @@ async function renderPageClientSide(renderArgs) {
         const onRenderClientPromise = (async () => {
             let onRenderClientError;
             try {
-                await executeOnRenderClientHook(pageContext, preparePageContextForPublicUsageClient);
+                await execHookOnRenderClient(pageContext, preparePageContextForPublicUsageClient);
             }
             catch (err) {
                 onRenderClientError = err;
@@ -411,9 +401,11 @@ async function renderPageClientSide(renderArgs) {
         */
         // onHydrationEnd()
         if (isFirstRender && !onRenderClientError) {
-            const res = await execHookErrorHandling('onHydrationEnd', pageContext, preparePageContextForPublicUsageClient);
-            if ('err' in res) {
-                await onError(res.err);
+            try {
+                await execHook('onHydrationEnd', pageContext, preparePageContextForPublicUsageClient);
+            }
+            catch (err) {
+                await onError(err);
                 if (!isErrorPage)
                     return;
             }
@@ -428,9 +420,11 @@ async function renderPageClientSide(renderArgs) {
             globalObject.isTransitioning = undefined;
             assert(previousPageContext);
             const hooks = getHookFromPageContextNew('onPageTransitionEnd', previousPageContext);
-            const res = await execHooksErrorHandling(hooks, pageContext, preparePageContextForPublicUsageClient);
-            if ('err' in res) {
-                await onError(res.err);
+            try {
+                await execHookDirect(hooks, pageContext, preparePageContextForPublicUsageClient);
+            }
+            catch (err) {
+                await onError(err);
                 if (!isErrorPage)
                     return;
             }
@@ -497,22 +491,6 @@ function changeUrl(url, overwriteLastHistoryEntry) {
         return;
     pushHistoryState(url, overwriteLastHistoryEntry);
 }
-function handleErrorFetchingStaticAssets(err, pageContext, isFirstRender) {
-    if (!isErrorFetchingStaticAssets(err)) {
-        return false;
-    }
-    if (isFirstRender) {
-        disableClientRouting(err, false);
-        // This may happen if the frontend was newly deployed during hydration.
-        // Ideally: re-try a couple of times by reloading the page (not entirely trivial to implement since `localStorage` is needed.)
-        throw err;
-    }
-    else {
-        disableClientRouting(err, true);
-    }
-    redirectHard(pageContext.urlOriginal);
-    return true;
-}
 function disableClientRouting(err, log) {
     assert(isErrorFetchingStaticAssets(err));
     globalObject.clientRoutingIsDisabled = true;
@@ -602,9 +580,54 @@ function areKeysEqual(key1, key2) {
 function getPageContextClient() {
     return globalObject.renderedPageContext ?? null;
 }
-async function loadPageConfigsLazyClientSide(pageContext) {
-    const pageContextAddendum = await loadPageConfigsLazy(pageContext.pageId, pageContext._pageFilesAll, pageContext._globalContext._pageConfigs, pageContext._globalContext._pageConfigGlobal);
+async function loadPageConfigsLazyClientSideAndExecHook(pageContext, isFirstRender, isRenderOutdated) {
+    let hasErr = false;
+    let err;
+    let pageContextAddendum;
+    try {
+        pageContextAddendum = await loadPageConfigsLazyClientSide(pageContext.pageId, pageContext._pageFilesAll, pageContext._globalContext._pageConfigs, pageContext._globalContext._pageConfigGlobal);
+    }
+    catch (err_) {
+        err = err_;
+        hasErr = true;
+        if (handleErrorFetchingStaticAssets(err, pageContext, isFirstRender)) {
+            return { skip: true };
+        }
+        else {
+            // Syntax error in user file
+        }
+    }
+    if (isRenderOutdated())
+        return { skip: true };
+    if (hasErr)
+        return { err };
     objectAssign(pageContext, pageContextAddendum);
-    await execHook('onCreatePageContext', pageContext, preparePageContextForPublicUsageClient);
-    return pageContext;
+    try {
+        await execHook('onCreatePageContext', pageContext, preparePageContextForPublicUsageClient);
+    }
+    catch (err_) {
+        err = err;
+        hasErr = true;
+    }
+    if (isRenderOutdated())
+        return { skip: true };
+    if (hasErr)
+        return { err };
+    return { pageContext };
+}
+function handleErrorFetchingStaticAssets(err, pageContext, isFirstRender) {
+    if (!isErrorFetchingStaticAssets(err)) {
+        return false;
+    }
+    if (isFirstRender) {
+        disableClientRouting(err, false);
+        // This may happen if the frontend was newly deployed during hydration.
+        // Ideally: re-try a couple of times by reloading the page (not entirely trivial to implement since `localStorage` is needed.)
+        throw err;
+    }
+    else {
+        disableClientRouting(err, true);
+    }
+    redirectHard(pageContext.urlOriginal);
+    return true;
 }

package/dist/esm/client/runtime-server-routing/createPageContextClientSide.js

@@ -1,7 +1,7 @@
 export { createPageContextClientSide };
 import { assertUsage, augmentType, objectAssign } from './utils.js';
 import { getPageContextSerializedInHtml } from '../shared/getJsonSerializedInHtml.js';
-import { loadPageConfigsLazy, } from '../shared/loadPageConfigsLazyClientSide.js';
+import { loadPageConfigsLazyClientSide, } from '../shared/loadPageConfigsLazyClientSide.js';
 import { getCurrentUrl } from '../shared/getCurrentUrl.js';
 import { createPageContextObject, createPageContextShared } from '../../shared/createPageContextShared.js';
 import { getGlobalContextClientInternal } from './globalContext.js';
@@ -24,7 +24,7 @@ async function createPageContextClientSide() {
     // Sets pageContext.config to global configs
     augmentType(pageContextCreated, await createPageContextShared(pageContextCreated, globalContext._pageConfigGlobal, globalContext._vikeConfigPublicGlobal));
     // Sets pageContext.config to local configs (overrides the pageContext.config set above)
-    augmentType(pageContextCreated, await loadPageConfigsLazyClientSide(pageContextCreated));
+    augmentType(pageContextCreated, await loadPageConfigsLazyClientSideAndExecHook(pageContextCreated));
     assertPristineUrl();
     return pageContextCreated;
 }
@@ -32,8 +32,8 @@ function assertPristineUrl() {
     const urlCurrent = getCurrentUrl({ withoutHash: true });
     assertUsage(urlFirst === urlCurrent, `The URL was manipulated before the hydration finished ('${urlFirst}' to '${urlCurrent}'). Ensure the hydration has finished before manipulating the URL. Consider using the onHydrationEnd() hook.`);
 }
-async function loadPageConfigsLazyClientSide(pageContext) {
-    const pageContextAddendum = await loadPageConfigsLazy(pageContext.pageId, pageContext._pageFilesAll, pageContext._globalContext._pageConfigs, pageContext._globalContext._pageConfigGlobal);
+async function loadPageConfigsLazyClientSideAndExecHook(pageContext) {
+    const pageContextAddendum = await loadPageConfigsLazyClientSide(pageContext.pageId, pageContext._pageFilesAll, pageContext._globalContext._pageConfigs, pageContext._globalContext._pageConfigGlobal);
     objectAssign(pageContext, pageContextAddendum);
     await execHook('onCreatePageContext', pageContext, preparePageContextForPublicUsageClient);
     return pageContext;

package/dist/esm/client/runtime-server-routing/entry.js

@@ -1,7 +1,7 @@
 import { assertServerRouting } from '../../utils/assertRoutingType.js';
 assertServerRouting();
 import { createPageContextClientSide } from './createPageContextClientSide.js';
-import { executeOnRenderClientHook } from '../shared/executeOnRenderClientHook.js';
+import { execHookOnRenderClient } from '../shared/execHookOnRenderClient.js';
 import { assertSingleInstance_onClientEntryServerRouting } from './utils.js';
 import { removeFoucBuster } from '../shared/removeFoucBuster.js';
 import { execHook } from '../../shared/hooks/execHook.js';
@@ -14,6 +14,6 @@ if (import.meta.env.DEV)
 hydrate();
 async function hydrate() {
     const pageContext = await createPageContextClientSide();
-    await executeOnRenderClientHook(pageContext, preparePageContextForPublicUsageClient);
+    await execHookOnRenderClient(pageContext, preparePageContextForPublicUsageClient);
     await execHook('onHydrationEnd', pageContext, preparePageContextForPublicUsageClient);
 }

package/dist/esm/client/shared/{executeOnRenderClientHook.d.ts → execHookOnRenderClient.d.ts}

@@ -1,4 +1,4 @@
-export { executeOnRenderClientHook };
+export { execHookOnRenderClient };
 export type { PageContextBeforeRenderClient };
 import type { PageFile, VikeConfigPublicPageLazy } from '../../shared/getPageFiles.js';
 import type { PageContextForPublicUsageClientShared } from './preparePageContextForPublicUsageClientShared.js';
@@ -10,4 +10,4 @@ type PageContextBeforeRenderClient = {
     pageId: string;
     _globalContext: GlobalContextClientInternalShared;
 } & VikeConfigPublicPageLazy & PageContextForPublicUsageClientShared;
-declare function executeOnRenderClientHook<PageContext extends PageContextBeforeRenderClient>(pageContext: PageContext, prepareForPublicUsage: (pageConfig: PageContext) => PageContext): Promise<void>;
+declare function execHookOnRenderClient<PageContext extends PageContextBeforeRenderClient>(pageContext: PageContext, prepareForPublicUsage: (pageConfig: PageContext) => PageContext): Promise<void>;

package/dist/esm/client/shared/{executeOnRenderClientHook.js → execHookOnRenderClient.js}

@@ -1,8 +1,8 @@
-export { executeOnRenderClientHook };
+export { execHookOnRenderClient };
 import { assert, assertUsage } from '../runtime-server-routing/utils.js';
 import { getHookFromPageContext } from '../../shared/hooks/getHook.js';
-import { execHookSingle } from '../../shared/hooks/execHook.js';
-async function executeOnRenderClientHook(pageContext, prepareForPublicUsage) {
+import { execHookDirectSingle } from '../../shared/hooks/execHook.js';
+async function execHookOnRenderClient(pageContext, prepareForPublicUsage) {
     let hook = null;
     {
         const renderHook = getHookFromPageContext(pageContext, 'render');
@@ -38,7 +38,7 @@ async function executeOnRenderClientHook(pageContext, prepareForPublicUsage) {
         }
     }
     // We don't use a try-catch wrapper because rendering errors are usually handled by the UI framework. (E.g. React's Error Boundaries.)
-    await execHookSingle(hook, pageContext, prepareForPublicUsage);
+    await execHookDirectSingle(hook, pageContext, prepareForPublicUsage);
 }
 function getUrlToShowToUser(pageContext) {
     let url;

package/dist/esm/client/shared/loadPageConfigsLazyClientSide.d.ts

@@ -1,9 +1,8 @@
-export { loadPageConfigsLazy };
+export { loadPageConfigsLazyClientSide };
 export type { PageContext_loadPageConfigsLazyClientSide };
 export { isErrorFetchingStaticAssets };
-import { type PageFile, type VikeConfigPublicPageLazy } from '../../shared/getPageFiles.js';
+import { type PageFile } from '../../shared/getPageFiles.js';
 import type { PageConfigGlobalRuntime, PageConfigRuntime } from '../../types/PageConfig.js';
-import { PageContextPrepareMinimum } from '../../shared/preparePageContextForPublicUsage.js';
 type PageContext_loadPageConfigsLazyClientSide = {
     pageId: string;
     _pageFilesAll: PageFile[];
@@ -11,9 +10,8 @@ type PageContext_loadPageConfigsLazyClientSide = {
         _pageConfigs: PageConfigRuntime[];
         _pageConfigGlobal: PageConfigGlobalRuntime;
     };
-} & PageContextPrepareMinimum;
-type PageContextUserFilesLoaded = VikeConfigPublicPageLazy & {
-    _pageFilesLoaded: PageFile[];
 };
-declare function loadPageConfigsLazy(pageId: string, pageFilesAll: PageFile[], pageConfigs: PageConfigRuntime[], pageConfigGlobal: PageConfigGlobalRuntime): Promise<PageContextUserFilesLoaded>;
+declare function loadPageConfigsLazyClientSide(pageId: string, pageFilesAll: PageFile[], pageConfigs: PageConfigRuntime[], pageConfigGlobal: PageConfigGlobalRuntime): Promise<import("../../shared/getPageFiles.js").VikeConfigPublicPageLazy & {
+    _pageFilesLoaded: PageFile[];
+}>;
 declare function isErrorFetchingStaticAssets(err: unknown): boolean;

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

@@ -1,12 +1,12 @@
-export { loadPageConfigsLazy };
+export { loadPageConfigsLazyClientSide };
 export { isErrorFetchingStaticAssets };
 import { getPageFilesClientSide } from '../../shared/getPageFiles.js';
 import { resolveVikeConfigPublicPageLazy } from '../../shared/page-configs/resolveVikeConfigPublic.js';
 import { findPageConfig } from '../../shared/page-configs/findPageConfig.js';
 import { loadConfigValues } from '../../shared/page-configs/loadConfigValues.js';
 import { objectAssign } from '../runtime-server-routing/utils.js';
-const stamp = '__whileFetchingAssets';
-async function loadPageConfigsLazy(pageId, pageFilesAll, pageConfigs, pageConfigGlobal) {
+const errStamp = '_isAssetsError';
+async function loadPageConfigsLazyClientSide(pageId, pageFilesAll, pageConfigs, pageConfigGlobal) {
     const pageFilesClientSide = getPageFilesClientSide(pageFilesAll, pageId);
     const pageConfig = findPageConfig(pageConfigs, pageId);
     let pageConfigLoaded;
@@ -23,10 +23,10 @@ async function loadPageConfigsLazy(pageId, pageFilesAll, pageConfigs, pageConfig
     }
     catch (err) {
         if (isFetchError(err)) {
-            Object.assign(err, { [stamp]: true });
+            Object.assign(err, { [errStamp]: true });
         }
         else {
-            // A user file has a syntax error
+            // Syntax error in user file
         }
         throw err;
     }
@@ -40,7 +40,7 @@ function isErrorFetchingStaticAssets(err) {
     if (!err) {
         return false;
     }
-    return err[stamp] === true;
+    return err[errStamp] === true;
 }
 // https://stackoverflow.com/questions/75928310/how-to-detect-that-import-some-url-failed-because-some-url-isnt-a-javasc
 function isFetchError(err) {

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

@@ -18,11 +18,11 @@ import { getConfigValueRuntime } from '../../shared/page-configs/getConfigValueR
 import { loadConfigValues } from '../../shared/page-configs/loadConfigValues.js';
 import { getErrorPageId, isErrorPage } from '../../shared/error-page.js';
 import { isAbortError } from '../../shared/route/abort.js';
-import { loadPageConfigsLazyServerSide } from '../runtime/renderPage/loadPageConfigsLazyServerSide.js';
+import { loadPageConfigsLazyServerSideAndExecHook } from '../runtime/renderPage/loadPageConfigsLazyServerSide.js';
 import { getHookFromPageConfig, getHookFromPageConfigGlobal, getHookTimeoutDefault, getHook_setIsPrerenderering, } from '../../shared/hooks/getHook.js';
 import { noRouteMatch } from '../../shared/route/noRouteMatch.js';
 import { getVikeConfigInternal } from '../vite/shared/resolveVikeConfigInternal.js';
-import { execHookWithoutPageContext, isUserHookError } from '../../shared/hooks/execHook.js';
+import { execHookDirectWithoutPageContext, isUserHookError } from '../../shared/hooks/execHook.js';
 import { setWasPrerenderRun } from './context.js';
 import { resolvePrerenderConfigGlobal, resolvePrerenderConfigLocal } from './resolvePrerenderConfig.js';
 import { getOutDirs } from '../vite/shared/getOutDirs.js';
@@ -216,7 +216,7 @@ async function callOnBeforePrerenderStartHooks(prerenderContext, globalContext,
         if (doNotPrerenderList.find((p) => p.pageId === pageId))
             return;
         const { hookName, hookFilePath } = hook;
-        const prerenderResult = await execHookWithoutPageContext(() => hook.hookFn(), hook);
+        const prerenderResult = await execHookDirectWithoutPageContext(() => hook.hookFn(), hook);
         const result = normalizeOnPrerenderHookResult(prerenderResult, hookFilePath, hookName);
         // Handle result
         await Promise.all(result.map(async ({ url, pageContext }) => {
@@ -323,7 +323,7 @@ async function createPageContextPrerendering(urlOriginal, prerenderContext, glob
             routeParams: {},
         });
     }
-    augmentType(pageContext, await loadPageConfigsLazyServerSide(pageContext));
+    augmentType(pageContext, await loadPageConfigsLazyServerSideAndExecHook(pageContext));
     let usesClientRouter;
     {
         const { pageId } = pageContext;
@@ -444,7 +444,7 @@ async function callOnPrerenderStartHook(prerenderContext, globalContext, concurr
         preservePropertyGetters(pageContext);
     });
     const prerenderContextPublic = preparePrerenderContextForPublicUsage(prerenderContext);
-    let result = await execHookWithoutPageContext(() => hookFn(prerenderContextPublic), onPrerenderStartHook);
+    let result = await execHookDirectWithoutPageContext(() => hookFn(prerenderContextPublic), onPrerenderStartHook);
     // Before applying result
     prerenderContext.pageContexts.forEach((pageContext) => {
         ;

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

@@ -8,7 +8,7 @@ export { createHttpResponseBaseIsMissing };
 export type { HttpResponse };
 import type { GetPageAssets } from './getPageAssets.js';
 import type { HtmlRender } from '../html/renderHtml.js';
-import type { RenderHook } from './executeOnRenderHtmlHook.js';
+import type { RenderHook } from './execHookOnRenderHtml.js';
 import type { RedirectStatusCode, AbortStatusCode, UrlRedirect } from '../../../shared/route/abort.js';
 import { HttpResponseBody } from './getHttpResponseBody.js';
 import { type EarlyHint } from './getEarlyHints.js';

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

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

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

@@ -1,7 +1,7 @@
-export { executeOnBeforeRenderAndDataHooks };
+export { execHookDataAndOnBeforeRender };
 import { assertOnBeforeRenderHookReturn } from '../../../shared/assertOnBeforeRenderHookReturn.js';
 import { execHookServer } from './execHookServer.js';
-async function executeOnBeforeRenderAndDataHooks(pageContext) {
+async function execHookDataAndOnBeforeRender(pageContext) {
     if (pageContext._pageContextAlreadyProvidedByOnPrerenderHook) {
         return;
     }

package/dist/esm/node/runtime/renderPage/{executeOnRenderHtmlHook.d.ts → execHookOnRenderHtml.d.ts}

@@ -1,4 +1,4 @@
-export { executeOnRenderHtmlHook };
+export { execHookOnRenderHtml };
 export type { RenderHook };
 import { type HtmlRender } from '../html/renderHtml.js';
 import { type Hook } from '../../../shared/hooks/getHook.js';
@@ -11,7 +11,7 @@ type RenderHook = Hook & {
     hookName: HookName;
 };
 type HookName = 'onRenderHtml' | 'render';
-declare function executeOnRenderHtmlHook(pageContext: PageContextForPublicUsageServer & PageContextSerialization & {
+declare function execHookOnRenderHtml(pageContext: PageContextForPublicUsageServer & PageContextSerialization & {
     pageId: string;
     _globalContext: GlobalContextServerInternal;
     __getPageAssets: GetPageAssets;

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

@@ -1,4 +1,4 @@
-export { executeOnRenderHtmlHook };
+export { execHookOnRenderHtml };
 import { isDocumentHtml, renderDocumentHtml, dangerouslySkipEscape, } from '../html/renderHtml.js';
 import { getHookFromPageContext } from '../../../shared/hooks/getHook.js';
 import { assert, assertUsage, assertWarning, isObject, objectAssign, isPromise, isCallable } from '../utils.js';
@@ -8,11 +8,11 @@ import { preparePageContextForPublicUsageServer, } from './preparePageContextFor
 import { assertHookReturnedObject } from '../../../shared/assertHookReturnedObject.js';
 import { logRuntimeError } from '../loggerRuntime.js';
 import pc from '@brillout/picocolors';
-import { execHookSingleWithReturn } from '../../../shared/hooks/execHook.js';
-async function executeOnRenderHtmlHook(pageContext) {
+import { execHookDirectSingleWithReturn } from '../../../shared/hooks/execHook.js';
+async function execHookOnRenderHtml(pageContext) {
     const hook = getRenderHook(pageContext);
     objectAssign(pageContext, { _renderHook: hook });
-    const { hookReturn } = await execHookSingleWithReturn(hook, pageContext, preparePageContextForPublicUsageServer);
+    const { hookReturn } = await execHookDirectSingleWithReturn(hook, pageContext, preparePageContextForPublicUsageServer);
     const { documentHtml, pageContextProvidedByRenderHook, pageContextPromise, injectFilter } = processHookReturnValue(hookReturn, hook);
     Object.assign(pageContext, pageContextProvidedByRenderHook);
     objectAssign(pageContext, { _pageContextPromise: pageContextPromise });

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

@@ -1,10 +1,10 @@
 export { execHookServer };
-export type { PageContextExecuteHookServer };
+export type { PageContextExecHookServer };
 import { type PageContextForPublicUsageServer } from './preparePageContextForPublicUsageServer.js';
 import type { VikeConfigPublicPageLazy } from '../../../shared/getPageFiles.js';
 import type { HookName } from '../../../types/Config.js';
-type PageContextExecuteHookServer = VikeConfigPublicPageLazy & PageContextForPublicUsageServer;
-declare function execHookServer(hookName: HookName, pageContext: PageContextExecuteHookServer): Promise<(import("../../../shared/hooks/getHook.js").HookLoc & {
+type PageContextExecHookServer = VikeConfigPublicPageLazy & PageContextForPublicUsageServer;
+declare function execHookServer(hookName: HookName, pageContext: PageContextExecHookServer): 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/node/runtime/renderPage/getHttpResponseBody.d.ts

@@ -3,7 +3,7 @@ export { getHttpResponseBodyStreamHandlers };
 export type { HttpResponseBody };
 import { StreamPipeNode, StreamPipeWeb, StreamReadableNode, StreamReadableWeb, StreamWritableNode, StreamWritableWeb } from '../html/stream.js';
 import { type HtmlRender } from '../html/renderHtml.js';
-import type { RenderHook } from './executeOnRenderHtmlHook.js';
+import type { RenderHook } from './execHookOnRenderHtml.js';
 type HttpResponseBody = {
     body: string;
     pipe: (writable: StreamWritableWeb | StreamWritableNode) => void;

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

@@ -1,19 +1,19 @@
-export { loadPageConfigsLazyServerSide };
+export { loadPageConfigsLazyServerSideAndExecHook };
 export type { PageContext_loadPageConfigsLazyServerSide };
 export type { PageConfigsLazy };
 import { PromiseType } from '../utils.js';
 import { PageContextGetPageAssets, type PageAsset } from './getPageAssets.js';
 import { type PageContextDebugRouteMatches } from './debugPageFiles.js';
 import type { GlobalContextServerInternal } from '../globalContext.js';
-import { type PageContextExecuteHookServer } from './execHookServer.js';
-type PageContextExecute = Omit<PageContextExecuteHookServer, keyof Awaited<ReturnType<typeof loadPageConfigsLazy>>>;
+import { type PageContextExecHookServer } from './execHookServer.js';
+type PageContextExecuteHook = Omit<PageContextExecHookServer, keyof Awaited<ReturnType<typeof loadPageConfigsLazyServerSide>>>;
 type PageContext_loadPageConfigsLazyServerSide = PageContextGetPageAssets & PageContextDebugRouteMatches & {
     pageId: string;
     urlOriginal: string;
     _globalContext: GlobalContextServerInternal;
 };
-type PageConfigsLazy = PromiseType<ReturnType<typeof loadPageConfigsLazy>>;
-declare function loadPageConfigsLazyServerSide<PageContext extends PageContext_loadPageConfigsLazyServerSide & PageContextExecute>(pageContext: PageContext): Promise<PageContext & import("../../../shared/getPageFiles.js").VikeConfigPublicPageLazy & {
+type PageConfigsLazy = PromiseType<ReturnType<typeof loadPageConfigsLazyServerSide>>;
+declare function loadPageConfigsLazyServerSideAndExecHook<PageContext extends PageContext_loadPageConfigsLazyServerSide & PageContextExecuteHook>(pageContext: PageContext): Promise<PageContext & import("../../../shared/getPageFiles.js").VikeConfigPublicPageLazy & {
     Page: unknown;
     _isHtmlOnly: boolean;
     _passToClient: string[];
@@ -21,7 +21,7 @@ declare function loadPageConfigsLazyServerSide<PageContext extends PageContext_l
 } & {
     __getPageAssets: () => Promise<PageAsset[]>;
 }>;
-declare function loadPageConfigsLazy(pageContext: PageContext_loadPageConfigsLazyServerSide): Promise<import("../../../shared/getPageFiles.js").VikeConfigPublicPageLazy & {
+declare function loadPageConfigsLazyServerSide(pageContext: PageContext_loadPageConfigsLazyServerSide): Promise<import("../../../shared/getPageFiles.js").VikeConfigPublicPageLazy & {
     Page: unknown;
     _isHtmlOnly: boolean;
     _passToClient: string[];

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

@@ -1,4 +1,4 @@
-export { loadPageConfigsLazyServerSide };
+export { loadPageConfigsLazyServerSideAndExecHook };
 import { getPageFilesServerSide } from '../../../shared/getPageFiles.js';
 import { resolveVikeConfigPublicPageLazy } from '../../../shared/page-configs/resolveVikeConfigPublic.js';
 import { analyzePageClientSideInit } from '../../../shared/getPageFiles/analyzePageClientSide.js';
@@ -9,13 +9,13 @@ import { findPageConfig } from '../../../shared/page-configs/findPageConfig.js';
 import { analyzePage } from './analyzePage.js';
 import { loadConfigValues } from '../../../shared/page-configs/loadConfigValues.js';
 import { execHookServer } from './execHookServer.js';
-async function loadPageConfigsLazyServerSide(pageContext) {
-    const pageContextAddendum = await loadPageConfigsLazy(pageContext);
+async function loadPageConfigsLazyServerSideAndExecHook(pageContext) {
+    const pageContextAddendum = await loadPageConfigsLazyServerSide(pageContext);
     objectAssign(pageContext, pageContextAddendum);
     await execHookServer('onCreatePageContext', pageContext);
     return pageContext;
 }
-async function loadPageConfigsLazy(pageContext) {
+async function loadPageConfigsLazyServerSide(pageContext) {
     const pageConfig = findPageConfig(pageContext._globalContext._pageConfigs, pageContext.pageId); // Make pageConfig globally available as pageContext._pageConfig ?
     const globalContext = pageContext._globalContext;
     const [{ pageFilesLoaded, pageContextExports }] = await Promise.all([

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

@@ -5,13 +5,13 @@ import { getHtmlString } from '../html/renderHtml.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)));
-    augmentType(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);