vike 0.4.232 → 0.4.233

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)

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, loadPageConfigsLazyClientSide } 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, } 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';
@@ -60,7 +60,7 @@ async function renderPageClientSide(renderArgs) {
     return;
     async function renderPageNominal() {
         const onError = async (err) => {
-            await renderErrorPage({ err });
+            await renderPageOnError({ err });
         };
         const pageContext = await getPageContextBegin(false, pageContextBeginArgs);
         if (isRenderOutdated())
@@ -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,21 +136,17 @@ async function renderPageClientSide(renderArgs) {
             assert(!('urlOriginal' in pageContextFromRoute));
             objectAssign(pageContext, pageContextFromRoute);
         }
-        try {
-            objectAssign(pageContext, await loadPageConfigsLazyClientSide(pageContext.pageId, pageContext._pageFilesAll, pageContext._globalContext._pageConfigs, pageContext._globalContext._pageConfigGlobal));
-        }
-        catch (err) {
-            if (handleErrorFetchingStaticAssets(err, pageContext, isFirstRender)) {
-                return;
-            }
-            else {
-                // A user file has a syntax error
-                await onError(err);
-                return;
-            }
-        }
-        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) {
@@ -218,7 +216,11 @@ async function renderPageClientSide(renderArgs) {
             await renderPageView(pageContext);
         }
     }
-    async function renderErrorPage(args) {
+    // 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(args) {
         const onError = (err) => {
             if (!isSameErrorMessage(err, args.err)) {
                 /* When we can't render the error page, we prefer showing a blank page over letting the server-side try because otherwise:
@@ -247,8 +249,6 @@ async function renderPageClientSide(renderArgs) {
         if (isRenderOutdated())
             return;
         objectAssign(pageContext, { routeParams: {} });
-        if (args.is404)
-            objectAssign(pageContext, { is404: true });
         if (args.pageContextError)
             objectAssign(pageContext, args.pageContextError);
         if ('err' in args) {
@@ -313,21 +313,17 @@ async function renderPageClientSide(renderArgs) {
             redirectHard(urlOriginal);
             return;
         }
-        try {
-            objectAssign(pageContext, await loadPageConfigsLazyClientSide(pageContext.pageId, pageContext._pageFilesAll, pageContext._globalContext._pageConfigs, pageContext._globalContext._pageConfigGlobal));
-        }
-        catch (err) {
-            if (handleErrorFetchingStaticAssets(err, pageContext, isFirstRender)) {
-                return;
-            }
-            else {
-                // A user file has a syntax error
-                onError(err);
-                return;
-            }
-        }
-        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 {
@@ -361,7 +357,7 @@ async function renderPageClientSide(renderArgs) {
     async function renderPageView(pageContext, isErrorPage) {
         const onError = async (err) => {
             if (!isErrorPage) {
-                await renderErrorPage({ err });
+                await renderPageOnError({ err });
             }
             else {
                 if (!isSameErrorMessage(err, isErrorPage.err)) {
@@ -383,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;
@@ -405,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;
             }
@@ -422,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;
             }
@@ -491,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;
@@ -596,3 +580,54 @@ function areKeysEqual(key1, key2) {
 function getPageContextClient() {
     return globalObject.renderedPageContext ?? null;
 }
+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);
+    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,10 +1,12 @@
 export { createPageContextClientSide };
 import { assertUsage, augmentType, objectAssign } from './utils.js';
 import { getPageContextSerializedInHtml } from '../shared/getJsonSerializedInHtml.js';
-import { loadPageConfigsLazyClientSide } 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';
+import { preparePageContextForPublicUsageClient, } from './preparePageContextForPublicUsageClient.js';
+import { execHook } from '../../shared/hooks/execHook.js';
 const urlFirst = getCurrentUrl({ withoutHash: true });
 async function createPageContextClientSide() {
     const globalContext = await getGlobalContextClientInternal();
@@ -20,10 +22,9 @@ async function createPageContextClientSide() {
     });
     objectAssign(pageContextCreated, getPageContextSerializedInHtml());
     // Sets pageContext.config to global configs
-    const pageContextAugmented = await createPageContextShared(pageContextCreated, globalContext._pageConfigGlobal, globalContext._vikeConfigPublicGlobal);
-    augmentType(pageContextCreated, pageContextAugmented);
+    augmentType(pageContextCreated, await createPageContextShared(pageContextCreated, globalContext._pageConfigGlobal, globalContext._vikeConfigPublicGlobal));
     // Sets pageContext.config to local configs (overrides the pageContext.config set above)
-    objectAssign(pageContextCreated, await loadPageConfigsLazyClientSide(pageContextCreated.pageId, globalContext._pageFilesAll, globalContext._pageConfigs, globalContext._pageConfigGlobal));
+    augmentType(pageContextCreated, await loadPageConfigsLazyClientSideAndExecHook(pageContextCreated));
     assertPristineUrl();
     return pageContextCreated;
 }
@@ -31,3 +32,9 @@ 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 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,17 @@
 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';
-type PageContextUserFilesLoaded = VikeConfigPublicPageLazy & {
-    _pageFilesLoaded: PageFile[];
+type PageContext_loadPageConfigsLazyClientSide = {
+    pageId: string;
+    _pageFilesAll: PageFile[];
+    _globalContext: {
+        _pageConfigs: PageConfigRuntime[];
+        _pageConfigGlobal: PageConfigGlobalRuntime;
+    };
 };
-declare function loadPageConfigsLazyClientSide(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

@@ -5,7 +5,7 @@ import { resolveVikeConfigPublicPageLazy } from '../../shared/page-configs/resol
 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';
+const errStamp = '_isAssetsError';
 async function loadPageConfigsLazyClientSide(pageId, pageFilesAll, pageConfigs, pageConfigGlobal) {
     const pageFilesClientSide = getPageFilesClientSide(pageFilesAll, pageId);
     const pageConfig = findPageConfig(pageConfigs, pageId);
@@ -23,10 +23,10 @@ async function loadPageConfigsLazyClientSide(pageId, pageFilesAll, pageConfigs,
     }
     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) {