vike 0.4.229 → 0.4.230

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

@@ -0,0 +1,71 @@
+export { replaceConstants };
+import MagicString from 'magic-string';
+import { assert, assertPosixPath } from '../utils.js';
+import { normalizeId } from '../shared/normalizeId.js';
+import { isViteServerBuild_safe } from '../shared/isViteServerBuild.js';
+import { applyRegExpWithMagicString } from '../shared/applyRegExWithMagicString.js';
+function replaceConstants() {
+    let config;
+    return {
+        name: 'vike:replaceConstants',
+        enforce: 'post',
+        apply: 'build',
+        configResolved(config_) {
+            config = config_;
+        },
+        transform(code, id, options) {
+            id = normalizeId(id);
+            assertPosixPath(id);
+            if (id.includes('/node_modules/'))
+                return;
+            assertPosixPath(config.root);
+            if (!id.startsWith(config.root))
+                return;
+            if (!code.includes('import.meta.env.'))
+                return;
+            const isBuild = config.command === 'build';
+            assert(isBuild);
+            // Used by vike.dev
+            // https://github.com/vikejs/vike/blob/08a1ff55c80ddca64ca6d4417fefd45fefeb4ffb/docs/vite.config.ts#L12
+            // @ts-expect-error
+            if (config._skipVikeReplaceConstants?.(id))
+                return;
+            const magicString = new MagicString(code);
+            const constantsMap = [];
+            constantsMap.push({
+                constants: ['pageContext.isClientSide', 'globalContext.isClientSide', 'pageContext.globalContext.isClientSide'],
+                replacement: !isViteServerBuild_safe(config, options)
+            });
+            constantsMap.forEach(({ constants, replacement }) => {
+                if (!constants.some((c) => code.includes(c)))
+                    return;
+                const regExp = getConstantRegExp(constants);
+                applyRegExpWithMagicString(magicString, regExp, replacement);
+            });
+            if (!magicString.hasChanged())
+                return null;
+            return {
+                code: magicString.toString(),
+                map: magicString.generateMap({ hires: true, source: id })
+            };
+        }
+    };
+}
+// Copied & adapted from:
+// https://github.com/rollup/plugins/blob/e1a5ef99f1578eb38a8c87563cb9651db228f3bd/packages/replace/src/index.js#L57-L67
+function getConstantRegExp(constants) {
+    const keys = Object.values(constants).sort(longest).map(escape);
+    // const delimiters = ['\\b', '\\b(?!\\.)']
+    const delimiters = ['(?<!\\.)\\b', '\\b(?!\\.)']; // Improved version, to avoid replacing `globalContext.pageContext.isClientSide` with `globalContext.false`
+    const preventAssignment = false; // Let's try without it first, let's see if a user complains
+    const lookbehind = preventAssignment ? '(?<!\\b(?:const|let|var)\\s*)' : '';
+    const lookahead = preventAssignment ? '(?!\\s*=[^=])' : '';
+    const pattern = new RegExp(`${lookbehind}${delimiters[0]}(${keys.join('|')})${delimiters[1]}${lookahead}`, 'g');
+    return pattern;
+}
+function escape(str) {
+    return str.replace(/[-[\]/{}()*+?.\\^$|]/g, '\\$&');
+}
+function longest(a, b) {
+    return b.length - a.length;
+}

package/dist/esm/node/plugin/shared/applyRegExWithMagicString.d.ts

@@ -0,0 +1,3 @@
+export { applyRegExpWithMagicString };
+import type MagicString from 'magic-string';
+declare function applyRegExpWithMagicString(magicString: MagicString, regExp: string | RegExp, replacement: unknown): void;

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

@@ -0,0 +1,8 @@
+export { applyRegExpWithMagicString };
+function applyRegExpWithMagicString(magicString, regExp, replacement) {
+    const envStatementRegEx = typeof regExp === 'string' ? new RegExp(regExp, 'g') : regExp;
+    let match;
+    while ((match = envStatementRegEx.exec(magicString.original))) {
+        magicString.overwrite(match.index, match.index + match[0].length, JSON.stringify(replacement));
+    }
+}

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

@@ -1,13 +1,13 @@
 export { findPageFiles };
 import { glob } from 'tinyglobby';
-import { assertWarning, toPosixPath, scriptFileExtensions } from '../utils.js';
+import { assertWarning, toPosixPath, scriptFileExtensionPattern } from '../utils.js';
 import pc from '@brillout/picocolors';
 import { getOutDirs } from './getOutDirs.js';
 async function findPageFiles(config, fileTypes, isDev) {
     const cwd = config.root;
     const { outDirRoot } = getOutDirs(config);
     const timeBase = new Date().getTime();
-    let pageFiles = await glob(fileTypes.map((fileType) => `**/*${fileType}.${scriptFileExtensions}`), { ignore: ['**/node_modules/**', `${outDirRoot}/**`], cwd, dot: false, expandDirectories: false });
+    let pageFiles = await glob(fileTypes.map((fileType) => `**/*${fileType}.${scriptFileExtensionPattern}`), { ignore: ['**/node_modules/**', `${outDirRoot}/**`], cwd, dot: false, expandDirectories: false });
     pageFiles = pageFiles.map((p) => '/' + toPosixPath(p));
     const time = new Date().getTime() - timeBase;
     if (isDev) {

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

@@ -22,7 +22,7 @@ import { logWithVikeTag, logWithViteTag, logDirectly, applyViteSourceMapToStackT
 import pc from '@brillout/picocolors';
 import { setAlreadyLogged } from '../../runtime/renderPage/isNewError.js';
 import { onRuntimeError } from '../../runtime/renderPage/loggerProd.js';
-import { isUserHookError } from '../../../shared/hooks/executeHook.js';
+import { isUserHookError } from '../../../shared/hooks/execHook.js';
 assertIsNotProductionRuntime();
 overwriteRuntimeProductionLogger(logRuntimeError, logRuntimeInfo);
 overwriteAssertProductionLogger(assertLogger);

package/dist/esm/node/plugin/shared/resolveClientEntriesDev.d.ts

@@ -1,4 +1,4 @@
 export { resolveClientEntriesDev };
 export type ResolveClientEntriesDev = typeof resolveClientEntriesDev;
 import type { ViteDevServer } from 'vite';
-declare function resolveClientEntriesDev(clientEntry: string, viteDevServer: ViteDevServer): Promise<string>;
+declare function resolveClientEntriesDev(clientEntry: string, viteDevServer: ViteDevServer): string;

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

@@ -1,7 +1,7 @@
 export { resolveClientEntriesDev };
 import { assert, assertPosixPath, toPosixPath, pathJoin, assertIsImportPathNpmPackage, assertIsNotProductionRuntime, requireResolveNpmPackage, requireResolveVikeDistFile } from '../utils.js';
 assertIsNotProductionRuntime();
-async function resolveClientEntriesDev(clientEntry, viteDevServer) {
+function resolveClientEntriesDev(clientEntry, viteDevServer) {
     let userRootDir = viteDevServer.config.root;
     assert(userRootDir);
     userRootDir = toPosixPath(userRootDir);

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

@@ -5,7 +5,7 @@ export { runPrerender_forceExit };
 export type { PrerenderOptions };
 export type { PrerenderContextPublic };
 import type { PageFile } from '../../shared/getPageFiles.js';
-import { type GlobalContextServerInternal, type GlobalContextServer } from '../runtime/globalContext.js';
+import { type GlobalContextServerInternal } from '../runtime/globalContext.js';
 import type { InlineConfig, ResolvedConfig } from 'vite';
 import type { APIOptions } from '../api/types.js';
 type ProvidedByHook = null | {
@@ -22,6 +22,7 @@ type PageContextPrerendered = {
     pageId: string;
 };
 type PrerenderedPageContexts = Record<string, PageContextPrerendered>;
+type PrerenderContextPublic = Pick<PrerenderContext, 'pageContexts' | 'output'>;
 type PrerenderContext = {
     pageContexts: PageContext[];
     output: Output;
@@ -66,23 +67,35 @@ declare function runPrerenderFromCLIPrerenderCommand(): Promise<void>;
 declare function runPrerenderFromAutoRun(viteConfig: InlineConfig | undefined): Promise<{
     forceExit: boolean;
 }>;
-declare function createPageContextPrerendering(urlOriginal: string, prerenderContext: PrerenderContext, globalContext: GlobalContextServerInternal, globalContext_public: GlobalContextServer, is404: boolean, pageId: string | undefined, providedByHook: ProvidedByHook): Promise<((({
-    isClientSide: boolean;
+declare function createPageContextPrerendering(urlOriginal: string, prerenderContext: PrerenderContext, globalContext: GlobalContextServerInternal, is404: boolean, pageId: string | undefined, providedByHook: ProvidedByHook): Promise<((({
+    _isOriginalObject: true;
+    isPageContext: true;
+} & {
+    isClientSide: false;
     isPrerendering: boolean;
-} & Pick<import("../../shared/types.js").PageContextBuiltInServerInternal, "urlOriginal" | "headersOriginal"> & {
+} & Pick<import("../../shared/types.js").PageContextInternalServer, "urlOriginal" | "headersOriginal"> & {
     url?: string;
     headers?: Record<string, string>;
 } & {
-    globalContext: GlobalContextServer;
     _globalContext: {
         isGlobalContext: true;
+        _isOriginalObject: true;
         _virtualFileExports: unknown;
         _pageFilesAll: PageFile[];
         _pageConfigs: import("../../shared/page-configs/PageConfig.js").PageConfigRuntime[];
         _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
         _allPageIds: string[];
+        _userFriendlyConfigsGlobal: import("../../shared/page-configs/getUserFriendlyConfigs.js").PageConfigUserFriendly;
         config: import("../../types/index.js").ConfigResolved;
-        pages: import("../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
+        pages: {
+            [k: string]: import("../../shared/page-configs/getUserFriendlyConfigs.js").PageConfigUserFriendly & ({
+                route: import("../../shared/page-configs/Config.js").Route;
+                isErrorPage?: undefined;
+            } | {
+                route?: undefined;
+                isErrorPage: true;
+            });
+        };
     } & ({
         _isProduction: false;
         _isPrerendering: false;
@@ -104,14 +117,6 @@ declare function createPageContextPrerendering(urlOriginal: string, prerenderCon
         isClientSide: false;
         _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
         _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
-        isGlobalContext: true;
-        _virtualFileExports: unknown;
-        _pageFilesAll: PageFile[];
-        _pageConfigs: import("../../shared/page-configs/PageConfig.js").PageConfigRuntime[];
-        _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
-        _allPageIds: string[];
-        config: import("../../types/index.js").ConfigResolved;
-        pages: import("../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
     } | {
         _isPrerendering: true;
         viteConfig: ResolvedConfig;
@@ -134,14 +139,6 @@ declare function createPageContextPrerendering(urlOriginal: string, prerenderCon
         isClientSide: false;
         _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
         _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
-        isGlobalContext: true;
-        _virtualFileExports: unknown;
-        _pageFilesAll: PageFile[];
-        _pageConfigs: import("../../shared/page-configs/PageConfig.js").PageConfigRuntime[];
-        _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
-        _allPageIds: string[];
-        config: import("../../types/index.js").ConfigResolved;
-        pages: import("../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
     } | {
         _isPrerendering: false;
         viteConfig: null;
@@ -164,14 +161,6 @@ declare function createPageContextPrerendering(urlOriginal: string, prerenderCon
         isClientSide: false;
         _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
         _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
-        isGlobalContext: true;
-        _virtualFileExports: unknown;
-        _pageFilesAll: PageFile[];
-        _pageConfigs: import("../../shared/page-configs/PageConfig.js").PageConfigRuntime[];
-        _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
-        _allPageIds: string[];
-        config: import("../../types/index.js").ConfigResolved;
-        pages: import("../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
     });
     _baseServer: string;
     _baseAssets: string;
@@ -186,18 +175,12 @@ declare function createPageContextPrerendering(urlOriginal: string, prerenderCon
     _urlRewrite: null;
     _urlHandler: ((url: string) => string) | null;
     isClientSideNavigation: boolean;
-} & {
+} & import("../../shared/page-configs/getUserFriendlyConfigs.js").PageConfigUserFriendly & {
     urlParsed: import("../shared/utils.js").UrlPublic;
     urlPathname: string;
     url: string;
 } & {
     headers: Record<string, string> | null;
-} & {
-    config: import("../../types/index.js").ConfigResolved;
-    _source: import("../../shared/page-configs/getPageConfigUserFriendly.js").Source;
-    _sources: import("../../shared/page-configs/getPageConfigUserFriendly.js").Sources;
-    _from: import("../../shared/page-configs/getPageConfigUserFriendly.js").From;
-    isPageContext: true;
 } & {
     _urlHandler: null;
     _httpRequestId: null;
@@ -208,22 +191,34 @@ declare function createPageContextPrerendering(urlOriginal: string, prerenderCon
     _urlOriginalModifiedByHook: ProvidedByHookTransformer;
     is404: boolean;
 } & import("../../shared/route/index.js").PageContextFromRoute & Record<"pageId", string>) | ({
-    isClientSide: boolean;
+    _isOriginalObject: true;
+    isPageContext: true;
+} & {
+    isClientSide: false;
     isPrerendering: boolean;
-} & Pick<import("../../shared/types.js").PageContextBuiltInServerInternal, "urlOriginal" | "headersOriginal"> & {
+} & Pick<import("../../shared/types.js").PageContextInternalServer, "urlOriginal" | "headersOriginal"> & {
     url?: string;
     headers?: Record<string, string>;
 } & {
-    globalContext: GlobalContextServer;
     _globalContext: {
         isGlobalContext: true;
+        _isOriginalObject: true;
         _virtualFileExports: unknown;
         _pageFilesAll: PageFile[];
         _pageConfigs: import("../../shared/page-configs/PageConfig.js").PageConfigRuntime[];
         _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
         _allPageIds: string[];
+        _userFriendlyConfigsGlobal: import("../../shared/page-configs/getUserFriendlyConfigs.js").PageConfigUserFriendly;
         config: import("../../types/index.js").ConfigResolved;
-        pages: import("../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
+        pages: {
+            [k: string]: import("../../shared/page-configs/getUserFriendlyConfigs.js").PageConfigUserFriendly & ({
+                route: import("../../shared/page-configs/Config.js").Route;
+                isErrorPage?: undefined;
+            } | {
+                route?: undefined;
+                isErrorPage: true;
+            });
+        };
     } & ({
         _isProduction: false;
         _isPrerendering: false;
@@ -245,14 +240,6 @@ declare function createPageContextPrerendering(urlOriginal: string, prerenderCon
         isClientSide: false;
         _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
         _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
-        isGlobalContext: true;
-        _virtualFileExports: unknown;
-        _pageFilesAll: PageFile[];
-        _pageConfigs: import("../../shared/page-configs/PageConfig.js").PageConfigRuntime[];
-        _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
-        _allPageIds: string[];
-        config: import("../../types/index.js").ConfigResolved;
-        pages: import("../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
     } | {
         _isPrerendering: true;
         viteConfig: ResolvedConfig;
@@ -275,14 +262,6 @@ declare function createPageContextPrerendering(urlOriginal: string, prerenderCon
         isClientSide: false;
         _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
         _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
-        isGlobalContext: true;
-        _virtualFileExports: unknown;
-        _pageFilesAll: PageFile[];
-        _pageConfigs: import("../../shared/page-configs/PageConfig.js").PageConfigRuntime[];
-        _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
-        _allPageIds: string[];
-        config: import("../../types/index.js").ConfigResolved;
-        pages: import("../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
     } | {
         _isPrerendering: false;
         viteConfig: null;
@@ -305,14 +284,6 @@ declare function createPageContextPrerendering(urlOriginal: string, prerenderCon
         isClientSide: false;
         _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
         _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
-        isGlobalContext: true;
-        _virtualFileExports: unknown;
-        _pageFilesAll: PageFile[];
-        _pageConfigs: import("../../shared/page-configs/PageConfig.js").PageConfigRuntime[];
-        _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
-        _allPageIds: string[];
-        config: import("../../types/index.js").ConfigResolved;
-        pages: import("../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
     });
     _baseServer: string;
     _baseAssets: string;
@@ -327,18 +298,12 @@ declare function createPageContextPrerendering(urlOriginal: string, prerenderCon
     _urlRewrite: null;
     _urlHandler: ((url: string) => string) | null;
     isClientSideNavigation: boolean;
-} & {
+} & import("../../shared/page-configs/getUserFriendlyConfigs.js").PageConfigUserFriendly & {
     urlParsed: import("../shared/utils.js").UrlPublic;
     urlPathname: string;
     url: string;
 } & {
     headers: Record<string, string> | null;
-} & {
-    config: import("../../types/index.js").ConfigResolved;
-    _source: import("../../shared/page-configs/getPageConfigUserFriendly.js").Source;
-    _sources: import("../../shared/page-configs/getPageConfigUserFriendly.js").Sources;
-    _from: import("../../shared/page-configs/getPageConfigUserFriendly.js").From;
-    isPageContext: true;
 } & {
     _urlHandler: null;
     _httpRequestId: null;
@@ -363,4 +328,3 @@ declare function createPageContextPrerendering(urlOriginal: string, prerenderCon
     _usesClientRouter: boolean;
 }>;
 declare function runPrerender_forceExit(): void;
-type PrerenderContextPublic = Pick<PrerenderContext, 'output' | 'pageContexts'>;

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

@@ -4,7 +4,7 @@ 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, onSetupPrerender, getPublicProxy, PROJECT_VERSION, preservePropertyGetters } from './utils.js';
+import { assert, assertUsage, assertWarning, hasProp, objectAssign, isObjectWithKeys, isCallable, isPropertyGetter, assertPosixPath, urlToFile, isPlainObject, pLimit, isArray, onSetupPrerender, PROJECT_VERSION, preservePropertyGetters, changeEnumerable } from './utils.js';
 import { prerenderPage } from '../runtime/renderPage/renderPageAlreadyRouted.js';
 import { createPageContextServerSide } from '../runtime/renderPage/createPageContextServerSide.js';
 import pc from '@brillout/picocolors';
@@ -18,12 +18,12 @@ import { getConfigValueRuntime } from '../../shared/page-configs/getConfigValueR
 import { loadConfigValues } from '../../shared/page-configs/loadConfigValues.js';
 import { getErrorPageId, isErrorPage } from '../../shared/error-page.js';
 import { isAbortError } from '../../shared/route/abort.js';
-import { loadUserFilesServerSide } from '../runtime/renderPage/loadUserFilesServerSide.js';
+import { loadPageConfigsLazyServerSide } from '../runtime/renderPage/loadPageConfigsLazyServerSide.js';
 import { getHookFromPageConfig, getHookFromPageConfigGlobal, getHookTimeoutDefault, getHook_setIsPrerenderering } from '../../shared/hooks/getHook.js';
 import { noRouteMatch } from '../../shared/route/noRouteMatch.js';
 import { getVikeConfig } from '../plugin/plugins/importUserCode/v1-design/getVikeConfig.js';
 import { logErrorHint } from '../runtime/renderPage/logErrorHint.js';
-import { executeHook, isUserHookError } from '../../shared/hooks/executeHook.js';
+import { execHookWithoutPageContext, isUserHookError } from '../../shared/hooks/execHook.js';
 import { prepareViteApiCall } from '../api/prepareViteApiCall.js';
 import { setContextIsPrerendering } from './context.js';
 import { resolvePrerenderConfigGlobal, resolvePrerenderConfigLocal } from './resolvePrerenderConfig.js';
@@ -32,6 +32,8 @@ import { isVikeCli } from '../cli/context.js';
 import { isViteCliCall } from '../plugin/shared/isViteCliCall.js';
 import { getVikeConfigInternal } from '../plugin/plugins/commonConfig.js';
 import fs from 'node:fs';
+import { getProxyForPublicUsage } from '../../shared/getProxyForPublicUsage.js';
+const docLink = 'https://vike.dev/i18n#pre-rendering';
 async function runPrerenderFromAPI(options = {}) {
     return await runPrerender(options, 'prerender()');
     // - We purposely propagate the error to the user land, so that the error interrupts the user land. It's also, I guess, a nice-to-have that the user has control over the error.
@@ -94,7 +96,7 @@ async function runPrerender(options = {}, standaloneTrigger) {
     }
     const concurrencyLimit = pLimit(parallel === false || parallel === 0 ? 1 : parallel === true || parallel === undefined ? cpus().length : parallel);
     await initGlobalContext_runPrerender();
-    const { globalContext, globalContext_public } = await getGlobalContextServerInternal();
+    const { globalContext } = await getGlobalContextServerInternal();
     globalContext._pageFilesAll.forEach(assertExportNames);
     const prerenderContext = {
         pageContexts: [],
@@ -107,13 +109,13 @@ async function runPrerender(options = {}, standaloneTrigger) {
     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, globalContext_public, concurrencyLimit, doNotPrerenderList);
+    await callOnBeforePrerenderStartHooks(prerenderContext, globalContext, concurrencyLimit, doNotPrerenderList);
     // Create `pageContext` for each page with a static route
     const urlList = getUrlListFromPagesWithStaticRoute(globalContext, doNotPrerenderList);
-    await createPageContexts(urlList, prerenderContext, globalContext, globalContext_public, concurrencyLimit, false);
+    await createPageContexts(urlList, prerenderContext, globalContext, concurrencyLimit, false);
     // Create `pageContext` for 404 page
     const urlList404 = getUrlList404(globalContext);
-    await createPageContexts(urlList404, prerenderContext, globalContext, globalContext_public, concurrencyLimit, true);
+    await createPageContexts(urlList404, prerenderContext, globalContext, concurrencyLimit, true);
     // Allow user to duplicate the list of `pageContext` for i18n
     // https://vike.dev/onPrerenderStart
     await callOnPrerenderStartHook(prerenderContext, globalContext, concurrencyLimit);
@@ -132,8 +134,8 @@ async function runPrerender(options = {}, standaloneTrigger) {
         console.log(`${pc.green(`✓`)} ${prerenderedCount} HTML documents pre-rendered.`);
     }
     await warnMissingPages(prerenderContext._prerenderedPageContexts, globalContext, doNotPrerenderList, partial);
-    const prerenderContextPublic = makePublic(prerenderContext);
-    objectAssign(vike.prerenderContext, prerenderContextPublic);
+    const prerenderContextPublic = preparePrerenderContextForPublicUsage(prerenderContext);
+    objectAssign(vike.prerenderContext, prerenderContextPublic, true);
     if (prerenderConfigGlobal.isPrerenderingEnabledForAllPages && !prerenderConfigGlobal.keepDistServer) {
         fs.rmSync(outDirServer, { recursive: true });
     }
@@ -195,7 +197,7 @@ function assertExportNames(pageFile) {
     const { exportNames, fileType } = pageFile;
     assert(exportNames || fileType === '.page.route' || fileType === '.css', pageFile.filePath);
 }
-async function callOnBeforePrerenderStartHooks(prerenderContext, globalContext, globalContext_public, concurrencyLimit, doNotPrerenderList) {
+async function callOnBeforePrerenderStartHooks(prerenderContext, globalContext, concurrencyLimit, doNotPrerenderList) {
     const onBeforePrerenderStartHooks = [];
     // V1 design
     await Promise.all(globalContext._pageConfigs.map((pageConfig) => concurrencyLimit(async () => {
@@ -238,10 +240,11 @@ async function callOnBeforePrerenderStartHooks(prerenderContext, globalContext,
             hookTimeout: getHookTimeoutDefault('onBeforePrerenderStart')
         });
     })));
-    await Promise.all(onBeforePrerenderStartHooks.map(({ hookFn, hookName, hookFilePath, pageId, hookTimeout }) => concurrencyLimit(async () => {
+    await Promise.all(onBeforePrerenderStartHooks.map(({ pageId, ...hook }) => concurrencyLimit(async () => {
         if (doNotPrerenderList.find((p) => p.pageId === pageId))
             return;
-        const prerenderResult = await executeHook(() => hookFn(), { hookName, hookFilePath, hookTimeout }, null);
+        const { hookName, hookFilePath } = hook;
+        const prerenderResult = await execHookWithoutPageContext(() => hook.hookFn(), hook);
         const result = normalizeOnPrerenderHookResult(prerenderResult, hookFilePath, hookName);
         // Handle result
         await Promise.all(result.map(async ({ url, pageContext }) => {
@@ -258,7 +261,7 @@ async function callOnBeforePrerenderStartHooks(prerenderContext, globalContext,
             }
             // Add result
             const providedByHook = { hookFilePath, hookName };
-            const pageContextNew = await createPageContextPrerendering(url, prerenderContext, globalContext, globalContext_public, false, undefined, providedByHook);
+            const pageContextNew = await createPageContextPrerendering(url, prerenderContext, globalContext, false, undefined, providedByHook);
             prerenderContext.pageContexts.push(pageContextNew);
             if (pageContext) {
                 objectAssign(pageContextNew, { _pageContextAlreadyProvidedByOnPrerenderHook: true });
@@ -304,22 +307,22 @@ function getUrlList404(globalContext) {
     }
     return urlList;
 }
-async function createPageContexts(urlList, prerenderContext, globalContext, globalContext_public, concurrencyLimit, is404) {
+async function createPageContexts(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 pageContext = await createPageContextPrerendering(urlOriginal, prerenderContext, globalContext, globalContext_public, is404, pageId, null);
+        const pageContext = await createPageContextPrerendering(urlOriginal, prerenderContext, globalContext, is404, pageId, null);
         prerenderContext.pageContexts.push(pageContext);
     })));
 }
-async function createPageContextPrerendering(urlOriginal, prerenderContext, globalContext, globalContext_public, is404, pageId, providedByHook) {
+async function createPageContextPrerendering(urlOriginal, prerenderContext, globalContext, is404, pageId, providedByHook) {
     const pageContextInit = {
         urlOriginal,
         ...prerenderContext._pageContextInit
     };
-    const pageContext = await createPageContextServerSide(pageContextInit, globalContext, globalContext_public, {
+    const pageContext = await createPageContextServerSide(pageContextInit, globalContext, {
         isPrerendering: true
     });
     assert(pageContext.isPrerendering === true);
@@ -348,7 +351,7 @@ async function createPageContextPrerendering(urlOriginal, prerenderContext, glob
             routeParams: {}
         });
     }
-    objectAssign(pageContext, await loadUserFilesServerSide(pageContext));
+    objectAssign(pageContext, await loadPageConfigsLazyServerSide(pageContext));
     let usesClientRouter;
     {
         const { pageId } = pageContext;
@@ -463,26 +466,13 @@ async function callOnPrerenderStartHook(prerenderContext, globalContext, concurr
         assert(pageContext.urlOriginal);
         pageContext._urlOriginalBeforeHook = pageContext.urlOriginal;
     });
-    const docLink = 'https://vike.dev/i18n#pre-rendering';
     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
-        Object.defineProperty(prerenderContextPublic, 'prerenderPageContexts', {
-            get() {
-                assertWarning(false, `prerenderPageContexts has been renamed pageContexts, see ${docLink}`, {
-                    showStackTrace: true,
-                    onlyOnce: true
-                });
-                return prerenderContext.pageContexts;
-            }
-        });
-        return hookFn(prerenderContextPublic);
-    }, onPrerenderStartHook, null);
+    const prerenderContextPublic = preparePrerenderContextForPublicUsage(prerenderContext);
+    let result = await execHookWithoutPageContext(() => hookFn(prerenderContextPublic), onPrerenderStartHook);
     // Before applying result
     prerenderContext.pageContexts.forEach((pageContext) => {
         ;
@@ -731,10 +721,24 @@ function assertIsNotAbort(err, urlOriginal) {
     assert(abortCall);
     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 = getPublicProxy(prerenderContext, 'prerenderContext', [
-        'output', // vite-plugin-vercel
-        'pageContexts' // https://vike.dev/i18n#pre-rendering
-    ]);
+function preparePrerenderContextForPublicUsage(prerenderContext) {
+    // TODO/v1-release: remove
+    if (!('prerenderPageContexts' in prerenderContext)) {
+        Object.defineProperty(prerenderContext, 'prerenderPageContexts', {
+            get() {
+                assertWarning(false, `prerenderPageContexts has been renamed pageContexts, see ${pc.underline(docLink)}`, {
+                    showStackTrace: true,
+                    onlyOnce: true
+                });
+                return prerenderContext.pageContexts;
+            }
+        });
+    }
+    // Required because of https://vike.dev/i18n#pre-rendering
+    // - Thus, we have to let users access the original pageContext object => we cannot use ES proxies and we cannot use preparePageContextForPublicUsage()
+    prerenderContext.pageContexts.forEach((pageContext) => {
+        changeEnumerable(pageContext, '_isOriginalObject', true);
+    });
+    const prerenderContextPublic = getProxyForPublicUsage(prerenderContext, 'prerenderContext');
     return prerenderContextPublic;
 }

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

@@ -13,6 +13,6 @@ export * from '../../utils/pLimit.js';
 export * from '../../utils/isFilePathAbsoluteFilesystem.js';
 export * from '../../utils/isArray.js';
 export * from '../../utils/isObject.js';
-export * from '../../utils/getPublicProxy.js';
 export * from '../../utils/isNullish.js';
 export * from '../../utils/preservePropertyGetters.js';
+export * from '../../utils/changeEnumerable.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/getPublicProxy.js';
 export * from '../../utils/isNullish.js';
 export * from '../../utils/preservePropertyGetters.js';
+export * from '../../utils/changeEnumerable.js';