vike 0.4.227 → 0.4.228-commit-1553dee

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");
@@ -116,23 +115,26 @@ async function runPrerender(options = {}, standaloneTrigger) {
     const viteConfig = await (0, vite_1.resolveConfig)(options.viteConfig || {}, 'build', 'production');
     const vikeConfig = await (0, getVikeConfig_js_1.getVikeConfig)(viteConfig);
     const vike = (0, commonConfig_js_1.getVikeConfigPublic)(viteConfig);
-    (0, utils_js_1.assert)(vike.prerenderContext.isPrerenderingEnabled);
     const { outDirClient, outDirServer } = (0, getOutDirs_js_1.getOutDirs)(viteConfig);
     const { root } = viteConfig;
     const prerenderConfigGlobal = (0, resolvePrerenderConfig_js_1.resolvePrerenderConfigGlobal)(vikeConfig);
-    validatePrerenderConfig(prerenderConfigGlobal);
     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 });
+        /* TODO/soon: use this again a little while after https://github.com/magne4000/vite-plugin-vercel/pull/156 is merged.
+        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.`
+        )
+        */
+        return { viteConfig };
     }
     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)();
     const globalContext = await (0, globalContext_js_1.getGlobalContextInternal)();
     globalContext.pageFilesAll.forEach(assertExportNames);
     const prerenderContext = {
-        noExtraDir: noExtraDir ?? false,
+        noExtraDir,
         pageContexts: [],
         pageContextInit: options.pageContextInit ?? null,
         prerenderedPageContexts: {},
@@ -140,21 +142,29 @@ async function runPrerender(options = {}, standaloneTrigger) {
     };
     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);
     if (logLevel === 'info') {
         console.log(`${picocolors_1.default.green(`✓`)} ${prerenderedCount} HTML documents pre-rendered.`);
     }
@@ -266,12 +276,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 +293,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 +325,111 @@ 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))) {
             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));
+        const pageContext = await createPageContext(urlOriginal, prerenderContext, globalContext, is404, pageId, null);
         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 +499,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 +518,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 +553,42 @@ async function callOnPrerenderStartHook(prerenderContext, globalContext) {
         }
         delete pageContext.url;
     });
+    // After applying result
     prerenderContext.pageContexts.forEach((pageContext) => {
-        if (pageContext.urlOriginal !== pageContext._urlOriginalBeforeHook) {
+        ;
+        pageContext._restorePropertyGetters?.();
+    });
+    // Assert URL modified by user
+    await Promise.all(prerenderContext.pageContexts.map((pageContext) => concurrencyLimit(async () => {
+        if (pageContext.urlOriginal !== pageContext._urlOriginalBeforeHook && !pageContext.is404) {
             pageContext._urlOriginalModifiedByHook = {
                 hookFilePath,
                 hookName
             };
+            const pageContextFromRoute = await (0, index_js_1.route)(pageContext, 
+            // Avoid calling onBeforeRoute() twice, otherwise onBeforeRoute() will wrongfully believe URL doesn't have locale after onBeforeRoute() already removed the local from the URL when called the first time.
+            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, pageContext } = res;
+        const pageContextSerialized = pageContext.is404 ? null : res.pageContextSerialized;
         await onComplete({
-            urlOriginal,
             pageContext,
             htmlString: documentHtml,
             pageContextSerialized,
-            doNotCreateExtraDirectory: prerenderContext.noExtraDir,
-            pageId
+            doNotCreateExtraDirectory: prerenderContext.noExtraDir ?? pageContext.is404
         });
     })));
 }
@@ -581,31 +620,8 @@ 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')) {
-        let result;
-        try {
-            result = await (0, renderPageAlreadyRouted_js_1.prerender404Page)(prerenderContext.pageContextInit, globalContext);
-        }
-        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
-            });
-        }
-    }
-}
-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)
@@ -737,7 +753,7 @@ function runPrerender_forceExit() {
     assertInfo(false, "Pre-rendering was forced exit. (Didn't gracefully exit because the event queue isn't empty. This is usally fine, see ...", { onlyOnce: false })
     */
 }
-function assertIsNotAbort(err, urlOr404) {
+function assertIsNotAbort(err, urlOriginal) {
     if (!(0, abort_js_1.isAbortError)(err))
         return;
     const pageContextAbort = err._pageContextAbort;
@@ -748,62 +764,7 @@ function assertIsNotAbort(err, urlOr404) {
     (0, utils_js_1.assert)(abortCaller);
     const abortCall = pageContextAbort._abortCall;
     (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) {
-    if (!prerenderConfig || typeof prerenderConfig === 'boolean')
-        return;
-    (0, utils_js_1.assert)((0, utils_js_1.isObject)(prerenderConfig));
-    const wrongValue = (() => {
-        {
-            const p = 'partial';
-            if (!(0, utils_js_1.hasProp)(prerenderConfig, p, 'boolean') && !(0, utils_js_1.hasProp)(prerenderConfig, p, 'undefined'))
-                return { prop: p, errMsg: 'should be a boolean' };
-        }
-        {
-            const p = 'noExtraDir';
-            if (!(0, utils_js_1.hasProp)(prerenderConfig, p, 'boolean') && !(0, utils_js_1.hasProp)(prerenderConfig, p, 'undefined'))
-                return { prop: p, errMsg: 'should be a boolean' };
-        }
-        {
-            const p = 'disableAutoRun';
-            if (!(0, utils_js_1.hasProp)(prerenderConfig, p, 'boolean') && !(0, utils_js_1.hasProp)(prerenderConfig, p, 'undefined'))
-                return { prop: p, errMsg: 'should be a boolean' };
-        }
-        {
-            const p = 'parallel';
-            if (!(0, utils_js_1.hasProp)(prerenderConfig, p, 'boolean') &&
-                !(0, utils_js_1.hasProp)(prerenderConfig, p, 'number') &&
-                !(0, utils_js_1.hasProp)(prerenderConfig, p, 'undefined'))
-                return { prop: p, errMsg: 'should be a boolean or a number' };
-        }
-    })();
-    if (wrongValue) {
-        const { prop, errMsg } = wrongValue;
-        (0, utils_js_1.assertUsage)(false, `Setting ${picocolors_1.default.cyan(`prerender.${prop}`)} ${errMsg}`);
-    }
+    (0, utils_js_1.assertUsage)(false, `${picocolors_1.default.cyan(abortCall)} thrown${thrownBy} while pre-rendering ${urlOriginal} but ${picocolors_1.default.cyan(abortCaller)} isn't supported for pre-rendered pages`);
 }
 function makePublic(prerenderContext) {
     const prerenderContextPublic = (0, utils_js_1.makePublicCopy)(prerenderContext, 'prerenderContext', [

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);