vike 0.4.152-commit-6f928f9 → 0.4.153-commit-159c659

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

@@ -2,13 +2,13 @@ export { renderPageClientSide };
 export { getRenderCount };
 export { disableClientRouting };
 import { assert, getCurrentUrl, isSameErrorMessage, objectAssign, serverSideRouteTo, getGlobalObject, executeHook, hasProp } from './utils.js';
-import { getPageContextFromHooks_errorPage, getPageContextFromHooks_firstRender, getPageContextFromHooks_uponNavigation, isServerSideRouted } from './getPageContextFromHooks.js';
+import { getPageContextFromHooks_isHydration, getPageContextFromHooks_isNotHydration, getPageContextFromHooks_serialized, isServerSideRouted } from './getPageContextFromHooks.js';
 import { createPageContext } from './createPageContext.js';
 import { addLinkPrefetchHandlers } from './prefetch.js';
 import { assertInfo, assertWarning, isReact } from './utils.js';
 import { executeOnRenderClientHook } from '../shared/executeOnRenderClientHook.js';
 import { assertHook, getHook } from '../../shared/hooks/getHook.js';
-import { isErrorFetchingStaticAssets } from '../shared/loadPageFilesClientSide.js';
+import { isErrorFetchingStaticAssets, loadUserFilesClientSide } from '../shared/loadUserFilesClientSide.js';
 import { pushHistory } from './history.js';
 import { assertNoInfiniteAbortLoop, getPageContextFromAllRewrites, isAbortError, logAbortErrorHandled } from '../../shared/route/abort.js';
 import { route } from '../../shared/route/index.js';
@@ -16,12 +16,14 @@ import { isClientSideRoutable } from './isClientSideRoutable.js';
 import { setScrollPosition } from './setScrollPosition.js';
 import { updateState } from './onBrowserHistoryNavigation.js';
 import { browserNativeScrollRestoration_disable, setInitialRenderIsDone } from './scrollRestoration.js';
+import { getErrorPageId } from '../../shared/error-page.js';
+import { isRenderFailure } from '../../shared/misc/isRenderFailure.js';
 const globalObject = getGlobalObject('renderPageClientSide.ts', { renderCounter: 0 });
 async function renderPageClientSide(renderArgs) {
     const { scrollTarget, urlOriginal = getCurrentUrl(), overwriteLastHistoryEntry = false, isBackwardNavigation, pageContextsFromRewrite = [], redirectCount = 0, isUserLandPushStateNavigation, isClientSideNavigation = true } = renderArgs;
-    const { isRenderOutdated, setHydrationCanBeAborted, isFirstRender } = getIsRenderOutdated();
-    const callTransitionHooks = !isFirstRender;
-    assert(isClientSideNavigation === !isFirstRender);
+    // isHydrationRender <=> the first render attempt
+    const { isRenderOutdated, setHydrationCanBeAborted, isHydrationRender } = getIsRenderOutdated();
+    assert(isClientSideNavigation === !isHydrationRender);
     assertNoInfiniteAbortLoop(pageContextsFromRewrite.length, redirectCount);
     if (globalObject.clientRoutingIsDisabled) {
         serverSideRouteTo(urlOriginal);
@@ -33,92 +35,130 @@ async function renderPageClientSide(renderArgs) {
         const pageContext = await getPageContextBegin();
         if (isRenderOutdated())
             return;
-        let renderState = {};
-        if (!isFirstRender) {
-            // Route
+        // Route
+        let pageContextRouted;
+        if (isHydrationRender) {
+            const pageContextSerialized = getPageContextFromHooks_serialized();
+            pageContextRouted = pageContextSerialized;
+        }
+        else {
+            let pageContextFromRoute;
             try {
-                renderState = { pageContextFromRoute: await route(pageContext) };
+                pageContextFromRoute = await route(pageContext);
             }
             catch (err) {
-                await renderErrorPage(err);
+                await renderErrorPage({ err });
                 return;
             }
             if (isRenderOutdated())
                 return;
-            // Check whether rendering should be skipped
-            if (renderState.pageContextFromRoute) {
-                const { pageContextFromRoute } = renderState;
-                assert(!('urlOriginal' in pageContextFromRoute));
-                objectAssign(pageContext, pageContextFromRoute);
-                let isClientRoutable;
-                if (!pageContextFromRoute._pageId) {
-                    isClientRoutable = false;
-                }
-                else {
-                    isClientRoutable = await isClientSideRoutable(pageContextFromRoute._pageId, pageContext);
-                    if (isRenderOutdated())
-                        return;
-                }
-                if (!isClientRoutable) {
-                    serverSideRouteTo(urlOriginal);
-                    return;
-                }
-                const isSamePage = pageContextFromRoute._pageId &&
-                    globalObject.previousPageContext?._pageId &&
-                    pageContextFromRoute._pageId === globalObject.previousPageContext._pageId;
-                if (isUserLandPushStateNavigation && isSamePage) {
-                    // Skip's Vike's rendering; let the user handle the navigation
+            let isClientRoutable;
+            if (!pageContextFromRoute._pageId) {
+                isClientRoutable = false;
+            }
+            else {
+                isClientRoutable = await isClientSideRoutable(pageContextFromRoute._pageId, pageContext);
+                if (isRenderOutdated())
                     return;
-                }
+            }
+            if (!isClientRoutable) {
+                serverSideRouteTo(urlOriginal);
+                return;
+            }
+            assert(hasProp(pageContextFromRoute, '_pageId', 'string')); // Help TS
+            const isSamePage = pageContextFromRoute._pageId &&
+                globalObject.previousPageContext?._pageId &&
+                pageContextFromRoute._pageId === globalObject.previousPageContext._pageId;
+            if (isUserLandPushStateNavigation && isSamePage) {
+                // Skip's Vike's rendering; let the user handle the navigation
+                return;
+            }
+            pageContextRouted = pageContextFromRoute;
+        }
+        assert(!('urlOriginal' in pageContextRouted));
+        objectAssign(pageContext, pageContextRouted);
+        try {
+            objectAssign(pageContext, await loadUserFilesClientSide(pageContext._pageId, pageContext._pageFilesAll, pageContext._pageConfigs));
+        }
+        catch (err) {
+            if (handleErrorFetchingStaticAssets(err, pageContext, isHydrationRender)) {
+                return;
+            }
+            else {
+                throw err;
             }
         }
+        if (isRenderOutdated())
+            return;
+        // Set global hydrationCanBeAborted
+        if (pageContext.exports.hydrationCanBeAborted) {
+            setHydrationCanBeAborted();
+        }
+        else {
+            assertWarning(!isReact(), 'You seem to be using React; we recommend setting hydrationCanBeAborted to true, see https://vike.dev/hydrationCanBeAborted', { onlyOnce: true });
+        }
+        // There wasn't any `await` but result may change because we just called setHydrationCanBeAborted()
+        if (isRenderOutdated())
+            return;
         // onPageTransitionStart()
-        if (callTransitionHooks) {
+        if (!isHydrationRender) {
+            assertHook(pageContext, 'onPageTransitionStart');
             if (!globalObject.isTransitioning) {
-                if (globalObject.onPageTransitionStart) {
-                    const hook = globalObject.onPageTransitionStart;
+                globalObject.isTransitioning = true;
+                const onPageTransitionStartHook = getHook(pageContext, 'onPageTransitionStart');
+                if (onPageTransitionStartHook) {
+                    const hook = onPageTransitionStartHook;
                     const { hookFn } = hook;
-                    await executeHook(() => hookFn(pageContext), hook);
+                    try {
+                        await executeHook(() => hookFn(pageContext), hook);
+                    }
+                    catch (err) {
+                        await renderErrorPage({ err });
+                        return;
+                    }
+                    if (isRenderOutdated())
+                        return;
                 }
-                globalObject.isTransitioning = true;
-                if (isRenderOutdated())
-                    return;
             }
         }
-        if (isFirstRender) {
-            assert(!renderState.pageContextFromRoute);
+        // Get pageContext from hooks (fetched from server, and/or directly called on the client-side)
+        if (isHydrationRender) {
+            assert(hasProp(pageContext, '_hasPageContextFromServer', 'true'));
+            let pageContextFromHooks;
             try {
-                renderState.pageContextFromHooks = await getPageContextFromHooks_firstRender(pageContext);
+                pageContextFromHooks = await getPageContextFromHooks_isHydration(pageContext);
             }
             catch (err) {
-                await renderErrorPage(err);
+                await renderErrorPage({ err });
                 return;
             }
             if (isRenderOutdated())
                 return;
+            assert(!('urlOriginal' in pageContextFromHooks));
+            objectAssign(pageContext, pageContextFromHooks);
+            // Render page view
+            await renderPageView(pageContext);
         }
         else {
-            const { pageContextFromRoute } = renderState;
-            assert(pageContextFromRoute);
-            assert(pageContextFromRoute._pageId);
-            assert(hasProp(pageContextFromRoute, '_pageId', 'string')); // Help TS
-            assert(!('urlOriginal' in pageContextFromRoute));
-            objectAssign(pageContext, pageContextFromRoute);
+            let pageContextFromHooks;
             try {
-                renderState.pageContextFromHooks = await getPageContextFromHooks_uponNavigation(pageContext);
+                pageContextFromHooks = await getPageContextFromHooks_isNotHydration(pageContext, false);
             }
             catch (err) {
-                await renderErrorPage(err);
+                await renderErrorPage({ err });
                 return;
             }
             if (isRenderOutdated())
                 return;
+            if (isRenderFailure in pageContextFromHooks) {
+                await renderErrorPage({ pageContextError: pageContextFromHooks });
+                return;
+            }
+            assert(!('urlOriginal' in pageContextFromHooks));
+            objectAssign(pageContext, pageContextFromHooks);
+            // Render page view
+            await renderPageView(pageContext);
         }
-        const { pageContextFromHooks } = renderState;
-        assert(pageContextFromHooks);
-        assert(!('urlOriginal' in pageContextFromHooks));
-        objectAssign(pageContext, pageContextFromHooks);
-        await renderPageView(pageContext);
     }
     async function getPageContextBegin() {
         const pageContext = await createPageContext(urlOriginal);
@@ -133,88 +173,112 @@ async function renderPageClientSide(renderArgs) {
         }
         return pageContext;
     }
-    async function renderErrorPage(err) {
+    async function renderErrorPage(args) {
         const pageContext = await getPageContextBegin();
         if (isRenderOutdated())
             return;
-        assert(err);
-        assert(!('errorWhileRendering' in pageContext));
-        pageContext.errorWhileRendering = err;
-        if (!isAbortError(err)) {
-            // We don't swallow 404 errors:
-            //  - On the server-side, Vike swallows / doesn't show any 404 error log because it's expected that a user may go to some random non-existent URL. (We don't want to flood the app's error tracking with 404 logs.)
-            //  - On the client-side, if the user navigates to a 404 then it means that the UI has a broken link. (It isn't expected that users can go to some random URL using the client-side router, as it would require, for example, the user to manually change the URL of a link by manually manipulating the DOM which highly unlikely.)
-            console.error(err);
-        }
-        else {
-            // We swallow throw redirect()/render() called by client-side hooks onBeforeRender()/data()/guard()
-            // We handle the abort error down below.
+        if (args.pageContextError) {
+            objectAssign(pageContext, args.pageContextError);
         }
-        if (shouldSwallowAndInterrupt(err, pageContext, isFirstRender))
-            return;
-        if (isAbortError(err)) {
-            const errAbort = err;
-            logAbortErrorHandled(err, !import.meta.env.DEV, pageContext);
-            const pageContextAbort = errAbort._pageContextAbort;
-            // throw render('/some-url')
-            if (pageContextAbort._urlRewrite) {
-                await renderPageClientSide({
-                    ...renderArgs,
-                    scrollTarget: 'scroll-to-top-or-hash',
-                    pageContextsFromRewrite: [...pageContextsFromRewrite, pageContextAbort]
-                });
+        if ('err' in args) {
+            const { err } = args;
+            assert(err);
+            assert(!('errorWhileRendering' in pageContext));
+            pageContext.errorWhileRendering = err;
+            if (shouldSwallowAndInterrupt(err))
                 return;
+            if (!isAbortError(err)) {
+                // We don't swallow 404 errors:
+                //  - On the server-side, Vike swallows / doesn't show any 404 error log because it's expected that a user may go to some random non-existent URL. (We don't want to flood the app's error tracking with 404 logs.)
+                //  - On the client-side, if the user navigates to a 404 then it means that the UI has a broken link. (It isn't expected that users can go to some random URL using the client-side router, as it would require, for example, the user to manually change the URL of a link by manually manipulating the DOM which highly unlikely.)
+                console.error(err);
             }
-            // throw redirect('/some-url')
-            if (pageContextAbort._urlRedirect) {
-                const urlRedirect = pageContextAbort._urlRedirect.url;
-                if (urlRedirect.startsWith('http')) {
-                    // External redirection
-                    window.location.href = urlRedirect;
-                    return;
-                }
-                else {
+            else {
+                // We swallow throw redirect()/render() called by client-side hooks onBeforeRender()/data()/guard()
+                // We handle the abort error down below.
+            }
+            if (isAbortError(err)) {
+                const errAbort = err;
+                logAbortErrorHandled(err, !import.meta.env.DEV, pageContext);
+                const pageContextAbort = errAbort._pageContextAbort;
+                // throw render('/some-url')
+                if (pageContextAbort._urlRewrite) {
                     await renderPageClientSide({
                         ...renderArgs,
                         scrollTarget: 'scroll-to-top-or-hash',
-                        urlOriginal: urlRedirect,
-                        overwriteLastHistoryEntry: false,
-                        isBackwardNavigation: false,
-                        redirectCount: redirectCount + 1
+                        pageContextsFromRewrite: [...pageContextsFromRewrite, pageContextAbort]
                     });
+                    return;
+                }
+                // throw redirect('/some-url')
+                if (pageContextAbort._urlRedirect) {
+                    const urlRedirect = pageContextAbort._urlRedirect.url;
+                    if (urlRedirect.startsWith('http')) {
+                        // External redirection
+                        window.location.href = urlRedirect;
+                        return;
+                    }
+                    else {
+                        await renderPageClientSide({
+                            ...renderArgs,
+                            scrollTarget: 'scroll-to-top-or-hash',
+                            urlOriginal: urlRedirect,
+                            overwriteLastHistoryEntry: false,
+                            isBackwardNavigation: false,
+                            redirectCount: redirectCount + 1
+                        });
+                    }
+                    return;
+                }
+                // throw render(statusCode)
+                assert(pageContextAbort.abortStatusCode);
+                assert(!('urlOriginal' in pageContextAbort));
+                objectAssign(pageContext, pageContextAbort);
+                if (pageContextAbort.abortStatusCode === 404) {
+                    objectAssign(pageContext, { is404: true });
                 }
-                return;
             }
-            // throw render(statusCode)
-            assert(pageContextAbort.abortStatusCode);
-            assert(!('urlOriginal' in pageContextAbort));
-            objectAssign(pageContext, pageContextAbort);
-            if (pageContextAbort.abortStatusCode === 404) {
-                objectAssign(pageContext, { is404: true });
+            else {
+                objectAssign(pageContext, { is404: false });
             }
         }
-        else {
-            objectAssign(pageContext, { is404: false });
+        const errorPageId = getErrorPageId(pageContext._pageFilesAll, pageContext._pageConfigs);
+        if (!errorPageId)
+            throw new Error('No error page defined.');
+        objectAssign(pageContext, {
+            _pageId: errorPageId
+        });
+        try {
+            objectAssign(pageContext, await loadUserFilesClientSide(pageContext._pageId, pageContext._pageFilesAll, pageContext._pageConfigs));
+        }
+        catch (err) {
+            if (handleErrorFetchingStaticAssets(err, pageContext, isHydrationRender)) {
+                return;
+            }
+            else {
+                throw err;
+            }
         }
+        if (isRenderOutdated())
+            return;
         let pageContextFromHooks;
         try {
-            pageContextFromHooks = await getPageContextFromHooks_errorPage(pageContext);
+            pageContextFromHooks = await getPageContextFromHooks_isNotHydration(pageContext, true);
         }
         catch (errErrorPage) {
             // - When user hasn't defined a `_error.page.js` file
             // - Some Vike unpexected internal error
-            if (shouldSwallowAndInterrupt(errErrorPage, pageContext, isFirstRender))
+            if (shouldSwallowAndInterrupt(errErrorPage))
                 return;
-            if (isSameErrorMessage(err, errErrorPage)) {
+            if (!isSameErrorMessage(args.err, errErrorPage)) {
                 /* When we can't render the error page, we prefer showing a blank page over letting the server-side try because otherwise:
                    - We risk running into an infinite loop of reloads which would overload the server.
                    - An infinite reloading page is a even worse UX than a blank page.
                 serverSideRouteTo(urlOriginal)
                 */
-                return;
+                console.error(errErrorPage);
             }
-            // We `throw err2` instead of `console.error(err2)` so that, when using `navigate()`, the error propagates to the user `navigate()` call
-            throw errErrorPage;
+            return;
         }
         if (isRenderOutdated())
             return;
@@ -224,20 +288,6 @@ async function renderPageClientSide(renderArgs) {
         await renderPageView(pageContext, true);
     }
     async function renderPageView(pageContext, isErrorPage) {
-        // Set global onPageTransitionStart()
-        assertHook(pageContext, 'onPageTransitionStart');
-        const onPageTransitionStartHook = getHook(pageContext, 'onPageTransitionStart');
-        globalObject.onPageTransitionStart = onPageTransitionStartHook;
-        // Set global hydrationCanBeAborted
-        if (pageContext.exports.hydrationCanBeAborted) {
-            setHydrationCanBeAborted();
-        }
-        else {
-            assertWarning(!isReact(), 'You seem to be using React; we recommend setting hydrationCanBeAborted to true, see https://vike.dev/hydrationCanBeAborted', { onlyOnce: true });
-        }
-        // There wasn't any `await` but result may change because we just called setHydrationCanBeAborted()
-        if (isRenderOutdated())
-            return;
         // We use globalObject.renderPromise in order to ensure that there is never two concurrent onRenderClient() calls
         if (globalObject.renderPromise) {
             // Make sure that the previous render has finished
@@ -255,7 +305,7 @@ async function renderPageClientSide(renderArgs) {
             }
             catch (err) {
                 if (!isErrorPage) {
-                    renderErrorPage(err);
+                    renderErrorPage({ err });
                 }
                 else {
                     throw err;
@@ -267,33 +317,53 @@ async function renderPageClientSide(renderArgs) {
         await globalObject.renderPromise;
         assert(globalObject.renderPromise === undefined);
         /* We don't abort in order to ensure that onHydrationEnd() is called: we abort only after onHydrationEnd() is called.
-      if (isRenderOutdated(true)) return
-      */
+        if (isRenderOutdated(true)) return
+        */
         // onHydrationEnd()
-        if (isFirstRender) {
+        if (isHydrationRender) {
             assertHook(pageContext, 'onHydrationEnd');
             const hook = getHook(pageContext, 'onHydrationEnd');
             if (hook) {
                 const { hookFn } = hook;
-                await executeHook(() => hookFn(pageContext), hook);
+                try {
+                    await executeHook(() => hookFn(pageContext), hook);
+                }
+                catch (err) {
+                    if (!isErrorPage) {
+                        renderErrorPage({ err });
+                    }
+                    else {
+                        throw err;
+                    }
+                }
                 if (isRenderOutdated(true))
                     return;
             }
         }
-        // We abort only after onHydrationEnd() is called
+        // We abort *after* onHydrationEnd() is called
         if (isRenderOutdated(true))
             return;
         // onPageTransitionEnd()
-        if (callTransitionHooks) {
+        if (globalObject.isTransitioning) {
+            globalObject.isTransitioning = undefined;
             assertHook(pageContext, 'onPageTransitionEnd');
             const hook = getHook(pageContext, 'onPageTransitionEnd');
             if (hook) {
                 const { hookFn } = hook;
-                await executeHook(() => hookFn(pageContext), hook);
+                try {
+                    await executeHook(() => hookFn(pageContext), hook);
+                }
+                catch (err) {
+                    if (!isErrorPage) {
+                        renderErrorPage({ err });
+                    }
+                    else {
+                        throw err;
+                    }
+                }
                 if (isRenderOutdated(true))
                     return;
             }
-            globalObject.isTransitioning = undefined;
         }
         // Page scrolling
         setScrollPosition(scrollTarget);
@@ -308,18 +378,16 @@ function changeUrl(url, overwriteLastHistoryEntry) {
     pushHistory(url, overwriteLastHistoryEntry);
     updateState();
 }
-function shouldSwallowAndInterrupt(err, pageContext, isFirstRender) {
+function shouldSwallowAndInterrupt(err) {
     if (isServerSideRouted(err))
         return true;
-    if (handleErrorFetchingStaticAssets(err, pageContext, isFirstRender))
-        return true;
     return false;
 }
-function handleErrorFetchingStaticAssets(err, pageContext, isFirstRender) {
+function handleErrorFetchingStaticAssets(err, pageContext, isHydrationRender) {
     if (!isErrorFetchingStaticAssets(err)) {
         return false;
     }
-    if (isFirstRender) {
+    if (isHydrationRender) {
         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.)
@@ -371,7 +439,7 @@ function getIsRenderOutdated() {
     return {
         isRenderOutdated,
         setHydrationCanBeAborted,
-        isFirstRender: renderNumber === 1
+        isHydrationRender: renderNumber === 1
     };
 }
 function getRenderCount() {

package/dist/esm/client/server-routing-runtime/getPageContext.d.ts

@@ -1,11 +1,11 @@
 export { getPageContext };
 declare function getPageContext(): Promise<{
     _pageId: string;
-    _hasPageContextFromServer: true;
 } & {
     isHydration: true;
     isBackwardNavigation: null;
-    _hasPageContextFromClient: boolean;
+    _hasPageContextFromServer: true;
+    _hasPageContextFromClient: false;
 } & {
     _pageFilesAll: import("../../shared/getPageFiles/getPageFileObject.js").PageFile[];
     _pageConfigs: import("../../shared/page-configs/PageConfig.js").PageConfigRuntime[];

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

@@ -1,7 +1,7 @@
 import { assertUsage, assertWarning, getCurrentUrl, objectAssign } from './utils.js';
 import { getPageContextSerializedInHtml } from '../shared/getPageContextSerializedInHtml.js';
 import { getPageFilesAll } from '../../shared/getPageFiles.js';
-import { loadPageFilesClientSide } from '../shared/loadPageFilesClientSide.js';
+import { loadUserFilesClientSide } from '../shared/loadUserFilesClientSide.js';
 export { getPageContext };
 const urlFirst = getCurrentUrl({ withoutHash: true });
 async function getPageContext() {
@@ -9,9 +9,10 @@ async function getPageContext() {
     objectAssign(pageContext, {
         isHydration: true,
         isBackwardNavigation: null,
+        _hasPageContextFromServer: true,
         _hasPageContextFromClient: false
     });
-    objectAssign(pageContext, await loadPageFiles(pageContext._pageId));
+    objectAssign(pageContext, await loadPageUserFiles(pageContext._pageId));
     assertPristineUrl();
     return pageContext;
 }
@@ -19,14 +20,14 @@ 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 loadPageFiles(pageId) {
+async function loadPageUserFiles(pageId) {
     const pageContextAddendum = {};
     const { pageFilesAll, pageConfigs } = await getPageFilesAll(true);
     objectAssign(pageContextAddendum, {
         _pageFilesAll: pageFilesAll,
         _pageConfigs: pageConfigs
     });
-    objectAssign(pageContextAddendum, await loadPageFilesClientSide(pageId, pageContextAddendum));
+    objectAssign(pageContextAddendum, await loadUserFilesClientSide(pageId, pageContextAddendum._pageFilesAll, pageContextAddendum._pageConfigs));
     pageFilesAll
         .filter((p) => p.fileType !== '.page.server')
         .forEach((p) => {

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

@@ -1,5 +1,4 @@
 export { getPageContextSerializedInHtml };
 declare function getPageContextSerializedInHtml(): {
     _pageId: string;
-    _hasPageContextFromServer: true;
 };

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

@@ -1,5 +1,5 @@
 import { parse } from '@brillout/json-serializer/parse';
-import { hasProp, assert, assertUsage, objectAssign } from '../server-routing-runtime/utils.js';
+import { hasProp, assert, assertUsage } from '../server-routing-runtime/utils.js';
 export { getPageContextSerializedInHtml };
 function getPageContextSerializedInHtml() {
     // elem should exist because:
@@ -15,8 +15,5 @@ function getPageContextSerializedInHtml() {
     assert(pageContextJson);
     const pageContextSerializedInHtml = parse(pageContextJson);
     assert(hasProp(pageContextSerializedInHtml, '_pageId', 'string'));
-    objectAssign(pageContextSerializedInHtml, {
-        _hasPageContextFromServer: true
-    });
     return pageContextSerializedInHtml;
 }

package/dist/esm/client/shared/{loadPageFilesClientSide.d.ts → loadUserFilesClientSide.d.ts}

@@ -1,13 +1,14 @@
-export { loadPageFilesClientSide };
+export { loadUserFilesClientSide };
 export { isErrorFetchingStaticAssets };
-export type { PageContextPageFiles };
+export type { PageContextUserFiles };
 import { type PageFile, type PageContextExports } from '../../shared/getPageFiles.js';
 import type { PageConfigRuntime } from '../../shared/page-configs/PageConfig.js';
-type PageContextPageFiles = {
+type PageContextUserFilesLoaded = PageContextExports & {
+    _pageFilesLoaded: PageFile[];
+};
+type PageContextUserFiles = {
     _pageFilesAll: PageFile[];
     _pageConfigs: PageConfigRuntime[];
 };
-declare function loadPageFilesClientSide(pageId: string, pageContext: PageContextPageFiles): Promise<PageContextExports & {
-    _pageFilesLoaded: PageFile[];
-}>;
+declare function loadUserFilesClientSide(pageId: string, pageFilesAll: PageFile[], pageConfigs: PageConfigRuntime[]): Promise<PageContextUserFilesLoaded>;
 declare function isErrorFetchingStaticAssets(err: unknown): boolean;

package/dist/esm/client/shared/{loadPageFilesClientSide.js → loadUserFilesClientSide.js}

@@ -1,12 +1,12 @@
-export { loadPageFilesClientSide };
+export { loadUserFilesClientSide };
 export { isErrorFetchingStaticAssets };
 import { getPageFilesClientSide, getExports } from '../../shared/getPageFiles.js';
 import { findPageConfig } from '../../shared/page-configs/findPageConfig.js';
 import { loadConfigValues } from '../../shared/page-configs/loadConfigValues.js';
 const stamp = '__whileFetchingAssets';
-async function loadPageFilesClientSide(pageId, pageContext) {
-    const pageFilesClientSide = getPageFilesClientSide(pageContext._pageFilesAll, pageId);
-    const pageConfig = findPageConfig(pageContext._pageConfigs, pageId);
+async function loadUserFilesClientSide(pageId, pageFilesAll, pageConfigs) {
+    const pageFilesClientSide = getPageFilesClientSide(pageFilesAll, pageId);
+    const pageConfig = findPageConfig(pageConfigs, pageId);
     let pageConfigLoaded;
     // @ts-ignore Since dist/cjs/client/ is never used, we can ignore this error.
     const isDev = import.meta.env.DEV;

package/dist/esm/node/cli/bin.js

@@ -1,6 +1,6 @@
 import { cac } from 'cac';
 import { resolve } from 'path';
-import { prerenderFromCLI, prerenderForceExit } from '../prerender/runPrerender.js';
+import { runPrerenderFromCLI, runPrerender_forceExit } from '../prerender/runPrerender.js';
 import { projectInfo, assertUsage } from './utils.js';
 const cli = cac(projectInfo.projectName);
 cli
@@ -10,8 +10,8 @@ cli
     assertOptions();
     const { partial, noExtraDir, base, parallel, outDir, configFile } = options;
     const root = options.root && resolve(options.root);
-    await prerenderFromCLI({ partial, noExtraDir, base, root, parallel, outDir, configFile });
-    prerenderForceExit();
+    await runPrerenderFromCLI({ partial, noExtraDir, base, root, parallel, outDir, configFile });
+    runPrerender_forceExit();
 });
 function assertOptions() {
     // Using process.argv because cac convert names to camelCase