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

package/dist/cjs/node/plugin/plugins/commonConfig.js

@@ -38,7 +38,8 @@ function commonConfig(vikeVitePluginOptions) {
                         isPrerenderingEnabled,
                         isPrerenderingEnabledForAllPages,
                         output: null,
-                        pageContexts: null
+                        pageContexts: null,
+                        pageContexts404: null
                     });
                     (0, utils_js_1.assert)(prerenderContext.isPrerenderingEnabled === isPrerenderingEnabled);
                     (0, utils_js_1.assert)(prerenderContext.isPrerenderingEnabledForAllPages === isPrerenderingEnabledForAllPages);

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

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

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

@@ -5,7 +5,6 @@ const utils_js_1 = require("../utils.js");
 const module_1 = require("module");
 // @ts-ignore `file://${__filename}` is shimmed at dist/cjs by dist-cjs-fixup.js.
 const importMetaUrl = `file://${__filename}`;
-const require_ = (0, module_1.createRequire)(importMetaUrl);
 (0, utils_js_1.assertIsNotProductionRuntime)();
 async function resolveClientEntriesDev(clientEntry, viteDevServer) {
     let root = viteDevServer.config.root;
@@ -28,6 +27,7 @@ async function resolveClientEntriesDev(clientEntry, viteDevServer) {
     }
     else {
         if (clientEntry.startsWith('@@vike/')) {
+            const require_ = (0, module_1.createRequire)(importMetaUrl);
             (0, utils_js_1.assert)(clientEntry.endsWith('.js'));
             try {
                 // For Vitest (which doesn't resolve vike to its dist but to its source files)
@@ -41,6 +41,7 @@ async function resolveClientEntriesDev(clientEntry, viteDevServer) {
             }
         }
         else {
+            const require_ = (0, module_1.createRequire)(root);
             (0, utils_js_1.assertIsNpmPackageImport)(clientEntry);
             filePath = require_.resolve(clientEntry);
         }

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

@@ -54,7 +54,6 @@ const resolveRouteString_js_1 = require("../../shared/route/resolveRouteString.j
 const getConfigValueRuntime_js_1 = require("../../shared/page-configs/getConfigValueRuntime.js");
 const loadConfigValues_js_1 = require("../../shared/page-configs/loadConfigValues.js");
 const error_page_js_1 = require("../../shared/error-page.js");
-const getPageContextUrlComputed_js_1 = require("../../shared/getPageContextUrlComputed.js");
 const abort_js_1 = require("../../shared/route/abort.js");
 const loadUserFilesServerSide_js_1 = require("../runtime/renderPage/loadUserFilesServerSide.js");
 const getHook_js_1 = require("../../shared/hooks/getHook.js");
@@ -124,8 +123,7 @@ async function runPrerender(options = {}, standaloneTrigger) {
     const { partial, noExtraDir, parallel, defaultLocalValue, isPrerenderingEnabled } = prerenderConfigGlobal;
     if (!isPrerenderingEnabled) {
         (0, utils_js_1.assert)(standaloneTrigger);
-        // TODO/now: make it assertUsage() and remove dist/server/entry.mjs if pre-rendering is completely disabled
-        (0, utils_js_1.assertWarning)(false, `You're executing ${picocolors_1.default.cyan(standaloneTrigger)} but you didn't enable pre-rendering. Use the ${picocolors_1.default.cyan('prerender')} setting (${picocolors_1.default.underline('https://vike.dev/prerender')}) to enable pre-rendering for at least one page.`, { onlyOnce: true });
+        (0, utils_js_1.assertUsage)(false, `You're executing ${picocolors_1.default.cyan(standaloneTrigger)} but you didn't enable pre-rendering. Use the ${picocolors_1.default.cyan('prerender')} setting (${picocolors_1.default.underline('https://vike.dev/prerender')}) to enable pre-rendering for at least one page.`);
     }
     const concurrencyLimit = (0, utils_js_1.pLimit)(parallel === false || parallel === 0 ? 1 : parallel === true || parallel === undefined ? (0, os_1.cpus)().length : parallel);
     await (0, globalContext_js_1.initGlobalContext_runPrerender)();
@@ -134,27 +132,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;
+        (0, utils_js_1.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(`${picocolors_1.default.green(`✓`)} ${prerenderedCount} HTML documents pre-rendered.`);
     }
@@ -266,12 +274,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 (0, executeHook_js_1.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) {
@@ -282,30 +291,23 @@ async function callOnBeforePrerenderStartHooks(prerenderContext, globalContext,
                     (0, utils_js_1.assertUsage)(false, `URL ${picocolors_1.default.cyan(url)} provided ${providedTwice}. Make sure to provide the URL only once instead.`);
                 }
             }
-            const pageContextNew = await createPageContext(url, prerenderContext, globalContext);
-            (0, utils_js_1.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) {
-                (0, utils_js_1.objectAssign)(pageContextNew, {
-                    _pageContextAlreadyProvidedByOnPrerenderHook: true
-                });
+                (0, utils_js_1.objectAssign)(pageContextNew, { _pageContextAlreadyProvidedByOnPrerenderHook: true });
                 (0, utils_js_1.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
@@ -321,43 +323,116 @@ async function handlePagesWithStaticRoutes(prerenderContext, globalContext, doNo
             urlOriginal = url;
         }
         (0, utils_js_1.assert)(urlOriginal.startsWith('/'));
+        urlList.push({ urlOriginal, pageId });
+    });
+    return urlList;
+}
+function getUrlList404(globalContext) {
+    const urlList = [];
+    const errorPageId = (0, error_page_js_1.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);
-        (0, utils_js_1.objectAssign)(pageContext, {
-            _providedByHook: null,
-            routeParams,
-            pageId: pageId,
-            _debugRouteMatches: [
-                {
-                    pageId,
-                    routeType: pageRoute.routeType,
-                    routeString: urlOriginal,
-                    routeParams
-                }
-            ]
-        });
-        (0, utils_js_1.objectAssign)(pageContext, await (0, loadUserFilesServerSide_js_1.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 };
-    (0, utils_js_1.objectAssign)(pageContextInit, prerenderContext.pageContextInit);
-    const pageContext = await (0, renderPageAlreadyRouted_js_1.getPageContextInitEnhanced)(pageContextInit, globalContext, true, {});
+async function createPageContext(urlOriginal, prerenderContext, globalContext, is404, pageId, providedByHook) {
+    const pageContextInit = {
+        urlOriginal,
+        ...prerenderContext.pageContextInit
+    };
+    const pageContext = await (0, renderPageAlreadyRouted_js_1.getPageContextInitEnhanced)(pageContextInit, globalContext, true);
     (0, utils_js_1.assert)(pageContext.isPrerendering === true);
     (0, utils_js_1.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 (0, index_js_1.route)(pageContext);
+        (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageContextFromRoute, 'pageId', 'null') || (0, utils_js_1.hasProp)(pageContextFromRoute, 'pageId', 'string')); // Help TS
+        assertRouteMatch(pageContextFromRoute, pageContext);
+        (0, utils_js_1.assert)(pageContextFromRoute.pageId);
+        (0, utils_js_1.objectAssign)(pageContext, pageContextFromRoute);
+    }
+    else {
+        (0, utils_js_1.assert)(pageId);
+        (0, utils_js_1.objectAssign)(pageContext, {
+            pageId,
+            _debugRouteMatches: [],
+            routeParams: {}
+        });
+    }
+    (0, utils_js_1.objectAssign)(pageContext, await (0, loadUserFilesServerSide_js_1.loadUserFilesServerSide)(pageContext));
+    let usesClientRouter;
+    {
+        const { pageId } = pageContext;
+        (0, utils_js_1.assert)(pageId);
+        (0, utils_js_1.assert)(globalContext.isPrerendering);
+        if (globalContext.pageConfigs.length > 0) {
+            const pageConfig = globalContext.pageConfigs.find((p) => p.pageId === pageId);
+            (0, utils_js_1.assert)(pageConfig);
+            usesClientRouter = (0, getConfigValueRuntime_js_1.getConfigValueRuntime)(pageConfig, 'clientRouting', 'boolean')?.value ?? false;
+        }
+        else {
+            usesClientRouter = globalContext.usesClientRouter;
+        }
+    }
+    (0, utils_js_1.objectAssign)(pageContext, { _usesClientRouter: usesClientRouter });
     return pageContext;
 }
-async function callOnPrerenderStartHook(prerenderContext, globalContext) {
+function assertRouteMatch(pageContextFromRoute, pageContext) {
+    if (pageContextFromRoute.pageId !== null) {
+        (0, utils_js_1.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) {
+        (0, utils_js_1.assert)(hookFilePath);
+        const { urlOriginal } = pageContext;
+        (0, utils_js_1.assert)(urlOriginal);
+        (0, utils_js_1.assertUsage)(false, `The ${hookName}() hook defined by ${hookFilePath} returns a URL ${picocolors_1.default.cyan(urlOriginal)} that ${noRouteMatch_js_1.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.
+        (0, utils_js_1.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) {
@@ -427,8 +502,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
+        (0, utils_js_1.preservePropertyGetters)(pageContext);
+    });
     let result = await (0, executeHook_js_1.executeHook)(() => {
         const prerenderContextPublic = makePublic(prerenderContext);
         // TODO/v1-release: remove warning
@@ -443,7 +521,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;
     }
@@ -474,82 +556,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 (0, index_js_1.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) {
-    (0, utils_js_1.assert)(globalContext.isPrerendering);
-    // Route all URLs
-    await Promise.all(prerenderContext.pageContexts.map((pageContext) => concurrencyLimit(async () => {
-        const { urlOriginal } = pageContext;
-        (0, utils_js_1.assert)(urlOriginal);
-        const pageContextFromRoute = await (0, index_js_1.route)(pageContext);
-        (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageContextFromRoute, 'pageId', 'null') || (0, utils_js_1.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) {
-                (0, utils_js_1.assert)(hookFilePath);
-                (0, utils_js_1.assertUsage)(false, `The ${hookName}() hook defined by ${hookFilePath} returns a URL ${picocolors_1.default.cyan(urlOriginal)} that ${noRouteMatch_js_1.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.
-                (0, utils_js_1.assert)(pageContextFromRoute._routingProvidedByOnBeforeRouteHook);
-                // Abort since the URL doesn't correspond to any page
-                return;
-            }
-        }
-        (0, utils_js_1.assert)(pageContextFromRoute.pageId);
-        (0, utils_js_1.objectAssign)(pageContext, pageContextFromRoute);
-        const { pageId: pageId } = pageContext;
-        (0, utils_js_1.objectAssign)(pageContext, await (0, loadUserFilesServerSide_js_1.loadUserFilesServerSide)(pageContext));
-        let usesClientRouter;
-        {
-            if (pageContext._pageConfigs.length > 0) {
-                const pageConfig = pageContext._pageConfigs.find((p) => p.pageId === pageId);
-                (0, utils_js_1.assert)(pageConfig);
-                usesClientRouter = (0, getConfigValueRuntime_js_1.getConfigValueRuntime)(pageConfig, 'clientRouting', 'boolean')?.value ?? false;
-            }
-            else {
-                usesClientRouter = globalContext.usesClientRouter;
-            }
-        }
-        (0, utils_js_1.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 (0, renderPageAlreadyRouted_js_1.prerenderPage)(pageContext);
+            res = await (0, renderPageAlreadyRouted_js_1.prerenderPage)(pageContextBeforeRender);
         }
         catch (err) {
-            assertIsNotAbort(err, picocolors_1.default.cyan(pageContext.urlOriginal));
+            assertIsNotAbort(err, picocolors_1.default.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
         });
     })));
 }
@@ -581,31 +622,27 @@ async function warnMissingPages(prerenderedPageContexts, globalContext, doNotPre
         (0, utils_js_1.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 (0, renderPageAlreadyRouted_js_1.prerender404Page)(prerenderContext.pageContextInit, globalContext);
+            result = await (0, renderPageAlreadyRouted_js_1.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;
     (0, utils_js_1.assert)(urlOriginal.startsWith('/'));
     const writeJobs = [
         write(urlOriginal, pageContext, 'HTML', htmlString, root, outDirClient, doNotCreateExtraDirectory, onPagePrerender, output, logLevel)
@@ -750,26 +787,6 @@ function assertIsNotAbort(err, urlOr404) {
     (0, utils_js_1.assert)(abortCall);
     (0, utils_js_1.assertUsage)(false, `${picocolors_1.default.cyan(abortCall)} thrown${thrownBy} while pre-rendering ${urlOr404} but ${picocolors_1.default.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 = (0, getPageContextUrlComputed_js_1.getPageContextUrlComputed)(pageContext);
-            (0, utils_js_1.objectAssign)(pageContext, pageContextUrlComputed);
-        });
-    }
-    function change(enumerable) {
-        pageContexts.forEach((pageContext) => {
-            (0, utils_js_1.changeEnumerable)(pageContext, 'urlPathname', enumerable);
-            (0, utils_js_1.changeEnumerable)(pageContext, 'urlParsed', enumerable);
-        });
-    }
-}
 function validatePrerenderConfig(
 // Guaranteed by configDef.type to be either an object or boolean
 prerenderConfig) {
@@ -808,7 +825,8 @@ prerenderConfig) {
 function makePublic(prerenderContext) {
     const prerenderContextPublic = (0, utils_js_1.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/cjs/node/prerender/utils.js

@@ -31,6 +31,6 @@ __exportStar(require("../../utils/pLimit.js"), exports);
 __exportStar(require("../../utils/isFilePathAbsoluteFilesystem.js"), exports);
 __exportStar(require("../../utils/isArray.js"), exports);
 __exportStar(require("../../utils/isObject.js"), exports);
-__exportStar(require("../../utils/changeEnumerable.js"), exports);
 __exportStar(require("../../utils/makePublicCopy.js"), exports);
 __exportStar(require("../../utils/isNullish.js"), exports);
+__exportStar(require("../../utils/preservePropertyGetters.js"), exports);

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

@@ -5,7 +5,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.renderPageAlreadyRouted = renderPageAlreadyRouted;
 exports.prerenderPage = prerenderPage;
-exports.prerender404Page = prerender404Page;
 exports.getPageContextInitEnhanced = getPageContextInitEnhanced;
 exports.createPageContext = createPageContext;
 const error_page_js_1 = require("../../../shared/error-page.js");
@@ -85,28 +84,6 @@ async function prerenderPage(pageContext) {
         return { documentHtml, pageContextSerialized, pageContext };
     }
 }
-async function prerender404Page(pageContextInit_, globalContext) {
-    const errorPageId = (0, error_page_js_1.getErrorPageId)(globalContext.pageFilesAll, globalContext.pageConfigs);
-    if (!errorPageId) {
-        return null;
-    }
-    // A URL is required for `viteDevServer.transformIndexHtml(url,html)`
-    const pageContextInit = { urlOriginal: '/fake-404-url' };
-    (0, utils_js_1.objectAssign)(pageContextInit, pageContextInit_);
-    const pageContext = await getPageContextInitEnhanced(pageContextInit, globalContext, true);
-    (0, utils_js_1.objectAssign)(pageContext, {
-        pageId: errorPageId,
-        _httpRequestId: null,
-        _urlRewrite: null,
-        is404: true,
-        routeParams: {},
-        // `prerender404Page()` is about generating `dist/client/404.html` for static hosts; there is no Client Routing.
-        _usesClientRouter: false,
-        _debugRouteMatches: []
-    });
-    (0, utils_js_1.objectAssign)(pageContext, await (0, loadUserFilesServerSide_js_1.loadUserFilesServerSide)(pageContext));
-    return prerenderPage(pageContext);
-}
 async function getPageContextInitEnhanced(pageContextInit, globalContext, isPrerendering, { ssr: { urlRewrite, urlHandler, isClientSideNavigation } = {
     urlRewrite: null,
     urlHandler: null,

package/dist/cjs/shared/route/index.js

@@ -18,23 +18,25 @@ const resolveRouteFunction_js_1 = require("./resolveRouteFunction.js");
 const executeOnBeforeRouteHook_js_1 = require("./executeOnBeforeRouteHook.js");
 const debug_js_1 = require("./debug.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
-async function route(pageContext) {
+async function route(pageContext, skipOnBeforeRouteHook) {
     (0, debug_js_1.debug)('Pages routes:', pageContext._pageRoutes);
     (0, getPageContextUrlComputed_js_1.assertPageContextUrl)(pageContext);
     const pageContextFromRoute = {};
     // onBeforeRoute()
-    const pageContextFromOnBeforeRouteHook = await (0, executeOnBeforeRouteHook_js_1.executeOnBeforeRouteHook)(pageContext);
-    if (pageContextFromOnBeforeRouteHook) {
-        if (pageContextFromOnBeforeRouteHook._routingProvidedByOnBeforeRouteHook) {
-            (0, utils_js_1.assert)(pageContextFromOnBeforeRouteHook.pageId);
-            return pageContextFromOnBeforeRouteHook;
-        }
-        else {
-            (0, utils_js_1.objectAssign)(pageContextFromRoute, pageContextFromOnBeforeRouteHook);
+    if (!skipOnBeforeRouteHook) {
+        const pageContextFromOnBeforeRouteHook = await (0, executeOnBeforeRouteHook_js_1.executeOnBeforeRouteHook)(pageContext);
+        if (pageContextFromOnBeforeRouteHook) {
+            if (pageContextFromOnBeforeRouteHook._routingProvidedByOnBeforeRouteHook) {
+                (0, utils_js_1.assert)(pageContextFromOnBeforeRouteHook.pageId);
+                return pageContextFromOnBeforeRouteHook;
+            }
+            else {
+                (0, utils_js_1.objectAssign)(pageContextFromRoute, pageContextFromOnBeforeRouteHook);
+            }
         }
+        // We take into account pageContext.urlLogical set by onBeforeRoute()
+        (0, utils_js_1.objectAssign)(pageContext, pageContextFromOnBeforeRouteHook);
     }
-    // We take into account pageContext.urlLogical set by onBeforeRoute()
-    (0, utils_js_1.objectAssign)(pageContext, pageContextFromOnBeforeRouteHook);
     // Vike's routing
     const allPageIds = pageContext._allPageIds;
     (0, utils_js_1.assertUsage)(allPageIds.length > 0, 'No page found. You must create at least one page.');

package/dist/cjs/utils/PROJECT_VERSION.js

@@ -2,4 +2,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PROJECT_VERSION = void 0;
 // Automatically updated by @brillout/release-me
-exports.PROJECT_VERSION = '0.4.227-commit-e36b916';
+exports.PROJECT_VERSION = '0.4.227-commit-25aa0f8';

package/dist/cjs/utils/preservePropertyGetters.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preservePropertyGetters = preservePropertyGetters;
+const assert_js_1 = require("./assert.js");
+function preservePropertyGetters(objOriginal) {
+    // Store original getter descriptors
+    const getters = Object.fromEntries(Object.entries(Object.getOwnPropertyDescriptors(objOriginal)).filter(([_, desc]) => 'get' in desc));
+    // Make getters non-enumerable
+    for (const [key, desc] of Object.entries(getters)) {
+        Object.defineProperty(objOriginal, key, { ...desc, enumerable: false });
+    }
+    const restorePropertyGetters = function () {
+        const objCopy = this;
+        delete objOriginal._restorePropertyGetters;
+        delete objCopy._restorePropertyGetters;
+        for (const [key, desc] of Object.entries(getters)) {
+            if (objCopy !== objOriginal) {
+                (0, assert_js_1.assert)(!(key in objCopy));
+                Object.defineProperty(objCopy, key, desc); // Add property getters to copy
+            }
+            (0, assert_js_1.assert)(key in objOriginal);
+            Object.defineProperty(objOriginal, key, desc); // Restore original `enumerable` value
+        }
+    };
+    Object.defineProperty(objOriginal, '_restorePropertyGetters', {
+        value: restorePropertyGetters,
+        enumerable: true,
+        configurable: true
+    });
+}

package/dist/esm/node/plugin/plugins/commonConfig.js

@@ -33,7 +33,8 @@ function commonConfig(vikeVitePluginOptions) {
                         isPrerenderingEnabled,
                         isPrerenderingEnabledForAllPages,
                         output: null,
-                        pageContexts: null
+                        pageContexts: null,
+                        pageContexts404: null
                     });
                     assert(prerenderContext.isPrerenderingEnabled === isPrerenderingEnabled);
                     assert(prerenderContext.isPrerenderingEnabledForAllPages === isPrerenderingEnabledForAllPages);