vike 0.4.240-commit-bac5dee → 0.4.240-commit-098ff81

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

@@ -3,7 +3,7 @@ export { getRenderCount };
 export { disableClientRouting };
 export { firstRenderStartPromise };
 export { getPageContextClient };
-import { assert, isSameErrorMessage, objectAssign, redirectHard, getGlobalObject, hasProp, updateType, genPromise, isCallable, catchInfiniteLoop, } from './utils.js';
+import { assert, objectAssign, redirectHard, getGlobalObject, hasProp, updateType, genPromise, isCallable, catchInfiniteLoop, } from './utils.js';
 import { getPageContextFromClientHooks, getPageContextFromServerHooks, getPageContextFromHooks_isHydration, getPageContextFromHooks_serialized, setPageContextInitIsPassedToClient, } from './getPageContextFromHooks.js';
 import { createPageContextClientSide } from './createPageContextClientSide.js';
 import { addLinkPrefetchHandlers, addLinkPrefetchHandlers_unwatch, addLinkPrefetchHandlers_watch, getPageContextPrefetched, populatePageContextPrefetchCache, } from './prefetch.js';
@@ -60,7 +60,7 @@ async function renderPageClientSide(renderArgs) {
     return;
     async function renderPageNominal() {
         const onError = async (err) => {
-            await renderPageOnError({ err });
+            await handleError({ err });
         };
         const pageContext = await getPageContextBegin(false, pageContextBeginArgs);
         if (isRenderOutdated())
@@ -229,96 +229,68 @@ async function renderPageClientSide(renderArgs) {
             await renderPageView(pageContext);
         }
     }
-    // When the normal page threw an error
+    // When the normal page threw an error:
     // - Can be a URL rewrite upon `throw render('/some-url')`
     // - Can be rendering the error page
     // - Can be rendering Vike's generic error page (if no error page is defined, or if the error page throws an error)
-    async function renderPageOnError(args) {
-        const onError = (err) => {
-            if (!isSameErrorMessage(err, args.err)) {
-                /* When we can't render the error page, we prefer showing a blank page over letting the server-side try because otherwise:
-                   - 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.
-                redirectHard(urlOriginal)
-                */
-                console.error(err);
-            }
-        };
-        if ('err' in args) {
-            const { err } = args;
-            assert(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.
-            }
+    async function handleError(args) {
+        const { err } = args;
+        assert(err);
+        // Logging
+        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.
+        }
+        // pageContext
         const pageContext = await getPageContextBegin(true, pageContextBeginArgs);
         if (isRenderOutdated())
             return;
-        objectAssign(pageContext, { routeParams: {} });
-        if (args.pageContextError)
-            objectAssign(pageContext, args.pageContextError);
-        if ('err' in args) {
-            const { err } = args;
-            assert(!('errorWhileRendering' in pageContext));
-            objectAssign(pageContext, { errorWhileRendering: err });
-            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: undefined,
-                        pageContextsFromRewrite: [...pageContextsFromRewrite, pageContextAbort],
-                    });
-                    return;
-                }
-                // throw redirect('/some-url')
-                if (pageContextAbort._urlRedirect) {
-                    const urlRedirect = pageContextAbort._urlRedirect.url;
-                    if (!urlRedirect.startsWith('/')) {
-                        // External redirection
-                        redirectHard(urlRedirect);
-                        return;
-                    }
-                    else {
-                        await renderPageClientSide({
-                            ...renderArgs,
-                            scrollTarget: undefined,
-                            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 });
-                }
-            }
-            else {
-                objectAssign(pageContext, { is404: false });
-            }
+        objectAssign(pageContext, {
+            errorWhileRendering: err,
+        });
+        // throw redirect()/render()
+        let pageContextAbort;
+        if (isAbortError(err)) {
+            const res = await handleAbortError(err, pageContext);
+            if (res.skip)
+                return;
+            pageContextAbort = res.pageContextAbort;
         }
+        // Render error page
+        await renderErrorPage(pageContext, args, pageContextAbort);
+    }
+    async function renderErrorPage(pageContext, args, pageContextAbort) {
+        const onError = (err) => {
+            /* 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.
+            redirectHard(urlOriginal)
+            */
+            console.error(err);
+        };
         const errorPageId = getErrorPageId(pageContext._pageFilesAll, pageContext._globalContext._pageConfigs);
         if (!errorPageId)
             throw new Error('No error page defined.');
         objectAssign(pageContext, {
             pageId: errorPageId,
+            routeParams: {},
         });
+        // throw render(statusCode)
+        if (pageContextAbort) {
+            assert(pageContextAbort.abortStatusCode);
+            assert(!('urlOriginal' in pageContextAbort));
+            objectAssign(pageContext, pageContextAbort);
+            objectAssign(pageContext, { is404: pageContextAbort.abortStatusCode === 404 });
+        }
+        else {
+            objectAssign(pageContext, { is404: false });
+        }
         const isClientRoutable = await isClientSideRoutable(pageContext.pageId, pageContext);
         if (isRenderOutdated())
             return;
@@ -326,6 +298,9 @@ async function renderPageClientSide(renderArgs) {
             redirectHard(urlOriginal);
             return;
         }
+        if (import.meta.env.DEV || globalThis.__VIKE__IS_DEBUG) {
+            assertInfo(false, `Rendering error page ${errorPageId}`, { onlyOnce: false });
+        }
         const res = await loadPageConfigsLazyClientSideAndExecHook(pageContext, isFirstRender, isRenderOutdated);
         /* Already called inside loadPageConfigsLazyClientSideAndExecHook()
         if (isRenderOutdated()) return
@@ -367,15 +342,49 @@ async function renderPageClientSide(renderArgs) {
         updateType(pageContext, pageContextFromClientHooks);
         await renderPageView(pageContext, args);
     }
+    async function handleAbortError(err, pageContext) {
+        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: undefined,
+                pageContextsFromRewrite: [...pageContextsFromRewrite, pageContextAbort],
+            });
+            return { skip: true };
+        }
+        // throw redirect('/some-url')
+        if (pageContextAbort._urlRedirect) {
+            const urlRedirect = pageContextAbort._urlRedirect.url;
+            if (!urlRedirect.startsWith('/')) {
+                // External redirection
+                redirectHard(urlRedirect);
+                return { skip: true };
+            }
+            else {
+                await renderPageClientSide({
+                    ...renderArgs,
+                    scrollTarget: undefined,
+                    urlOriginal: urlRedirect,
+                    overwriteLastHistoryEntry: false,
+                    isBackwardNavigation: false,
+                    redirectCount: redirectCount + 1,
+                });
+            }
+            return { skip: true };
+        }
+        // throw render(statusCode)
+        return { pageContextAbort };
+    }
     async function renderPageView(pageContext, isErrorPage) {
         const onError = async (err) => {
             if (!isErrorPage) {
-                await renderPageOnError({ err });
+                await handleError({ err });
             }
             else {
-                if (!isSameErrorMessage(err, isErrorPage.err)) {
-                    console.error(err);
-                }
+                console.error(err);
             }
         };
         // We use globalObject.onRenderClientPreviousPromise in order to ensure that there is never two concurrent onRenderClient() calls
@@ -395,6 +404,7 @@ async function renderPageClientSide(renderArgs) {
                 await execHookOnRenderClient(pageContext, preparePageContextForPublicUsageClient);
             }
             catch (err) {
+                assert(err);
                 onRenderClientError = err;
             }
             globalObject.onRenderClientPreviousPromise = undefined;

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

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

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

@@ -11,7 +11,6 @@ export * from '../../utils/isCallable.js';
 export * from '../../utils/isObject.js';
 export * from '../../utils/isPlainObject.js';
 export * from '../../utils/isReact.js';
-export * from '../../utils/isSameErrorMessage.js';
 export * from '../../utils/objectAssign.js';
 export * from '../../utils/parseUrl.js';
 export * from '../../utils/PromiseType.js';

package/dist/esm/shared/route/abort.d.ts

@@ -12,6 +12,7 @@ export type { AbortStatusCode };
 export type { ErrorAbort };
 export type { PageContextFromRewrite };
 export type { UrlRedirect };
+export type { PageContextAbort };
 type RedirectStatusCode = number & Parameters<typeof redirect>[1];
 type AbortStatusCode = number & Parameters<InferTwoOverloads<typeof render>[0]>[0];
 type UrlRedirect = {

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

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.240-commit-bac5dee";
+export declare const PROJECT_VERSION: "0.4.240-commit-098ff81";

package/dist/esm/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.240-commit-bac5dee';
+export const PROJECT_VERSION = '0.4.240-commit-098ff81';

package/dist/esm/utils/debug.js

@@ -36,7 +36,6 @@ const flags = [
     'vike:vite-rpc',
 ];
 const flagsSkipWildcard = ['vike:log'];
-const flagRegex = /\bvike:[a-zA-Z-]+/g;
 // We purposely read process.env.DEBUG early, in order to avoid users from the temptation to set process.env.DEBUG with JavaScript, since reading & writing process.env.DEBUG dynamically leads to inconsistencies such as https://github.com/vikejs/vike/issues/2239
 const DEBUG = getDEBUG() ?? '';
 if (isDebug())
@@ -86,8 +85,8 @@ function debug_(flag, options, ...msgs) {
 }
 function isDebugActivated(flag) {
     assert(flags.includes(flag));
-    const { flagsActivated, all } = getFlagsActivated();
-    const isActivated = flagsActivated.includes(flag) || (all && !flagsSkipWildcard.includes(flag));
+    const { flagsActivated, isAll } = getFlagsActivated();
+    const isActivated = flagsActivated.includes(flag) || (isAll && !flagsSkipWildcard.includes(flag));
     return isActivated;
 }
 function formatMsg(info, options, padding, position) {
@@ -156,17 +155,15 @@ function assertFlagsActivated() {
         assertUsage(flags.includes(flag), `Unknown DEBUG flag ${pc.cyan(flag)}. Valid flags:\n${flags.map((f) => `  ${pc.cyan(f)}`).join('\n')}`);
     });
 }
-// TODO/now: refactor isAll
-// TODO/now: refactor inline flagRegex
 function getFlagsActivated() {
-    const flagsActivated = DEBUG.match(flagRegex) ?? [];
-    const all = DEBUG.includes('vike:*');
+    const flagsActivated = DEBUG.match(/\bvike:[a-zA-Z-]+/g) ?? [];
+    const isAll = DEBUG.includes('vike:*');
     const isGlobal = /\bvike\b[^:]/.test(DEBUG);
-    return { flagsActivated, all, isGlobal };
+    return { flagsActivated, isAll, isGlobal };
 }
 function isDebug() {
-    const { flagsActivated, all, isGlobal } = getFlagsActivated();
-    return all || flagsActivated.length > 0 || isGlobal;
+    const { flagsActivated, isAll, isGlobal } = getFlagsActivated();
+    return isAll || flagsActivated.length > 0 || isGlobal;
 }
 function getDEBUG() {
     let DEBUG;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.240-commit-bac5dee",
+  "version": "0.4.240-commit-098ff81",
   "repository": "https://github.com/vikejs/vike",
   "exports": {
     "./server": {
@@ -247,7 +247,7 @@
     "@types/source-map-support": "^0.5.10",
     "react-streaming": "^0.4.3",
     "rimraf": "^5.0.5",
-    "typescript": "^5.8.3",
+    "typescript": "^5.9.2",
     "vite": "^7.1.5"
   },
   "scripts": {