vike 0.4.227-commit-e36b916 → 0.4.227-commit-25aa0f8

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig.js

@@ -568,6 +568,7 @@ function getConfigValueSource(configName, plusFile, configDef, userRootDir) {
             // Defined over pointer import
             assert(confVal.valueIsLoaded);
             const pointerImport = resolvePointerImport(confVal.value, plusFile.filePath, userRootDir, configName);
+            console.log('pointerImport', pointerImport);
             const configDefinedAt = getConfigDefinedAt('Config', configName, definedAtFilePath_);
             assertUsage(pointerImport, `${configDefinedAt} should be an import`);
             valueFilePath = pointerImport.fileExportPath.filePathAbsoluteVite;

package/dist/esm/node/plugin/shared/resolveClientEntriesDev.js

@@ -3,7 +3,6 @@ import { assert, assertPosixPath, toPosixPath, pathJoin, assertIsNpmPackageImpor
 import { createRequire } from 'module';
 // @ts-ignore import.meta.url is shimmed at dist/cjs by dist-cjs-fixup.js.
 const importMetaUrl = import.meta.url;
-const require_ = createRequire(importMetaUrl);
 assertIsNotProductionRuntime();
 async function resolveClientEntriesDev(clientEntry, viteDevServer) {
     let root = viteDevServer.config.root;
@@ -26,6 +25,7 @@ async function resolveClientEntriesDev(clientEntry, viteDevServer) {
     }
     else {
         if (clientEntry.startsWith('@@vike/')) {
+            const require_ = createRequire(importMetaUrl);
             assert(clientEntry.endsWith('.js'));
             try {
                 // For Vitest (which doesn't resolve vike to its dist but to its source files)
@@ -39,6 +39,7 @@ async function resolveClientEntriesDev(clientEntry, viteDevServer) {
             }
         }
         else {
+            const require_ = createRequire(root);
             assertIsNpmPackageImport(clientEntry);
             filePath = require_.resolve(clientEntry);
         }

package/dist/esm/node/prerender/runPrerender.d.ts

@@ -14,6 +14,7 @@ type ProvidedByHook = null | {
 type PageContextPrerendered = {
     urlOriginal: string;
     _providedByHook?: ProvidedByHook;
+    pageId: string;
 };
 type Output<PageContext = PageContextPrerendered> = {
     filePath: string;
@@ -53,4 +54,5 @@ declare function runPrerender_forceExit(): void;
 type PrerenderContextPublic = {
     output: Output<PageContextServer>;
     pageContexts: PageContextServer[];
+    pageContexts404: PageContextServer;
 };

package/dist/esm/node/prerender/runPrerender.js

@@ -4,8 +4,8 @@ export { runPrerenderFromAutoRun };
 export { runPrerender_forceExit };
 import path from 'path';
 import { route } from '../../shared/route/index.js';
-import { assert, assertUsage, assertWarning, hasProp, objectAssign, isObjectWithKeys, isCallable, isPropertyGetter, assertPosixPath, urlToFile, isPlainObject, pLimit, isArray, changeEnumerable, onSetupPrerender, isObject, makePublicCopy, PROJECT_VERSION } from './utils.js';
-import { prerenderPage, prerender404Page, getPageContextInitEnhanced } from '../runtime/renderPage/renderPageAlreadyRouted.js';
+import { assert, assertUsage, assertWarning, hasProp, objectAssign, isObjectWithKeys, isCallable, isPropertyGetter, assertPosixPath, urlToFile, isPlainObject, pLimit, isArray, onSetupPrerender, isObject, makePublicCopy, PROJECT_VERSION, preservePropertyGetters } from './utils.js';
+import { prerenderPage, getPageContextInitEnhanced } from '../runtime/renderPage/renderPageAlreadyRouted.js';
 import pc from '@brillout/picocolors';
 import { cpus } from 'os';
 import { getGlobalContextInternal, initGlobalContext_runPrerender, setGlobalContext_isPrerendering } from '../runtime/globalContext.js';
@@ -15,8 +15,7 @@ import { getPageContextRequestUrl } from '../../shared/getPageContextRequestUrl.
 import { getUrlFromRouteString } from '../../shared/route/resolveRouteString.js';
 import { getConfigValueRuntime } from '../../shared/page-configs/getConfigValueRuntime.js';
 import { loadConfigValues } from '../../shared/page-configs/loadConfigValues.js';
-import { isErrorPage } from '../../shared/error-page.js';
-import { getPageContextUrlComputed } from '../../shared/getPageContextUrlComputed.js';
+import { getErrorPageId, isErrorPage } from '../../shared/error-page.js';
 import { isAbortError } from '../../shared/route/abort.js';
 import { loadUserFilesServerSide } from '../runtime/renderPage/loadUserFilesServerSide.js';
 import { getHookFromPageConfig, getHookFromPageConfigGlobal, getHookTimeoutDefault, getHook_setIsPrerenderering } from '../../shared/hooks/getHook.js';
@@ -86,8 +85,7 @@ async function runPrerender(options = {}, standaloneTrigger) {
     const { partial, noExtraDir, parallel, defaultLocalValue, isPrerenderingEnabled } = prerenderConfigGlobal;
     if (!isPrerenderingEnabled) {
         assert(standaloneTrigger);
-        // TODO/now: make it assertUsage() and remove dist/server/entry.mjs if pre-rendering is completely disabled
-        assertWarning(false, `You're executing ${pc.cyan(standaloneTrigger)} but you didn't enable pre-rendering. Use the ${pc.cyan('prerender')} setting (${pc.underline('https://vike.dev/prerender')}) to enable pre-rendering for at least one page.`, { onlyOnce: true });
+        assertUsage(false, `You're executing ${pc.cyan(standaloneTrigger)} but you didn't enable pre-rendering. Use the ${pc.cyan('prerender')} setting (${pc.underline('https://vike.dev/prerender')}) to enable pre-rendering for at least one page.`);
     }
     const concurrencyLimit = pLimit(parallel === false || parallel === 0 ? 1 : parallel === true || parallel === undefined ? cpus().length : parallel);
     await initGlobalContext_runPrerender();
@@ -96,27 +94,37 @@ async function runPrerender(options = {}, standaloneTrigger) {
     const prerenderContext = {
         noExtraDir: noExtraDir ?? false,
         pageContexts: [],
+        pageContexts404: [],
         pageContextInit: options.pageContextInit ?? null,
         prerenderedPageContexts: {},
         output: []
     };
     const doNotPrerenderList = [];
     await collectDoNoPrerenderList(vikeConfig.pageConfigs, doNotPrerenderList, defaultLocalValue, concurrencyLimit, globalContext);
+    // Allow user to create `pageContext` for parameterized routes and/or bulk data fetching
+    // https://vike.dev/onBeforePrerenderStart
     await callOnBeforePrerenderStartHooks(prerenderContext, globalContext, concurrencyLimit, doNotPrerenderList);
-    await handlePagesWithStaticRoutes(prerenderContext, globalContext, doNotPrerenderList, concurrencyLimit);
-    await callOnPrerenderStartHook(prerenderContext, globalContext);
+    // Create `pageContext` for each page with a static route
+    const urlList = getUrlListFromPagesWithStaticRoute(globalContext, doNotPrerenderList);
+    await createPageContextsForOnPrerenderStartHook(urlList, prerenderContext, globalContext, concurrencyLimit, false);
+    // Create `pageContext` for 404 page
+    const urlList404 = getUrlList404(globalContext);
+    await createPageContextsForOnPrerenderStartHook(urlList404, prerenderContext, globalContext, concurrencyLimit, true);
+    // Allow user to duplicate the list of `pageContext` for i18n
+    // https://vike.dev/onPrerenderStart
+    await callOnPrerenderStartHook(prerenderContext, globalContext, concurrencyLimit);
     let prerenderedCount = 0;
     // Write files as soon as pages finish rendering (instead of writing all files at once only after all pages have rendered).
     const onComplete = async (htmlFile) => {
         prerenderedCount++;
-        if (htmlFile.pageId) {
-            prerenderContext.prerenderedPageContexts[htmlFile.pageId] = htmlFile.pageContext;
-        }
+        const { pageId } = htmlFile.pageContext;
+        assert(pageId);
+        prerenderContext.prerenderedPageContexts[pageId] = htmlFile.pageContext;
         await writeFiles(htmlFile, root, outDirClient, options.onPagePrerender, prerenderContext.output, logLevel);
     };
-    await routeAndPrerender(prerenderContext, globalContext, concurrencyLimit, onComplete);
+    await prerenderPages(prerenderContext, concurrencyLimit, onComplete);
     warnContradictoryNoPrerenderList(prerenderContext.prerenderedPageContexts, doNotPrerenderList);
-    await prerender404(prerenderContext, globalContext, onComplete);
+    await prerenderPages404(prerenderContext, onComplete, concurrencyLimit);
     if (logLevel === 'info') {
         console.log(`${pc.green(`✓`)} ${prerenderedCount} HTML documents pre-rendered.`);
     }
@@ -228,12 +236,13 @@ async function callOnBeforePrerenderStartHooks(prerenderContext, globalContext,
         });
     })));
     await Promise.all(onBeforePrerenderStartHooks.map(({ hookFn, hookName, hookFilePath, pageId, hookTimeout }) => concurrencyLimit(async () => {
-        if (doNotPrerenderList.find((p) => p.pageId === pageId)) {
+        if (doNotPrerenderList.find((p) => p.pageId === pageId))
             return;
-        }
         const prerenderResult = await executeHook(() => hookFn(), { hookName, hookFilePath, hookTimeout }, null);
         const result = normalizeOnPrerenderHookResult(prerenderResult, hookFilePath, hookName);
+        // Handle result
         await Promise.all(result.map(async ({ url, pageContext }) => {
+            // Assert no duplication
             {
                 const pageContextFound = prerenderContext.pageContexts.find((pageContext) => isSameUrl(pageContext.urlOriginal, url));
                 if (pageContextFound) {
@@ -244,30 +253,23 @@ async function callOnBeforePrerenderStartHooks(prerenderContext, globalContext,
                     assertUsage(false, `URL ${pc.cyan(url)} provided ${providedTwice}. Make sure to provide the URL only once instead.`);
                 }
             }
-            const pageContextNew = await createPageContext(url, prerenderContext, globalContext);
-            objectAssign(pageContextNew, {
-                _providedByHook: {
-                    hookFilePath,
-                    hookName
-                }
-            });
+            // Add result
+            const providedByHook = { hookFilePath, hookName };
+            const pageContextNew = await createPageContext(url, prerenderContext, globalContext, false, undefined, providedByHook);
             prerenderContext.pageContexts.push(pageContextNew);
             if (pageContext) {
-                objectAssign(pageContextNew, {
-                    _pageContextAlreadyProvidedByOnPrerenderHook: true
-                });
+                objectAssign(pageContextNew, { _pageContextAlreadyProvidedByOnPrerenderHook: true });
                 objectAssign(pageContextNew, pageContext);
             }
         }));
     })));
 }
-async function handlePagesWithStaticRoutes(prerenderContext, globalContext, doNotPrerenderList, concurrencyLimit) {
-    // Pre-render pages with a static route
-    await Promise.all(globalContext.pageRoutes.map((pageRoute) => concurrencyLimit(async () => {
+function getUrlListFromPagesWithStaticRoute(globalContext, doNotPrerenderList) {
+    const urlList = [];
+    globalContext.pageRoutes.map((pageRoute) => {
         const { pageId } = pageRoute;
-        if (doNotPrerenderList.find((p) => p.pageId === pageId)) {
+        if (doNotPrerenderList.find((p) => p.pageId === pageId))
             return;
-        }
         let urlOriginal;
         if (!('routeString' in pageRoute)) {
             // Abort since the page's route is a Route Function
@@ -283,43 +285,116 @@ async function handlePagesWithStaticRoutes(prerenderContext, globalContext, doNo
             urlOriginal = url;
         }
         assert(urlOriginal.startsWith('/'));
+        urlList.push({ urlOriginal, pageId });
+    });
+    return urlList;
+}
+function getUrlList404(globalContext) {
+    const urlList = [];
+    const errorPageId = getErrorPageId(globalContext.pageFilesAll, globalContext.pageConfigs);
+    if (errorPageId) {
+        urlList.push({
+            // A URL is required for `viteDevServer.transformIndexHtml(url,html)`
+            urlOriginal: '/404',
+            pageId: errorPageId
+        });
+    }
+    return urlList;
+}
+async function createPageContextsForOnPrerenderStartHook(urlList, prerenderContext, globalContext, concurrencyLimit, is404) {
+    await Promise.all(urlList.map(({ urlOriginal, pageId }) => concurrencyLimit(async () => {
         // Already included in a onBeforePrerenderStart() hook
-        if (prerenderContext.pageContexts.find((pageContext) => isSameUrl(pageContext.urlOriginal, urlOriginal))) {
+        if ([...prerenderContext.pageContexts, ...prerenderContext.pageContexts404].find((pageContext) => isSameUrl(pageContext.urlOriginal, urlOriginal))) {
             return;
         }
-        const routeParams = {};
-        const pageContext = await createPageContext(urlOriginal, prerenderContext, globalContext);
-        objectAssign(pageContext, {
-            _providedByHook: null,
-            routeParams,
-            pageId: pageId,
-            _debugRouteMatches: [
-                {
-                    pageId,
-                    routeType: pageRoute.routeType,
-                    routeString: urlOriginal,
-                    routeParams
-                }
-            ]
-        });
-        objectAssign(pageContext, await loadUserFilesServerSide(pageContext));
-        prerenderContext.pageContexts.push(pageContext);
+        const pageContext = await createPageContext(urlOriginal, prerenderContext, globalContext, is404, pageId, null);
+        if (is404) {
+            prerenderContext.pageContexts404.push(pageContext);
+        }
+        else {
+            prerenderContext.pageContexts.push(pageContext);
+        }
     })));
 }
-async function createPageContext(urlOriginal, prerenderContext, globalContext) {
-    const pageContextInit = { urlOriginal };
-    objectAssign(pageContextInit, prerenderContext.pageContextInit);
-    const pageContext = await getPageContextInitEnhanced(pageContextInit, globalContext, true, {});
+async function createPageContext(urlOriginal, prerenderContext, globalContext, is404, pageId, providedByHook) {
+    const pageContextInit = {
+        urlOriginal,
+        ...prerenderContext.pageContextInit
+    };
+    const pageContext = await getPageContextInitEnhanced(pageContextInit, globalContext, true);
     assert(pageContext.isPrerendering === true);
     objectAssign(pageContext, {
         _urlHandler: null,
+        _httpRequestId: null,
         _urlRewrite: null,
         _noExtraDir: prerenderContext.noExtraDir,
-        _prerenderContext: prerenderContext
+        _prerenderContext: prerenderContext,
+        _providedByHook: providedByHook,
+        _urlOriginalModifiedByHook: null,
+        is404
     });
+    if (!is404) {
+        const pageContextFromRoute = await route(pageContext);
+        assert(hasProp(pageContextFromRoute, 'pageId', 'null') || hasProp(pageContextFromRoute, 'pageId', 'string')); // Help TS
+        assertRouteMatch(pageContextFromRoute, pageContext);
+        assert(pageContextFromRoute.pageId);
+        objectAssign(pageContext, pageContextFromRoute);
+    }
+    else {
+        assert(pageId);
+        objectAssign(pageContext, {
+            pageId,
+            _debugRouteMatches: [],
+            routeParams: {}
+        });
+    }
+    objectAssign(pageContext, await loadUserFilesServerSide(pageContext));
+    let usesClientRouter;
+    {
+        const { pageId } = pageContext;
+        assert(pageId);
+        assert(globalContext.isPrerendering);
+        if (globalContext.pageConfigs.length > 0) {
+            const pageConfig = globalContext.pageConfigs.find((p) => p.pageId === pageId);
+            assert(pageConfig);
+            usesClientRouter = getConfigValueRuntime(pageConfig, 'clientRouting', 'boolean')?.value ?? false;
+        }
+        else {
+            usesClientRouter = globalContext.usesClientRouter;
+        }
+    }
+    objectAssign(pageContext, { _usesClientRouter: usesClientRouter });
     return pageContext;
 }
-async function callOnPrerenderStartHook(prerenderContext, globalContext) {
+function assertRouteMatch(pageContextFromRoute, pageContext) {
+    if (pageContextFromRoute.pageId !== null) {
+        assert(pageContextFromRoute.pageId);
+        return;
+    }
+    let hookName;
+    let hookFilePath;
+    if (pageContext._urlOriginalModifiedByHook) {
+        hookName = pageContext._urlOriginalModifiedByHook.hookName;
+        hookFilePath = pageContext._urlOriginalModifiedByHook.hookFilePath;
+    }
+    else if (pageContext._providedByHook) {
+        hookName = pageContext._providedByHook.hookName;
+        hookFilePath = pageContext._providedByHook.hookFilePath;
+    }
+    if (hookName) {
+        assert(hookFilePath);
+        const { urlOriginal } = pageContext;
+        assert(urlOriginal);
+        assertUsage(false, `The ${hookName}() hook defined by ${hookFilePath} returns a URL ${pc.cyan(urlOriginal)} that ${noRouteMatch}. Make sure that the URLs returned by ${hookName}() always match the route of a page.`);
+    }
+    else {
+        // `prerenderHookFile` is `null` when the URL was deduced by the Filesytem Routing of `.page.js` files. The `onBeforeRoute()` can override Filesystem Routing; it is therefore expected that the deduced URL may not match any page.
+        assert(pageContextFromRoute._routingProvidedByOnBeforeRouteHook);
+        // Abort since the URL doesn't correspond to any page
+        return;
+    }
+}
+async function callOnPrerenderStartHook(prerenderContext, globalContext, concurrencyLimit) {
     let onPrerenderStartHook;
     // V1 design
     if (globalContext.pageConfigs.length > 0) {
@@ -389,8 +464,11 @@ async function callOnPrerenderStartHook(prerenderContext, globalContext) {
         pageContext._urlOriginalBeforeHook = pageContext.urlOriginal;
     });
     const docLink = 'https://vike.dev/i18n#pre-rendering';
-    // Set `enumerable` to `false` to avoid computed URL properties from being iterated & copied in onPrerenderStart() hook, e.g. /examples/i18n/
-    const { restoreEnumerable, addPageContextComputedUrl } = makePageContextComputedUrlNonEnumerable(prerenderContext.pageContexts);
+    prerenderContext.pageContexts.forEach((pageContext) => {
+        // Preserve URL computed properties when the user is copying pageContext is his onPrerenderStart() hook, e.g. /examples/i18n/
+        // https://vike.dev/i18n#pre-rendering
+        preservePropertyGetters(pageContext);
+    });
     let result = await executeHook(() => {
         const prerenderContextPublic = makePublic(prerenderContext);
         // TODO/v1-release: remove warning
@@ -405,7 +483,11 @@ async function callOnPrerenderStartHook(prerenderContext, globalContext) {
         });
         return hookFn(prerenderContextPublic);
     }, onPrerenderStartHook, null);
-    restoreEnumerable();
+    // Before applying result
+    prerenderContext.pageContexts.forEach((pageContext) => {
+        ;
+        pageContext._restorePropertyGetters?.();
+    });
     if (result === null || result === undefined) {
         return;
     }
@@ -436,82 +518,41 @@ async function callOnPrerenderStartHook(prerenderContext, globalContext) {
         }
         delete pageContext.url;
     });
+    // After applying result
     prerenderContext.pageContexts.forEach((pageContext) => {
+        ;
+        pageContext._restorePropertyGetters?.();
+    });
+    // Assert URL modified by user
+    await Promise.all(prerenderContext.pageContexts.map((pageContext) => concurrencyLimit(async () => {
         if (pageContext.urlOriginal !== pageContext._urlOriginalBeforeHook) {
             pageContext._urlOriginalModifiedByHook = {
                 hookFilePath,
                 hookName
             };
+            const pageContextFromRoute = await route(pageContext, 
+            // Avoid calling onBeforeRoute() twice, otherwise user's onBeforeRoute() will wrongfully believe URL doesn't have locale when onBeforeRoute() removes the local from the URL
+            true);
+            assertRouteMatch(pageContextFromRoute, pageContext);
         }
-    });
-    addPageContextComputedUrl(prerenderContext.pageContexts);
+    })));
 }
-async function routeAndPrerender(prerenderContext, globalContext, concurrencyLimit, onComplete) {
-    assert(globalContext.isPrerendering);
-    // Route all URLs
-    await Promise.all(prerenderContext.pageContexts.map((pageContext) => concurrencyLimit(async () => {
-        const { urlOriginal } = pageContext;
-        assert(urlOriginal);
-        const pageContextFromRoute = await route(pageContext);
-        assert(hasProp(pageContextFromRoute, 'pageId', 'null') || hasProp(pageContextFromRoute, 'pageId', 'string'));
-        if (pageContextFromRoute.pageId === null) {
-            let hookName;
-            let hookFilePath;
-            if (pageContext._providedByHook) {
-                hookName = pageContext._providedByHook.hookName;
-                hookFilePath = pageContext._providedByHook.hookFilePath;
-            }
-            else if (pageContext._urlOriginalModifiedByHook) {
-                hookName = pageContext._urlOriginalModifiedByHook.hookName;
-                hookFilePath = pageContext._urlOriginalModifiedByHook.hookFilePath;
-            }
-            if (hookName) {
-                assert(hookFilePath);
-                assertUsage(false, `The ${hookName}() hook defined by ${hookFilePath} returns a URL ${pc.cyan(urlOriginal)} that ${noRouteMatch}. Make sure that the URLs returned by ${hookName}() always match the route of a page.`);
-            }
-            else {
-                // `prerenderHookFile` is `null` when the URL was deduced by the Filesytem Routing of `.page.js` files. The `onBeforeRoute()` can override Filesystem Routing; it is therefore expected that the deduced URL may not match any page.
-                assert(pageContextFromRoute._routingProvidedByOnBeforeRouteHook);
-                // Abort since the URL doesn't correspond to any page
-                return;
-            }
-        }
-        assert(pageContextFromRoute.pageId);
-        objectAssign(pageContext, pageContextFromRoute);
-        const { pageId: pageId } = pageContext;
-        objectAssign(pageContext, await loadUserFilesServerSide(pageContext));
-        let usesClientRouter;
-        {
-            if (pageContext._pageConfigs.length > 0) {
-                const pageConfig = pageContext._pageConfigs.find((p) => p.pageId === pageId);
-                assert(pageConfig);
-                usesClientRouter = getConfigValueRuntime(pageConfig, 'clientRouting', 'boolean')?.value ?? false;
-            }
-            else {
-                usesClientRouter = globalContext.usesClientRouter;
-            }
-        }
-        objectAssign(pageContext, {
-            is404: null,
-            _httpRequestId: null,
-            _usesClientRouter: usesClientRouter
-        });
+async function prerenderPages(prerenderContext, concurrencyLimit, onComplete) {
+    await Promise.all(prerenderContext.pageContexts.map((pageContextBeforeRender) => concurrencyLimit(async () => {
         let res;
         try {
-            res = await prerenderPage(pageContext);
+            res = await prerenderPage(pageContextBeforeRender);
         }
         catch (err) {
-            assertIsNotAbort(err, pc.cyan(pageContext.urlOriginal));
+            assertIsNotAbort(err, pc.cyan(pageContextBeforeRender.urlOriginal));
             throw err;
         }
-        const { documentHtml, pageContextSerialized } = res;
+        const { documentHtml, pageContextSerialized, pageContext } = res;
         await onComplete({
-            urlOriginal,
             pageContext,
             htmlString: documentHtml,
             pageContextSerialized,
-            doNotCreateExtraDirectory: prerenderContext.noExtraDir,
-            pageId
+            doNotCreateExtraDirectory: prerenderContext.noExtraDir
         });
     })));
 }
@@ -543,31 +584,27 @@ async function warnMissingPages(prerenderedPageContexts, globalContext, doNotPre
         assertWarning(partial, `Cannot pre-render page ${pageAt} because it has a non-static route, while no ${hookName}() hook returned any URL matching the page's route. You need to use a ${hookName}() hook (https://vike.dev/${hookName}) providing a list of URLs for ${pageAt} that should be pre-rendered. If you don't want to pre-render ${pageAt} then use the option prerender.partial (https://vike.dev/prerender#partial) to suppress this warning.`, { onlyOnce: true });
     });
 }
-async function prerender404(prerenderContext, globalContext, onComplete) {
-    if (!Object.values(prerenderContext.prerenderedPageContexts).find(({ urlOriginal }) => urlOriginal === '/404')) {
+async function prerenderPages404(prerenderContext, onComplete, concurrencyLimit) {
+    await Promise.all(prerenderContext.pageContexts404.map((pageContextBeforeRender) => concurrencyLimit(async () => {
         let result;
         try {
-            result = await prerender404Page(prerenderContext.pageContextInit, globalContext);
+            result = await prerenderPage(pageContextBeforeRender);
         }
         catch (err) {
             assertIsNotAbort(err, 'the 404 page');
             throw err;
         }
-        if (result) {
-            const urlOriginal = '/404';
-            const { documentHtml, pageContext } = result;
-            await onComplete({
-                urlOriginal,
-                pageContext,
-                htmlString: documentHtml,
-                pageContextSerialized: null,
-                doNotCreateExtraDirectory: true,
-                pageId: null
-            });
-        }
-    }
+        const { documentHtml, pageContext } = result;
+        await onComplete({
+            pageContext,
+            htmlString: documentHtml,
+            pageContextSerialized: null,
+            doNotCreateExtraDirectory: true
+        });
+    })));
 }
-async function writeFiles({ urlOriginal, pageContext, htmlString, pageContextSerialized, doNotCreateExtraDirectory }, root, outDirClient, onPagePrerender, output, logLevel) {
+async function writeFiles({ pageContext, htmlString, pageContextSerialized, doNotCreateExtraDirectory }, root, outDirClient, onPagePrerender, output, logLevel) {
+    const { urlOriginal } = pageContext;
     assert(urlOriginal.startsWith('/'));
     const writeJobs = [
         write(urlOriginal, pageContext, 'HTML', htmlString, root, outDirClient, doNotCreateExtraDirectory, onPagePrerender, output, logLevel)
@@ -712,26 +749,6 @@ function assertIsNotAbort(err, urlOr404) {
     assert(abortCall);
     assertUsage(false, `${pc.cyan(abortCall)} thrown${thrownBy} while pre-rendering ${urlOr404} but ${pc.cyan(abortCaller)} isn't supported for pre-rendered pages`);
 }
-function makePageContextComputedUrlNonEnumerable(pageContexts) {
-    change(false);
-    return { restoreEnumerable, addPageContextComputedUrl };
-    function restoreEnumerable() {
-        change(true);
-    }
-    function addPageContextComputedUrl(pageContexts) {
-        // Add URL computed props to the user-generated pageContext copies
-        pageContexts.forEach((pageContext) => {
-            const pageContextUrlComputed = getPageContextUrlComputed(pageContext);
-            objectAssign(pageContext, pageContextUrlComputed);
-        });
-    }
-    function change(enumerable) {
-        pageContexts.forEach((pageContext) => {
-            changeEnumerable(pageContext, 'urlPathname', enumerable);
-            changeEnumerable(pageContext, 'urlParsed', enumerable);
-        });
-    }
-}
 function validatePrerenderConfig(
 // Guaranteed by configDef.type to be either an object or boolean
 prerenderConfig) {
@@ -770,7 +787,8 @@ prerenderConfig) {
 function makePublic(prerenderContext) {
     const prerenderContextPublic = makePublicCopy(prerenderContext, 'prerenderContext', [
         'output', // vite-plugin-vercel
-        'pageContexts' // https://vike.dev/i18n#pre-rendering
+        'pageContexts', // https://vike.dev/i18n#pre-rendering
+        'pageContexts404' // https://vike.dev/i18n#pre-rendering
     ]);
     return prerenderContextPublic;
 }

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

@@ -13,6 +13,6 @@ export * from '../../utils/pLimit.js';
 export * from '../../utils/isFilePathAbsoluteFilesystem.js';
 export * from '../../utils/isArray.js';
 export * from '../../utils/isObject.js';
-export * from '../../utils/changeEnumerable.js';
 export * from '../../utils/makePublicCopy.js';
 export * from '../../utils/isNullish.js';
+export * from '../../utils/preservePropertyGetters.js';

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

@@ -15,6 +15,6 @@ export * from '../../utils/pLimit.js';
 export * from '../../utils/isFilePathAbsoluteFilesystem.js';
 export * from '../../utils/isArray.js';
 export * from '../../utils/isObject.js';
-export * from '../../utils/changeEnumerable.js';
 export * from '../../utils/makePublicCopy.js';
 export * from '../../utils/isNullish.js';
+export * from '../../utils/preservePropertyGetters.js';