vike 0.4.227 → 0.4.228-commit-1553dee

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, 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';
@@ -78,23 +77,26 @@ async function runPrerender(options = {}, standaloneTrigger) {
     const viteConfig = await resolveConfig(options.viteConfig || {}, 'build', 'production');
     const vikeConfig = await getVikeConfig(viteConfig);
     const vike = getVikeConfigPublic(viteConfig);
-    assert(vike.prerenderContext.isPrerenderingEnabled);
     const { outDirClient, outDirServer } = getOutDirs(viteConfig);
     const { root } = viteConfig;
     const prerenderConfigGlobal = resolvePrerenderConfigGlobal(vikeConfig);
-    validatePrerenderConfig(prerenderConfigGlobal);
     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 });
+        /* 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 = pLimit(parallel === false || parallel === 0 ? 1 : parallel === true || parallel === undefined ? cpus().length : parallel);
     await initGlobalContext_runPrerender();
     const globalContext = await getGlobalContextInternal();
     globalContext.pageFilesAll.forEach(assertExportNames);
     const prerenderContext = {
-        noExtraDir: noExtraDir ?? false,
+        noExtraDir,
         pageContexts: [],
         pageContextInit: options.pageContextInit ?? null,
         prerenderedPageContexts: {},
@@ -102,21 +104,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;
+        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(`${pc.green(`✓`)} ${prerenderedCount} HTML documents pre-rendered.`);
     }
@@ -228,12 +238,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 +255,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 +287,111 @@ 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))) {
             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));
+        const pageContext = await createPageContext(urlOriginal, prerenderContext, globalContext, is404, pageId, null);
         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 +461,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 +480,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 +515,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 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) {
-    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, 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
         });
     })));
 }
@@ -543,31 +582,8 @@ 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')) {
-        let result;
-        try {
-            result = await 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;
     assert(urlOriginal.startsWith('/'));
     const writeJobs = [
         write(urlOriginal, pageContext, 'HTML', htmlString, root, outDirClient, doNotCreateExtraDirectory, onPagePrerender, output, logLevel)
@@ -699,7 +715,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 (!isAbortError(err))
         return;
     const pageContextAbort = err._pageContextAbort;
@@ -710,62 +726,7 @@ function assertIsNotAbort(err, urlOr404) {
     assert(abortCaller);
     const abortCall = pageContextAbort._abortCall;
     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) {
-    if (!prerenderConfig || typeof prerenderConfig === 'boolean')
-        return;
-    assert(isObject(prerenderConfig));
-    const wrongValue = (() => {
-        {
-            const p = 'partial';
-            if (!hasProp(prerenderConfig, p, 'boolean') && !hasProp(prerenderConfig, p, 'undefined'))
-                return { prop: p, errMsg: 'should be a boolean' };
-        }
-        {
-            const p = 'noExtraDir';
-            if (!hasProp(prerenderConfig, p, 'boolean') && !hasProp(prerenderConfig, p, 'undefined'))
-                return { prop: p, errMsg: 'should be a boolean' };
-        }
-        {
-            const p = 'disableAutoRun';
-            if (!hasProp(prerenderConfig, p, 'boolean') && !hasProp(prerenderConfig, p, 'undefined'))
-                return { prop: p, errMsg: 'should be a boolean' };
-        }
-        {
-            const p = 'parallel';
-            if (!hasProp(prerenderConfig, p, 'boolean') &&
-                !hasProp(prerenderConfig, p, 'number') &&
-                !hasProp(prerenderConfig, p, 'undefined'))
-                return { prop: p, errMsg: 'should be a boolean or a number' };
-        }
-    })();
-    if (wrongValue) {
-        const { prop, errMsg } = wrongValue;
-        assertUsage(false, `Setting ${pc.cyan(`prerender.${prop}`)} ${errMsg}`);
-    }
+    assertUsage(false, `${pc.cyan(abortCall)} thrown${thrownBy} while pre-rendering ${urlOriginal} but ${pc.cyan(abortCaller)} isn't supported for pre-rendered pages`);
 }
 function makePublic(prerenderContext) {
     const prerenderContextPublic = makePublicCopy(prerenderContext, 'prerenderContext', [

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

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

@@ -1,3 +1,4 @@
+export { getGlobalContext };
 export { getGlobalContextSync };
 export { getGlobalContextAsync };
 export { getGlobalContextInternal };
@@ -13,7 +14,6 @@ export { setGlobalContext_isProduction };
 export { setGlobalContext_buildEntry };
 export { clearGlobalContext };
 export { assertBuildInfo };
-export { getViteConfigRuntime };
 export { updateUserFiles };
 export type { BuildInfo };
 export type { GlobalContextInternal };
@@ -22,14 +22,13 @@ import type { ViteManifest } from '../shared/ViteManifest.js';
 import type { ResolvedConfig, ViteDevServer } from 'vite';
 import type { PageConfigUserFriendly, PageConfigsUserFriendly } from '../../shared/page-configs/getPageConfigUserFriendly.js';
 import { type BaseUrlsResolved } from '../shared/resolveBase.js';
+import type { ViteConfigRuntime } from '../plugin/shared/getViteConfigRuntime.js';
 type PageRuntimeInfo = Awaited<ReturnType<typeof getUserFiles>>;
 type GlobalContextInternal = GlobalContext & {
     globalContext_public: GlobalContextPublic;
 };
 type GlobalContext = {
-    viteConfigRuntime: {
-        _baseViteOriginal: null | string;
-    };
+    viteConfigRuntime: ViteConfigRuntime;
     config: PageConfigUserFriendly['config'];
     pages: PageConfigsUserFriendly;
 } & BaseUrlsResolved & PageRuntimeInfo & ({
@@ -51,16 +50,32 @@ type GlobalContext = {
     viteConfig: ResolvedConfig;
 })));
 declare function getGlobalContextInternal(): Promise<GlobalContextInternal>;
-/** @experimental https://vike.dev/getGlobalContext */
-declare function getGlobalContextSync(): GlobalContextPublic;
-/** @experimental https://vike.dev/getGlobalContext */
+/**
+ * Get runtime information about your app.
+ *
+ * https://vike.dev/getGlobalContext
+ */
+declare function getGlobalContext(): Promise<GlobalContextPublic>;
+/**
+ * Get runtime information about your app.
+ *
+ * https://vike.dev/getGlobalContext
+ */
 declare function getGlobalContextAsync(isProduction: boolean): Promise<GlobalContextPublic>;
+/**
+ * Get runtime information about your app.
+ *
+ * https://vike.dev/getGlobalContext
+ *
+ * @deprecated
+ */
+declare function getGlobalContextSync(): GlobalContextPublic;
 type GlobalContextPublic = ReturnType<typeof makePublic>;
-declare function makePublic(globalContext: GlobalContext): Pick<GlobalContext, "pages" | "baseServer" | "baseAssets" | "config" | "assetsManifest" | "viteConfig">;
+declare function makePublic(globalContext: GlobalContext): Pick<GlobalContext, "pages" | "baseServer" | "baseAssets" | "config" | "assetsManifest" | "viteConfig" | "viteConfigRuntime">;
 declare function setGlobalContext_viteDevServer(viteDevServer: ViteDevServer): Promise<void>;
-declare function setGlobalContext_viteConfig(viteConfig: ResolvedConfig, outDirRoot: string): void;
+declare function setGlobalContext_viteConfig(viteConfig: ResolvedConfig, viteConfigRuntime: ViteConfigRuntime): void;
 declare function setGlobalContext_isPrerendering(): void;
-declare function setGlobalContext_isProduction(isProduction: boolean): void;
+declare function setGlobalContext_isProduction(isProduction: boolean, tolerateContraditction?: true): void;
 declare function getViteDevServer(): ViteDevServer | null;
 declare function getViteConfig(): ResolvedConfig | null;
 declare function initGlobalContext_renderPage(): Promise<void>;
@@ -80,14 +95,8 @@ declare function setGlobalContext_buildEntry(buildEntry: unknown): Promise<void>
 type BuildInfo = {
     versionAtBuildTime: string;
     usesClientRouter: boolean;
-    viteConfigRuntime: {
-        _baseViteOriginal: string;
-        vitePluginServerEntry: {
-            inject?: boolean;
-        };
-    };
+    viteConfigRuntime: ViteConfigRuntime;
 };
 declare function assertBuildInfo(buildInfo: unknown): asserts buildInfo is BuildInfo;
-declare function getViteConfigRuntime(viteConfig: ResolvedConfig): BuildInfo['viteConfigRuntime'];
 declare function updateUserFiles(): Promise<void>;
 declare function clearGlobalContext(): void;