vike 0.4.232-commit-1690f53 → 0.4.232

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 { execHookGuard } from '../../shared/route/execHookGuard.js';
+import { executeGuardHook } from '../../shared/route/executeGuardHook.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 execHookDataLike(hookName, pageContext);
+            await executeDataLikeHook(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 execHookGuard(pageContext, (pageContext) => preparePageContextForPublicUsageClient(pageContext));
+                await executeGuardHook(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 execHookDataLike(hookName, pageContext);
+                await executeDataLikeHook(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 execHookDataLike(hookName, pageContext) {
+async function executeDataLikeHook(hookName, pageContext) {
     let pageContextFromHook;
     if (hookName === 'data') {
-        pageContextFromHook = await execHookData(pageContext);
+        pageContextFromHook = await executeDataHook(pageContext);
     }
     else {
-        pageContextFromHook = await execHookOnBeforeRender(pageContext);
+        pageContextFromHook = await executeOnBeforeRenderHook(pageContext);
     }
     Object.assign(pageContext, pageContextFromHook);
 }
-async function execHookData(pageContext) {
+async function executeDataHook(pageContext) {
     const res = await execHookClient('data', pageContext);
     const hook = res[0]; // TO-DO/soon: support cumulative
     if (!hook)
@@ -120,7 +120,7 @@ async function execHookData(pageContext) {
     const pageContextAddendum = { data: hookReturn };
     return pageContextAddendum;
 }
-async function execHookOnBeforeRender(pageContext) {
+async function executeOnBeforeRenderHook(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 { execHookOnRenderClient } from '../shared/execHookOnRenderClient.js';
-import { isErrorFetchingStaticAssets, loadPageConfigsLazyClientSide, } from '../shared/loadPageConfigsLazyClientSide.js';
+import { executeOnRenderClientHook } from '../shared/executeOnRenderClientHook.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 { execHookDirect, execHook } from '../../shared/hooks/execHook.js';
+import { execHooksErrorHandling, execHookErrorHandling, } 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 renderPageOnError({ err });
+            await renderErrorPage({ err });
         };
         const pageContext = await getPageContextBegin(false, pageContextBeginArgs);
         if (isRenderOutdated())
@@ -73,11 +73,9 @@ async function renderPageClientSide(renderArgs) {
             if (!globalObject.isTransitioning) {
                 globalObject.isTransitioning = true;
                 const hooks = getHookFromPageContextNew('onPageTransitionStart', previousPageContext);
-                try {
-                    await execHookDirect(hooks, pageContext, preparePageContextForPublicUsageClientMinimal);
-                }
-                catch (err) {
-                    await onError(err);
+                const res = await execHooksErrorHandling(hooks, pageContext, preparePageContextForPublicUsageClientMinimal);
+                if ('err' in res) {
+                    await onError(res.err);
                     return;
                 }
                 if (isRenderOutdated())
@@ -136,17 +134,21 @@ async function renderPageClientSide(renderArgs) {
             assert(!('urlOriginal' in pageContextFromRoute));
             objectAssign(pageContext, pageContextFromRoute);
         }
-        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;
+        try {
+            objectAssign(pageContext, await loadPageConfigsLazyClientSide(pageContext.pageId, pageContext._pageFilesAll, pageContext._globalContext._pageConfigs, pageContext._globalContext._pageConfigGlobal));
         }
-        augmentType(pageContext, res.pageContext);
+        catch (err) {
+            if (handleErrorFetchingStaticAssets(err, pageContext, isFirstRender)) {
+                return;
+            }
+            else {
+                // A user file has a syntax error
+                await onError(err);
+                return;
+            }
+        }
+        if (isRenderOutdated())
+            return;
         setPageContextCurrent(pageContext);
         // Set global hydrationCanBeAborted
         if (pageContext.exports.hydrationCanBeAborted) {
@@ -216,11 +218,7 @@ async function renderPageClientSide(renderArgs) {
             await renderPageView(pageContext);
         }
     }
-    // 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) {
+    async function renderErrorPage(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:
@@ -249,6 +247,8 @@ 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,17 +313,21 @@ async function renderPageClientSide(renderArgs) {
             redirectHard(urlOriginal);
             return;
         }
-        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;
+        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;
+            }
         }
-        augmentType(pageContext, res.pageContext);
+        if (isRenderOutdated())
+            return;
         setPageContextCurrent(pageContext);
         let pageContextFromServerHooks;
         try {
@@ -357,7 +361,7 @@ async function renderPageClientSide(renderArgs) {
     async function renderPageView(pageContext, isErrorPage) {
         const onError = async (err) => {
             if (!isErrorPage) {
-                await renderPageOnError({ err });
+                await renderErrorPage({ err });
             }
             else {
                 if (!isSameErrorMessage(err, isErrorPage.err)) {
@@ -379,7 +383,7 @@ async function renderPageClientSide(renderArgs) {
         const onRenderClientPromise = (async () => {
             let onRenderClientError;
             try {
-                await execHookOnRenderClient(pageContext, preparePageContextForPublicUsageClient);
+                await executeOnRenderClientHook(pageContext, preparePageContextForPublicUsageClient);
             }
             catch (err) {
                 onRenderClientError = err;
@@ -401,11 +405,9 @@ async function renderPageClientSide(renderArgs) {
         */
         // onHydrationEnd()
         if (isFirstRender && !onRenderClientError) {
-            try {
-                await execHook('onHydrationEnd', pageContext, preparePageContextForPublicUsageClient);
-            }
-            catch (err) {
-                await onError(err);
+            const res = await execHookErrorHandling('onHydrationEnd', pageContext, preparePageContextForPublicUsageClient);
+            if ('err' in res) {
+                await onError(res.err);
                 if (!isErrorPage)
                     return;
             }
@@ -420,11 +422,9 @@ async function renderPageClientSide(renderArgs) {
             globalObject.isTransitioning = undefined;
             assert(previousPageContext);
             const hooks = getHookFromPageContextNew('onPageTransitionEnd', previousPageContext);
-            try {
-                await execHookDirect(hooks, pageContext, preparePageContextForPublicUsageClient);
-            }
-            catch (err) {
-                await onError(err);
+            const res = await execHooksErrorHandling(hooks, pageContext, preparePageContextForPublicUsageClient);
+            if ('err' in res) {
+                await onError(res.err);
                 if (!isErrorPage)
                     return;
             }
@@ -491,6 +491,22 @@ 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;
@@ -580,54 +596,3 @@ 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,12 +1,10 @@
 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();
@@ -22,9 +20,10 @@ async function createPageContextClientSide() {
     });
     objectAssign(pageContextCreated, getPageContextSerializedInHtml());
     // Sets pageContext.config to global configs
-    augmentType(pageContextCreated, await createPageContextShared(pageContextCreated, globalContext._pageConfigGlobal, globalContext._vikeConfigPublicGlobal));
+    const pageContextAugmented = await createPageContextShared(pageContextCreated, globalContext._pageConfigGlobal, globalContext._vikeConfigPublicGlobal);
+    augmentType(pageContextCreated, pageContextAugmented);
     // Sets pageContext.config to local configs (overrides the pageContext.config set above)
-    augmentType(pageContextCreated, await loadPageConfigsLazyClientSideAndExecHook(pageContextCreated));
+    objectAssign(pageContextCreated, await loadPageConfigsLazyClientSide(pageContextCreated.pageId, globalContext._pageFilesAll, globalContext._pageConfigs, globalContext._pageConfigGlobal));
     assertPristineUrl();
     return pageContextCreated;
 }
@@ -32,9 +31,3 @@ 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 { execHookOnRenderClient } from '../shared/execHookOnRenderClient.js';
+import { executeOnRenderClientHook } from '../shared/executeOnRenderClientHook.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 execHookOnRenderClient(pageContext, preparePageContextForPublicUsageClient);
+    await executeOnRenderClientHook(pageContext, preparePageContextForPublicUsageClient);
     await execHook('onHydrationEnd', pageContext, preparePageContextForPublicUsageClient);
 }

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

@@ -1,4 +1,4 @@
-export { execHookOnRenderClient };
+export { executeOnRenderClientHook };
 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 execHookOnRenderClient<PageContext extends PageContextBeforeRenderClient>(pageContext: PageContext, prepareForPublicUsage: (pageConfig: PageContext) => PageContext): Promise<void>;
+declare function executeOnRenderClientHook<PageContext extends PageContextBeforeRenderClient>(pageContext: PageContext, prepareForPublicUsage: (pageConfig: PageContext) => PageContext): Promise<void>;

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

@@ -1,8 +1,8 @@
-export { execHookOnRenderClient };
+export { executeOnRenderClientHook };
 import { assert, assertUsage } from '../runtime-server-routing/utils.js';
 import { getHookFromPageContext } from '../../shared/hooks/getHook.js';
-import { execHookDirectSingle } from '../../shared/hooks/execHook.js';
-async function execHookOnRenderClient(pageContext, prepareForPublicUsage) {
+import { execHookSingle } from '../../shared/hooks/execHook.js';
+async function executeOnRenderClientHook(pageContext, prepareForPublicUsage) {
     let hook = null;
     {
         const renderHook = getHookFromPageContext(pageContext, 'render');
@@ -38,7 +38,7 @@ async function execHookOnRenderClient(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 execHookDirectSingle(hook, pageContext, prepareForPublicUsage);
+    await execHookSingle(hook, pageContext, prepareForPublicUsage);
 }
 function getUrlToShowToUser(pageContext) {
     let url;

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

@@ -1,17 +1,9 @@
 export { loadPageConfigsLazyClientSide };
-export type { PageContext_loadPageConfigsLazyClientSide };
 export { isErrorFetchingStaticAssets };
-import { type PageFile } from '../../shared/getPageFiles.js';
+import { type PageFile, type VikeConfigPublicPageLazy } from '../../shared/getPageFiles.js';
 import type { PageConfigGlobalRuntime, PageConfigRuntime } from '../../types/PageConfig.js';
-type PageContext_loadPageConfigsLazyClientSide = {
-    pageId: string;
-    _pageFilesAll: PageFile[];
-    _globalContext: {
-        _pageConfigs: PageConfigRuntime[];
-        _pageConfigGlobal: PageConfigGlobalRuntime;
-    };
-};
-declare function loadPageConfigsLazyClientSide(pageId: string, pageFilesAll: PageFile[], pageConfigs: PageConfigRuntime[], pageConfigGlobal: PageConfigGlobalRuntime): Promise<import("../../shared/getPageFiles.js").VikeConfigPublicPageLazy & {
+type PageContextUserFilesLoaded = VikeConfigPublicPageLazy & {
     _pageFilesLoaded: PageFile[];
-}>;
+};
+declare function loadPageConfigsLazyClientSide(pageId: string, pageFilesAll: PageFile[], pageConfigs: PageConfigRuntime[], pageConfigGlobal: PageConfigGlobalRuntime): Promise<PageContextUserFilesLoaded>;
 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 errStamp = '_isAssetsError';
+const stamp = '__whileFetchingAssets';
 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, { [errStamp]: true });
+            Object.assign(err, { [stamp]: true });
         }
         else {
-            // Syntax error in user file
+            // A user file has a syntax error
         }
         throw err;
     }
@@ -40,7 +40,7 @@ function isErrorFetchingStaticAssets(err) {
     if (!err) {
         return false;
     }
-    return err[errStamp] === true;
+    return err[stamp] === true;
 }
 // https://stackoverflow.com/questions/75928310/how-to-detect-that-import-some-url-failed-because-some-url-isnt-a-javasc
 function isFetchError(err) {