vike 0.4.152-commit-3d25618 → 0.4.152-commit-6f928f9

package/dist/cjs/node/runtime/html/stream.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.isStreamWritableNode = exports.isStreamWritableWeb = exports.streamPipeNodeToString = exports.streamReadableWebToString = exports.inferStreamName = exports.getStreamName = exports.isStreamReadableNode = exports.isStreamReadableWeb = exports.isStreamPipeNode = exports.isStreamPipeWeb = exports.isStream = exports.pipeToStreamWritableWeb = exports.pipeToStreamWritableNode = exports.getStreamReadableWeb = exports.getStreamReadableNode = exports.pipeNodeStream = exports.pipeWebStream = exports.pipeStream = exports.stampPipe = exports.streamToString = exports.processStream = void 0;
 const utils_js_1 = require("../utils.js");
 const react_streaming_js_1 = require("./stream/react-streaming.js");
+const import_1 = require("@brillout/import");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const debug = (0, utils_js_1.createDebugger)('vike:stream');
 function isStreamReadableWeb(thing) {
@@ -757,7 +758,7 @@ function encodeForWebStream(thing) {
 }
 // Because of Cloudflare Workers, we cannot statically import the `stream` module, instead we dynamically import it.
 async function loadStreamNodeModule() {
-    const streamModule = await (0, utils_js_1.dynamicImport)('stream');
+    const streamModule = (await (0, import_1.import_)('stream')).default;
     const { Readable, Writable } = streamModule;
     return { Readable, Writable };
 }

package/dist/cjs/node/runtime/renderPage/isNewError.js

@@ -7,7 +7,7 @@ const globalObject = (0, utils_js_1.getGlobalObject)('runtime/renderPage/isNewEr
 });
 function isNewError(errErrorPage, errNominalPage) {
     (0, utils_js_1.warnIfErrorIsNotObject)(errErrorPage);
-    return !(0, utils_js_1.isEquivalentError)(errNominalPage, errErrorPage) || !hasAlreadyLogged(errNominalPage);
+    return !(0, utils_js_1.isSameErrorMessage)(errNominalPage, errErrorPage) || !hasAlreadyLogged(errNominalPage);
 }
 exports.isNewError = isNewError;
 function hasAlreadyLogged(err) {

package/dist/cjs/node/runtime/utils.js

@@ -42,7 +42,7 @@ __exportStar(require("../../utils/filesystemPathHandling.js"), exports);
 __exportStar(require("../../utils/getOutDirs.js"), exports);
 __exportStar(require("../../utils/capitalizeFirstLetter.js"), exports);
 __exportStar(require("../../utils/debugGlob.js"), exports);
-__exportStar(require("../../utils/isEquivalentError.js"), exports);
+__exportStar(require("../../utils/isSameErrorMessage.js"), exports);
 __exportStar(require("../../utils/styleFileRE.js"), exports);
 __exportStar(require("../../utils/isPropertyGetter.js"), exports);
 __exportStar(require("../../utils/debug.js"), exports);
@@ -64,7 +64,6 @@ __exportStar(require("../../utils/path-shim.js"), exports);
 __exportStar(require("../../utils/nodeEnv.js"), exports);
 __exportStar(require("../../utils/isHtml.js"), exports);
 __exportStar(require("../../utils/warnIfErrorIsNotObject.js"), exports);
-__exportStar(require("../../utils/dynamicImport.js"), exports);
 __exportStar(require("../../utils/stripAnsi.js"), exports);
 __exportStar(require("../../utils/getTerminWidth.js"), exports);
 __exportStar(require("../../utils/truncateString.js"), exports);

package/dist/cjs/utils/isSameErrorMessage.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSameErrorMessage = void 0;
+const isObject_js_1 = require("./isObject.js");
+function isSameErrorMessage(err1, err2) {
+    if (!(0, isObject_js_1.isObject)(err1) || !(0, isObject_js_1.isObject)(err2))
+        return false;
+    return err1.message === err2.message;
+}
+exports.isSameErrorMessage = isSameErrorMessage;

package/dist/cjs/utils/projectInfo.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PROJECT_VERSION = exports.projectInfo = void 0;
 const assertSingleInstance_js_1 = require("./assertSingleInstance.js");
-const PROJECT_VERSION = '0.4.152-commit-3d25618';
+const PROJECT_VERSION = '0.4.152-commit-6f928f9';
 exports.PROJECT_VERSION = PROJECT_VERSION;
 const projectInfo = {
     projectName: 'Vike',

package/dist/esm/client/client-routing-runtime/createPageContext.d.ts

@@ -5,7 +5,6 @@ declare function createPageContext(urlOriginal: string): Promise<{
     _urlHandler: null;
     _urlRewrite: null;
     _baseServer: string;
-    _isProduction: boolean;
     _pageFilesAll: import("../../shared/getPageFiles/getPageFileObject.js").PageFile[];
     _pageConfigs: import("../../shared/page-configs/PageConfig.js").PageConfigRuntime[];
     _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;

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

@@ -13,15 +13,12 @@ async function createPageContext(urlOriginal) {
     const { pageRoutes, onBeforeRouteHook } = await loadPageRoutes(pageFilesAll, pageConfigs, pageConfigGlobal, allPageIds);
     const baseServer = getBaseServer();
     assert(isBaseServer(baseServer));
-    // @ts-ignore Since dist/cjs/client/ is never used, we can ignore this error.
-    const isProd = import.meta.env.PROD;
     const pageContext = {
         urlOriginal,
         _objectCreatedByVike: true,
         _urlHandler: null,
         _urlRewrite: null,
         _baseServer: baseServer,
-        _isProduction: isProd,
         _pageFilesAll: pageFilesAll,
         _pageConfigs: pageConfigs,
         _pageConfigGlobal: pageConfigGlobal,

package/dist/esm/client/client-routing-runtime/getPageContextFromHooks.d.ts

@@ -1,7 +1,7 @@
 export { getPageContextFromHooks_firstRender };
 export { getPageContextFromHooks_uponNavigation };
 export { getPageContextFromHooks_errorPage };
-export { isAlreadyServerSideRouted };
+export { isServerSideRouted as isServerSideRouted };
 export type { PageContextFromHooks };
 import type { PageContextExports, PageFile } from '../../shared/getPageFiles.js';
 import type { PageContextUrlComputedPropsInternal } from '../../shared/addUrlComputedProps.js';
@@ -36,4 +36,4 @@ declare function getPageContextFromHooks_errorPage(pageContext: {
 declare function getPageContextFromHooks_uponNavigation(pageContext: {
     _pageId: string;
 } & PageContext): Promise<PageContextFromHooks>;
-declare function isAlreadyServerSideRouted(err: unknown): boolean;
+declare function isServerSideRouted(err: unknown): boolean;

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

@@ -1,7 +1,7 @@
 export { getPageContextFromHooks_firstRender };
 export { getPageContextFromHooks_uponNavigation };
 export { getPageContextFromHooks_errorPage };
-export { isAlreadyServerSideRouted };
+export { isServerSideRouted as isServerSideRouted };
 import { assert, assertUsage, hasProp, objectAssign, getProjectError, serverSideRouteTo, executeHook, isObject, getGlobalObject } from './utils.js';
 import { parse } from '@brillout/json-serializer/parse';
 import { getPageContextSerializedInHtml } from '../shared/getPageContextSerializedInHtml.js';
@@ -237,7 +237,7 @@ async function fetchPageContextFromServer(pageContext) {
         // Static hosts + page doesn't exist
         if (!isCorrect && response.status === 404) {
             serverSideRouteTo(pageContext.urlOriginal);
-            throw AlreadyServerSideRouted();
+            throw ServerSideRouted();
         }
         assertUsage(isCorrect, `Wrong Content-Type for ${pageContextUrl}: it should be ${contentTypeCorrect} but it's ${contentType} instead. Make sure to properly use pageContext.httpResponse.headers, see https://vike.dev/renderPage`);
     }
@@ -254,10 +254,10 @@ async function fetchPageContextFromServer(pageContext) {
     removeBuiltInOverrides(pageContextFromServer);
     return pageContextFromServer;
 }
-function isAlreadyServerSideRouted(err) {
+function isServerSideRouted(err) {
     return isObject(err) && !!err._alreadyServerSideRouted;
 }
-function AlreadyServerSideRouted() {
+function ServerSideRouted() {
     const err = new Error("Page doesn't exist");
     Object.assign(err, { _alreadyServerSideRouted: true });
     return err;

package/dist/esm/client/client-routing-runtime/prefetch/getPrefetchSettings.d.ts

@@ -1,10 +1,8 @@
 export { getPrefetchSettings };
-export type { PrefetchStaticAssets };
+import type { PrefetchStaticAssets } from '../../../shared/types/PrefetchStaticAssets.js';
 type PageContextPrefetch = {
     exports: Record<string, unknown>;
-    _isProduction: boolean;
 };
-type PrefetchStaticAssets = false | 'hover' | 'viewport';
 type PrefetchSettings = {
     prefetchStaticAssets: PrefetchStaticAssets;
 };

package/dist/esm/client/client-routing-runtime/prefetch/getPrefetchSettings.js

@@ -2,7 +2,7 @@ export { getPrefetchSettings };
 import { assert, assertUsage, assertInfo, assertWarning, isPlainObject } from '../utils.js';
 function getPrefetchSettings(pageContext, linkTag) {
     let prefetchStaticAssets = getPrefetchStaticAssets(pageContext, linkTag);
-    if (prefetchStaticAssets === 'viewport' && !pageContext._isProduction) {
+    if (prefetchStaticAssets === 'viewport' && import.meta.env.DEV) {
         assertInfo(false, 'Viewport prefetching is disabled in development', { onlyOnce: true });
         prefetchStaticAssets = 'hover';
     }

package/dist/esm/client/client-routing-runtime/prefetch.d.ts

@@ -10,6 +10,5 @@ export { addLinkPrefetchHandlers };
 declare function prefetch(url: string): Promise<void>;
 declare function addLinkPrefetchHandlers(pageContext: {
     exports: Record<string, unknown>;
-    _isProduction: boolean;
     urlPathname: string;
 }): void;

package/dist/esm/client/client-routing-runtime/renderPageClientSide.d.ts

@@ -1,7 +1,7 @@
 export { renderPageClientSide };
 export { getRenderCount };
 export { disableClientRouting };
-import { PageContextFromRewrite } from '../../shared/route/abort.js';
+import { type PageContextFromRewrite } from '../../shared/route/abort.js';
 import { type ScrollTarget } from './setScrollPosition.js';
 type RenderArgs = {
     scrollTarget: ScrollTarget;

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

@@ -1,8 +1,8 @@
 export { renderPageClientSide };
 export { getRenderCount };
 export { disableClientRouting };
-import { assert, getCurrentUrl, isEquivalentError, objectAssign, serverSideRouteTo, getGlobalObject, executeHook, hasProp } from './utils.js';
-import { getPageContextFromHooks_errorPage, getPageContextFromHooks_firstRender, getPageContextFromHooks_uponNavigation, isAlreadyServerSideRouted } from './getPageContextFromHooks.js';
+import { assert, getCurrentUrl, isSameErrorMessage, objectAssign, serverSideRouteTo, getGlobalObject, executeHook, hasProp } from './utils.js';
+import { getPageContextFromHooks_errorPage, getPageContextFromHooks_firstRender, getPageContextFromHooks_uponNavigation, isServerSideRouted } from './getPageContextFromHooks.js';
 import { createPageContext } from './createPageContext.js';
 import { addLinkPrefetchHandlers } from './prefetch.js';
 import { assertInfo, assertWarning, isReact } from './utils.js';
@@ -19,113 +19,127 @@ import { browserNativeScrollRestoration_disable, setInitialRenderIsDone } from '
 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 { abortRender, setHydrationCanBeAborted, isFirstRender } = getAbortRender();
+    const { isRenderOutdated, setHydrationCanBeAborted, isFirstRender } = getIsRenderOutdated();
+    const callTransitionHooks = !isFirstRender;
     assert(isClientSideNavigation === !isFirstRender);
     assertNoInfiniteAbortLoop(pageContextsFromRewrite.length, redirectCount);
     if (globalObject.clientRoutingIsDisabled) {
         serverSideRouteTo(urlOriginal);
         return;
     }
-    const pageContext = await createPageContext(urlOriginal);
-    if (abortRender())
-        return;
-    objectAssign(pageContext, {
-        isBackwardNavigation,
-        isClientSideNavigation
-    });
-    {
-        const pageContextFromAllRewrites = getPageContextFromAllRewrites(pageContextsFromRewrite);
-        objectAssign(pageContext, pageContextFromAllRewrites);
-    }
-    let renderState = {};
-    const onError = (err) => {
-        assert(err);
-        assert(!('err' in renderState));
-        assert(!('errorWhileRendering' in pageContext));
-        renderState.err = err;
-        pageContext.errorWhileRendering = err;
-    };
-    if (!isFirstRender) {
-        // Route
-        try {
-            renderState = { pageContextFromRoute: await route(pageContext) };
-        }
-        catch (err) {
-            onError(err);
-        }
-        if (abortRender())
+    await renderPageNominal();
+    return;
+    async function renderPageNominal() {
+        const pageContext = await getPageContextBegin();
+        if (isRenderOutdated())
             return;
-        // Check whether rendering should be skipped
-        if (renderState.pageContextFromRoute) {
-            const { pageContextFromRoute } = renderState;
-            objectAssign(pageContext, pageContextFromRoute);
-            let isClientRoutable;
-            if (!pageContextFromRoute._pageId) {
-                isClientRoutable = false;
-            }
-            else {
-                isClientRoutable = await isClientSideRoutable(pageContextFromRoute._pageId, pageContext);
-                if (abortRender())
-                    return;
+        let renderState = {};
+        if (!isFirstRender) {
+            // Route
+            try {
+                renderState = { pageContextFromRoute: await route(pageContext) };
             }
-            if (!isClientRoutable) {
-                serverSideRouteTo(urlOriginal);
+            catch (err) {
+                await renderErrorPage(err);
                 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
+            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
+                    return;
+                }
             }
         }
-    }
-    // onPageTransitionStart()
-    const callTransitionHooks = !isFirstRender;
-    if (callTransitionHooks) {
-        if (!globalObject.isTransitioning) {
-            if (globalObject.onPageTransitionStart) {
-                const hook = globalObject.onPageTransitionStart;
-                const { hookFn } = hook;
-                await executeHook(() => hookFn(pageContext), hook);
+        // onPageTransitionStart()
+        if (callTransitionHooks) {
+            if (!globalObject.isTransitioning) {
+                if (globalObject.onPageTransitionStart) {
+                    const hook = globalObject.onPageTransitionStart;
+                    const { hookFn } = hook;
+                    await executeHook(() => hookFn(pageContext), hook);
+                }
+                globalObject.isTransitioning = true;
+                if (isRenderOutdated())
+                    return;
             }
-            globalObject.isTransitioning = true;
-            if (abortRender())
-                return;
-        }
-    }
-    if (isFirstRender) {
-        assert(!renderState.pageContextFromRoute);
-        assert(!renderState.err);
-        try {
-            renderState.pageContextFromHooks = await getPageContextFromHooks_firstRender(pageContext);
         }
-        catch (err) {
-            onError(err);
+        if (isFirstRender) {
+            assert(!renderState.pageContextFromRoute);
+            try {
+                renderState.pageContextFromHooks = await getPageContextFromHooks_firstRender(pageContext);
+            }
+            catch (err) {
+                await renderErrorPage(err);
+                return;
+            }
+            if (isRenderOutdated())
+                return;
         }
-        if (abortRender())
-            return;
-    }
-    else {
-        if (!renderState.err) {
+        else {
             const { pageContextFromRoute } = renderState;
             assert(pageContextFromRoute);
             assert(pageContextFromRoute._pageId);
             assert(hasProp(pageContextFromRoute, '_pageId', 'string')); // Help TS
+            assert(!('urlOriginal' in pageContextFromRoute));
             objectAssign(pageContext, pageContextFromRoute);
             try {
                 renderState.pageContextFromHooks = await getPageContextFromHooks_uponNavigation(pageContext);
             }
             catch (err) {
-                onError(err);
+                await renderErrorPage(err);
+                return;
             }
-            if (abortRender())
+            if (isRenderOutdated())
                 return;
         }
+        const { pageContextFromHooks } = renderState;
+        assert(pageContextFromHooks);
+        assert(!('urlOriginal' in pageContextFromHooks));
+        objectAssign(pageContext, pageContextFromHooks);
+        await renderPageView(pageContext);
+    }
+    async function getPageContextBegin() {
+        const pageContext = await createPageContext(urlOriginal);
+        objectAssign(pageContext, {
+            isBackwardNavigation,
+            isClientSideNavigation
+        });
+        {
+            const pageContextFromAllRewrites = getPageContextFromAllRewrites(pageContextsFromRewrite);
+            assert(!('urlOriginal' in pageContextFromAllRewrites));
+            objectAssign(pageContext, pageContextFromAllRewrites);
+        }
+        return pageContext;
     }
-    if ('err' in renderState) {
-        const { err } = renderState;
+    async function renderErrorPage(err) {
+        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.)
@@ -133,14 +147,14 @@ async function renderPageClientSide(renderArgs) {
             console.error(err);
         }
         else {
-            // We swallow throw redirect()/render() called by client-side hooks onBeforeRender(), data() and guard()
+            // We swallow throw redirect()/render() called by client-side hooks onBeforeRender()/data()/guard()
             // We handle the abort error down below.
         }
         if (shouldSwallowAndInterrupt(err, pageContext, isFirstRender))
             return;
         if (isAbortError(err)) {
             const errAbort = err;
-            logAbortErrorHandled(err, pageContext._isProduction, pageContext);
+            logAbortErrorHandled(err, !import.meta.env.DEV, pageContext);
             const pageContextAbort = errAbort._pageContextAbort;
             // throw render('/some-url')
             if (pageContextAbort._urlRewrite) {
@@ -173,6 +187,7 @@ async function renderPageClientSide(renderArgs) {
             }
             // throw render(statusCode)
             assert(pageContextAbort.abortStatusCode);
+            assert(!('urlOriginal' in pageContextAbort));
             objectAssign(pageContext, pageContextAbort);
             if (pageContextAbort.abortStatusCode === 404) {
                 objectAssign(pageContext, { is404: true });
@@ -181,99 +196,110 @@ async function renderPageClientSide(renderArgs) {
         else {
             objectAssign(pageContext, { is404: false });
         }
+        let pageContextFromHooks;
         try {
-            renderState.pageContextFromHooks = await getPageContextFromHooks_errorPage(pageContext);
+            pageContextFromHooks = await getPageContextFromHooks_errorPage(pageContext);
         }
-        catch (err2) {
+        catch (errErrorPage) {
             // - When user hasn't defined a `_error.page.js` file
-            // - Some unpexected vike internal error
-            if (shouldSwallowAndInterrupt(err2, pageContext, isFirstRender))
+            // - Some Vike unpexected internal error
+            if (shouldSwallowAndInterrupt(errErrorPage, pageContext, isFirstRender))
                 return;
-            if (!isFirstRender) {
-                setTimeout(() => {
-                    // We let the server show the 404 page
-                    window.location.pathname = urlOriginal;
-                }, 0);
-            }
-            if (!isEquivalentError(err, err2)) {
-                throw err2;
-            }
-            else {
-                // Abort
+            if (isSameErrorMessage(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;
             }
+            // We `throw err2` instead of `console.error(err2)` so that, when using `navigate()`, the error propagates to the user `navigate()` call
+            throw errErrorPage;
         }
-        if (abortRender())
+        if (isRenderOutdated())
             return;
+        assert(pageContextFromHooks);
+        assert(!('urlOriginal' in pageContextFromHooks));
+        objectAssign(pageContext, pageContextFromHooks);
+        await renderPageView(pageContext, true);
     }
-    const { pageContextFromHooks } = renderState;
-    assert(pageContextFromHooks);
-    objectAssign(pageContext, pageContextFromHooks);
-    // 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 (abortRender())
-        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
-        await globalObject.renderPromise;
-        assert(globalObject.renderPromise === undefined);
-        if (abortRender())
+    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;
-    }
-    changeUrl(urlOriginal, overwriteLastHistoryEntry);
-    globalObject.previousPageContext = pageContext;
-    assert(globalObject.renderPromise === undefined);
-    globalObject.renderPromise = (async () => {
-        await executeOnRenderClientHook(pageContext, true);
-        addLinkPrefetchHandlers(pageContext);
-        globalObject.renderPromise = undefined;
-    })();
-    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 (abortRender(true)) return
-    */
-    // onHydrationEnd()
-    if (isFirstRender) {
-        assertHook(pageContext, 'onHydrationEnd');
-        const hook = getHook(pageContext, 'onHydrationEnd');
-        if (hook) {
-            const { hookFn } = hook;
-            await executeHook(() => hookFn(pageContext), hook);
-            if (abortRender(true))
+        // 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
+            await globalObject.renderPromise;
+            assert(globalObject.renderPromise === undefined);
+            if (isRenderOutdated())
                 return;
         }
-    }
-    // We abort only after onHydrationEnd() is called
-    if (abortRender(true))
-        return;
-    // onPageTransitionEnd()
-    if (callTransitionHooks) {
-        assertHook(pageContext, 'onPageTransitionEnd');
-        const hook = getHook(pageContext, 'onPageTransitionEnd');
-        if (hook) {
-            const { hookFn } = hook;
-            await executeHook(() => hookFn(pageContext), hook);
-            if (abortRender(true))
-                return;
+        changeUrl(urlOriginal, overwriteLastHistoryEntry);
+        globalObject.previousPageContext = pageContext;
+        assert(globalObject.renderPromise === undefined);
+        globalObject.renderPromise = (async () => {
+            try {
+                await executeOnRenderClientHook(pageContext, true);
+            }
+            catch (err) {
+                if (!isErrorPage) {
+                    renderErrorPage(err);
+                }
+                else {
+                    throw err;
+                }
+            }
+            addLinkPrefetchHandlers(pageContext);
+            globalObject.renderPromise = undefined;
+        })();
+        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
+      */
+        // onHydrationEnd()
+        if (isFirstRender) {
+            assertHook(pageContext, 'onHydrationEnd');
+            const hook = getHook(pageContext, 'onHydrationEnd');
+            if (hook) {
+                const { hookFn } = hook;
+                await executeHook(() => hookFn(pageContext), hook);
+                if (isRenderOutdated(true))
+                    return;
+            }
         }
-        globalObject.isTransitioning = undefined;
+        // We abort only after onHydrationEnd() is called
+        if (isRenderOutdated(true))
+            return;
+        // onPageTransitionEnd()
+        if (callTransitionHooks) {
+            assertHook(pageContext, 'onPageTransitionEnd');
+            const hook = getHook(pageContext, 'onPageTransitionEnd');
+            if (hook) {
+                const { hookFn } = hook;
+                await executeHook(() => hookFn(pageContext), hook);
+                if (isRenderOutdated(true))
+                    return;
+            }
+            globalObject.isTransitioning = undefined;
+        }
+        // Page scrolling
+        setScrollPosition(scrollTarget);
+        browserNativeScrollRestoration_disable();
+        setInitialRenderIsDone();
     }
-    // Page scrolling
-    setScrollPosition(scrollTarget);
-    browserNativeScrollRestoration_disable();
-    setInitialRenderIsDone();
 }
 function changeUrl(url, overwriteLastHistoryEntry) {
     if (getCurrentUrl() === url)
@@ -283,7 +309,7 @@ function changeUrl(url, overwriteLastHistoryEntry) {
     updateState();
 }
 function shouldSwallowAndInterrupt(err, pageContext, isFirstRender) {
-    if (isAlreadyServerSideRouted(err))
+    if (isServerSideRouted(err))
         return true;
     if (handleErrorFetchingStaticAssets(err, pageContext, isFirstRender))
         return true;
@@ -323,7 +349,7 @@ function disableClientRouting(err, log) {
         .filter(Boolean)
         .join(' '), { onlyOnce: true });
 }
-function getAbortRender() {
+function getIsRenderOutdated() {
     const renderNumber = ++globalObject.renderCounter;
     assert(renderNumber >= 1);
     let hydrationCanBeAborted = false;
@@ -331,11 +357,11 @@ function getAbortRender() {
         hydrationCanBeAborted = true;
     };
     /** Whether the rendering should be aborted because a new rendering has started. We should call this after each `await`. */
-    const abortRender = (isRenderCleanup) => {
+    const isRenderOutdated = (isRenderCleanup) => {
         // Never abort hydration if `hydrationCanBeAborted` isn't `true`
-        if (!isRenderCleanup) {
+        {
             const isHydration = renderNumber === 1;
-            if (isHydration && !hydrationCanBeAborted) {
+            if (isHydration && !hydrationCanBeAborted && !isRenderCleanup) {
                 return false;
             }
         }
@@ -343,7 +369,7 @@ function getAbortRender() {
         return renderNumber !== globalObject.renderCounter;
     };
     return {
-        abortRender,
+        isRenderOutdated,
         setHydrationCanBeAborted,
         isFirstRender: renderNumber === 1
     };

package/dist/esm/client/client-routing-runtime/utils.d.ts

@@ -10,7 +10,7 @@ export * from '../../utils/isCallable.js';
 export * from '../../utils/isObject.js';
 export * from '../../utils/isPlainObject.js';
 export * from '../../utils/isReact.js';
-export * from '../../utils/isEquivalentError.js';
+export * from '../../utils/isSameErrorMessage.js';
 export * from '../../utils/objectAssign.js';
 export * from '../../utils/parseUrl.js';
 export * from '../../utils/projectInfo.js';

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

@@ -16,7 +16,7 @@ export * from '../../utils/isCallable.js';
 export * from '../../utils/isObject.js';
 export * from '../../utils/isPlainObject.js';
 export * from '../../utils/isReact.js';
-export * from '../../utils/isEquivalentError.js';
+export * from '../../utils/isSameErrorMessage.js';
 export * from '../../utils/objectAssign.js';
 export * from '../../utils/parseUrl.js';
 export * from '../../utils/projectInfo.js';

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

@@ -1,11 +1,13 @@
 export { executeOnRenderClientHook };
+export type { PageContextBeforeRenderClient };
 import type { PageFile, PageContextExports } from '../../shared/getPageFiles.js';
 import { type PageContextForUserConsumptionClientSide } from './preparePageContextForUserConsumptionClientSide.js';
 import type { PageConfigRuntime } from '../../shared/page-configs/PageConfig.js';
-declare function executeOnRenderClientHook<PC extends {
+type PageContextBeforeRenderClient = {
     _pageFilesLoaded: PageFile[];
     urlOriginal?: string;
     urlPathname?: string;
     _pageId: string;
     _pageConfigs: PageConfigRuntime[];
-} & PageContextExports & PageContextForUserConsumptionClientSide>(pageContext: PC, isClientRouting: boolean): Promise<void>;
+} & PageContextExports & PageContextForUserConsumptionClientSide;
+declare function executeOnRenderClientHook<PC extends PageContextBeforeRenderClient>(pageContext: PC, isClientRouting: boolean): Promise<void>;

package/dist/esm/node/runtime/html/stream.js

@@ -19,8 +19,9 @@ export { streamReadableWebToString };
 export { streamPipeNodeToString };
 export { isStreamWritableWeb };
 export { isStreamWritableNode };
-import { assert, assertUsage, checkType, isObject, hasProp, objectAssign, capitalizeFirstLetter, assertWarning, isCallable, createDebugger, dynamicImport, isBug } from '../utils.js';
+import { assert, assertUsage, checkType, isObject, hasProp, objectAssign, capitalizeFirstLetter, assertWarning, isCallable, createDebugger, isBug } from '../utils.js';
 import { getStreamFromReactStreaming, isStreamReactStreaming, streamReactStreamingToString } from './stream/react-streaming.js';
+import { import_ } from '@brillout/import';
 import pc from '@brillout/picocolors';
 const debug = createDebugger('vike:stream');
 function isStreamReadableWeb(thing) {
@@ -753,7 +754,7 @@ function encodeForWebStream(thing) {
 }
 // Because of Cloudflare Workers, we cannot statically import the `stream` module, instead we dynamically import it.
 async function loadStreamNodeModule() {
-    const streamModule = await dynamicImport('stream');
+    const streamModule = (await import_('stream')).default;
     const { Readable, Writable } = streamModule;
     return { Readable, Writable };
 }

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

@@ -1,12 +1,12 @@
 export { isNewError };
 export { setAlreadyLogged };
-import { getGlobalObject, isObject, isEquivalentError, warnIfErrorIsNotObject } from '../utils.js';
+import { getGlobalObject, isObject, isSameErrorMessage, warnIfErrorIsNotObject } from '../utils.js';
 const globalObject = getGlobalObject('runtime/renderPage/isNewError.ts', {
     wasAlreadyLogged: new WeakSet()
 });
 function isNewError(errErrorPage, errNominalPage) {
     warnIfErrorIsNotObject(errErrorPage);
-    return !isEquivalentError(errNominalPage, errErrorPage) || !hasAlreadyLogged(errNominalPage);
+    return !isSameErrorMessage(errNominalPage, errErrorPage) || !hasAlreadyLogged(errNominalPage);
 }
 function hasAlreadyLogged(err) {
     if (!isObject(err))

package/dist/esm/node/runtime/utils.d.ts

@@ -23,7 +23,7 @@ export * from '../../utils/filesystemPathHandling.js';
 export * from '../../utils/getOutDirs.js';
 export * from '../../utils/capitalizeFirstLetter.js';
 export * from '../../utils/debugGlob.js';
-export * from '../../utils/isEquivalentError.js';
+export * from '../../utils/isSameErrorMessage.js';
 export * from '../../utils/styleFileRE.js';
 export * from '../../utils/isPropertyGetter.js';
 export * from '../../utils/debug.js';
@@ -45,7 +45,6 @@ export * from '../../utils/path-shim.js';
 export * from '../../utils/nodeEnv.js';
 export * from '../../utils/isHtml.js';
 export * from '../../utils/warnIfErrorIsNotObject.js';
-export * from '../../utils/dynamicImport.js';
 export * from '../../utils/stripAnsi.js';
 export * from '../../utils/getTerminWidth.js';
 export * from '../../utils/truncateString.js';

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

@@ -26,7 +26,7 @@ export * from '../../utils/filesystemPathHandling.js';
 export * from '../../utils/getOutDirs.js';
 export * from '../../utils/capitalizeFirstLetter.js';
 export * from '../../utils/debugGlob.js';
-export * from '../../utils/isEquivalentError.js';
+export * from '../../utils/isSameErrorMessage.js';
 export * from '../../utils/styleFileRE.js';
 export * from '../../utils/isPropertyGetter.js';
 export * from '../../utils/debug.js';
@@ -48,7 +48,6 @@ export * from '../../utils/path-shim.js';
 export * from '../../utils/nodeEnv.js';
 export * from '../../utils/isHtml.js';
 export * from '../../utils/warnIfErrorIsNotObject.js';
-export * from '../../utils/dynamicImport.js';
 export * from '../../utils/stripAnsi.js';
 export * from '../../utils/getTerminWidth.js';
 export * from '../../utils/truncateString.js';

package/dist/esm/shared/page-configs/Config.d.ts

@@ -29,13 +29,13 @@ export type { OnRenderHtmlAsync };
 export type { OnRenderHtmlSync };
 export type { RouteAsync };
 export type { RouteSync };
-import type { PrefetchStaticAssets } from '../../client/client-routing-runtime/prefetch/getPrefetchSettings.js';
 import type { ConfigDefinition } from '../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/configDefinitionsBuiltIn.js';
 import type { DocumentHtml } from '../../node/runtime/html/renderHtml.js';
 import type { ConfigVikeUserProvided } from '../ConfigVike.js';
 import type { Vike, VikePackages } from '../VikeNamespace.js';
 import type { HooksTimeoutProvidedByUser } from '../hooks/getHook.js';
 import type { PageContextClient, PageContextServer } from '../types.js';
+import type { PrefetchStaticAssets } from '../types/PrefetchStaticAssets.js';
 type HookName = HookNamePage | HookNameGlobal | HookNameOldDesign;
 type HookNamePage = 'onHydrationEnd' | 'onBeforePrerenderStart' | 'onBeforeRender' | 'onPageTransitionStart' | 'onPageTransitionEnd' | 'onRenderHtml' | 'onRenderClient' | 'guard' | 'data';
 type HookNameGlobal = 'onBeforePrerender' | 'onBeforeRoute' | 'onPrerenderStart';

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

@@ -0,0 +1,2 @@
+export { isSameErrorMessage };
+declare function isSameErrorMessage(err1: unknown, err2: unknown): boolean;

package/dist/esm/utils/isSameErrorMessage.js

@@ -0,0 +1,7 @@
+import { isObject } from './isObject.js';
+export { isSameErrorMessage };
+function isSameErrorMessage(err1, err2) {
+    if (!isObject(err1) || !isObject(err2))
+        return false;
+    return err1.message === err2.message;
+}

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

@@ -1,13 +1,13 @@
 export { projectInfo };
 export type { ProjectTag };
 export { PROJECT_VERSION };
-declare const PROJECT_VERSION: "0.4.152-commit-3d25618";
+declare const PROJECT_VERSION: "0.4.152-commit-6f928f9";
 type PackageName = typeof projectInfo.npmPackageName;
 type ProjectVersion = typeof projectInfo.projectVersion;
 type ProjectTag = `[${PackageName}]` | `[${PackageName}@${ProjectVersion}]`;
 declare const projectInfo: {
     projectName: "Vike";
-    projectVersion: "0.4.152-commit-3d25618";
+    projectVersion: "0.4.152-commit-6f928f9";
     npmPackageName: "vike";
     githubRepository: "https://github.com/vikejs/vike";
 };

package/dist/esm/utils/projectInfo.js

@@ -1,7 +1,7 @@
 export { projectInfo };
 export { PROJECT_VERSION };
 import { onProjectInfo } from './assertSingleInstance.js';
-const PROJECT_VERSION = '0.4.152-commit-3d25618';
+const PROJECT_VERSION = '0.4.152-commit-6f928f9';
 const projectInfo = {
     projectName: 'Vike',
     projectVersion: PROJECT_VERSION,

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "vike",
-  "version": "0.4.152-commit-3d25618",
+  "version": "0.4.152-commit-6f928f9",
   "scripts": {
     "dev": "tsc --watch",
     "build": "rimraf dist/ && pnpm run build:esm && pnpm run build:cjs",
     "build:esm": "tsc",
     "build:cjs": "pnpm run build:cjs:ts && pnpm run build:cjs:fixup",
-    "build:cjs:ts": "tsc --outDir ./dist/cjs/ --module CommonJS --target ES2020 --moduleResolution Node10 --declaration false",
+    "build:cjs:ts": "tsc --project ./tsconfig.cjs.json",
     "build:cjs:fixup": "node ./dist-cjs-fixup.mjs",
     "release": "release-me patch",
     "release:commit": "release-me commit"

package/dist/cjs/utils/dynamicImport.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.dynamicImport = void 0;
-/** Only works for npm packages, for files use @brillout/import instead */
-function dynamicImport(mod) {
-    return new Function('mod', 'return import(mod)')(mod);
-}
-exports.dynamicImport = dynamicImport;

package/dist/cjs/utils/isEquivalentError.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isEquivalentError = void 0;
-const isObject_js_1 = require("./isObject.js");
-const deepEqual_js_1 = require("./deepEqual.js");
-function isEquivalentError(err1, err2) {
-    return ((0, isObject_js_1.isObject)(err1) &&
-        (0, isObject_js_1.isObject)(err2) &&
-        err1.constructor === err2.constructor &&
-        (0, deepEqual_js_1.deepEqual)({ ...err1, stack: null }, { ...err2, stack: null }) &&
-        // 'message' and 'stack' are usually non-emurable
-        err2.message === err2.message
-    /* Doesn't work because: the stack trace isn't exactly the same between the original page rendering and the fallback error page rendering
-    err2.stack === err2.stack
-    */
-    );
-}
-exports.isEquivalentError = isEquivalentError;

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

@@ -1,2 +0,0 @@
-/** Only works for npm packages, for files use @brillout/import instead */
-export declare function dynamicImport<Mod = never>(mod: string): Promise<Mod>;

package/dist/esm/utils/dynamicImport.js

@@ -1,4 +0,0 @@
-/** Only works for npm packages, for files use @brillout/import instead */
-export function dynamicImport(mod) {
-    return new Function('mod', 'return import(mod)')(mod);
-}

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

@@ -1,2 +0,0 @@
-export { isEquivalentError };
-declare function isEquivalentError(err1: unknown, err2: unknown): boolean;

package/dist/esm/utils/isEquivalentError.js

@@ -1,15 +0,0 @@
-import { isObject } from './isObject.js';
-import { deepEqual } from './deepEqual.js';
-export { isEquivalentError };
-function isEquivalentError(err1, err2) {
-    return (isObject(err1) &&
-        isObject(err2) &&
-        err1.constructor === err2.constructor &&
-        deepEqual({ ...err1, stack: null }, { ...err2, stack: null }) &&
-        // 'message' and 'stack' are usually non-emurable
-        err2.message === err2.message
-    /* Doesn't work because: the stack trace isn't exactly the same between the original page rendering and the fallback error page rendering
-    err2.stack === err2.stack
-    */
-    );
-}