vike 0.4.219 → 0.4.220-commit-a9f46b8

package/dist/cjs/node/api/build.js

@@ -1,72 +1,37 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.build = build;
 const prepareViteApiCall_js_1 = require("./prepareViteApiCall.js");
 const vite_1 = require("vite");
-const isPrerenderAutoRunEnabled_js_1 = require("../prerender/isPrerenderAutoRunEnabled.js");
+const assert_1 = __importDefault(require("assert"));
+const context_js_1 = require("../cli/context.js");
+const context_js_2 = require("../prerender/context.js");
 /**
  * Programmatically trigger `$ vike build`
  *
  * https://vike.dev/api#build
  */
 async function build(options = {}) {
-    const { viteConfigEnhanced, vikeConfigGlobal } = await (0, prepareViteApiCall_js_1.prepareViteApiCall)(options.viteConfig, 'build');
-    // Build client-side
-    const outputClient = await (0, vite_1.build)(viteConfigEnhanced);
-    // Build server-side
-    const outputServer = await (0, vite_1.build)(setSSR(viteConfigEnhanced));
-    // Pre-render
-    if ((0, isPrerenderAutoRunEnabled_js_1.isPrerenderAutoRunEnabled)(vikeConfigGlobal)) {
-        const { runPrerenderFromAutoRun } = await Promise.resolve().then(() => __importStar(require('../prerender/runPrerender.js')));
-        await runPrerenderFromAutoRun(viteConfigEnhanced);
-    }
-    return {
-        /* We don't return `viteConfig` because `viteConfigEnhanced` is `InlineConfig` not `ResolvedConfig`
-        viteConfig: viteConfigEnhanced,
-        */
-        rollupOutputClient: outputClient,
-        rollupOutputServer: outputServer
-    };
-}
-function setSSR(viteConfig) {
+    const { viteConfigEnhanced } = await (0, prepareViteApiCall_js_1.prepareViteApiCall)(options.viteConfig, 'build');
+    // Pass it to autoFullBuild()
+    if (viteConfigEnhanced)
+        viteConfigEnhanced._viteConfigEnhanced = viteConfigEnhanced;
+    // 1. Build client-side
+    // 2. Build server-side
+    //    > See: https://github.com/vikejs/vike/blob/c6c7533a56b3a16fc43ed644fc5c10c02d0ff375/vike/node/plugin/plugins/autoFullBuild.ts#L90
+    // 3. Pre-render (if enabled)
+    //    > See: https://github.com/vikejs/vike/blob/c6c7533a56b3a16fc43ed644fc5c10c02d0ff375/vike/node/plugin/plugins/autoFullBuild.ts#L98
+    //    > We purposely don't start the pre-rendering in this `build()` function but in a Rollup hook instead.
+    //    > Rationale: https://github.com/vikejs/vike/issues/2123
+    await (0, vite_1.build)(viteConfigEnhanced);
+    // When using the Vike CLI with pre-rendering the process is forcefully exited at the end of the buildVite() call above
+    (0, assert_1.default)(!((0, context_js_1.isVikeCli)() && (0, context_js_2.isPrerendering)()));
     return {
-        ...viteConfig,
-        build: {
-            ...viteConfig?.build,
-            ssr: true
-        }
+    /* We don't return `viteConfig` because `viteConfigEnhanced` is `InlineConfig` not `ResolvedConfig`
+    viteConfig: viteConfigEnhanced,
+    */
     };
 }

package/dist/cjs/node/api/context.js

@@ -1,13 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.setOperation = setOperation;
-exports.clearOperation = clearOperation;
 exports.isVikeCliOrApi = isVikeCliOrApi;
+exports.setContextApiOperation = setContextApiOperation;
+exports.clearContextApiOperation = clearContextApiOperation;
 const utils_js_1 = require("./utils.js");
-const globalObject = (0, utils_js_1.getGlobalObject)('context.ts', {
-    apiOperation: undefined
-});
-function getOperation() {
+const globalObject = (0, utils_js_1.getGlobalObject)('api/context.ts', {});
+function getApiOperation() {
     (0, utils_js_1.assert)(globalObject.apiOperation);
     return globalObject.apiOperation;
 }
@@ -15,10 +13,10 @@ function isVikeCliOrApi() {
     // The CLI uses the API
     return !!globalObject.apiOperation;
 }
-function setOperation(operation) {
+function setContextApiOperation(operation) {
     (0, utils_js_1.assert)(!globalObject.apiOperation);
     globalObject.apiOperation = operation;
 }
-function clearOperation() {
+function clearContextApiOperation() {
     globalObject.apiOperation = undefined;
 }

package/dist/cjs/node/api/prepareViteApiCall.js

@@ -51,31 +51,30 @@ const globalContext_js_1 = require("../runtime/globalContext.js");
 const globalObject = (0, utils_js_1.getGlobalObject)('prepareViteApiCall.ts', {});
 async function prepareViteApiCall(viteConfig, operation) {
     clear();
-    (0, context_js_1.setOperation)(operation);
+    (0, context_js_1.setContextApiOperation)(operation);
     return enhanceViteConfig(viteConfig, operation);
 }
 // For subsequent API calls, e.g. calling prerender() after build()
 function clear() {
-    (0, context_js_1.clearOperation)();
+    (0, context_js_1.clearContextApiOperation)();
     (0, globalContext_js_1.clearGlobalContext)();
 }
 async function enhanceViteConfig(viteConfig, operation) {
     const viteInfo = await getInfoFromVite(viteConfig, operation);
     await assertViteRoot2(viteInfo.root, viteInfo.viteConfigEnhanced, operation);
     const vikeConfig = await (0, getVikeConfig_js_1.getVikeConfig2)(viteInfo.root, operation === 'dev', viteInfo.vikeVitePluginOptions);
-    const viteConfigEnhanced = addViteSettingsSetByUser(viteInfo.viteConfigEnhanced, vikeConfig);
+    const viteConfigEnhanced = addViteSettingsSetByVikeConfig(viteInfo.viteConfigEnhanced, vikeConfig);
     return {
-        viteConfigEnhanced,
-        vikeConfigGlobal: vikeConfig.vikeConfigGlobal
+        viteConfigEnhanced
     };
 }
-function addViteSettingsSetByUser(viteConfigEnhanced, vikeConfig) {
+function addViteSettingsSetByVikeConfig(viteConfigEnhanced, vikeConfig) {
     const viteConfigs = vikeConfig.global.from.configsCumulative.vite;
     if (!viteConfigs)
         return viteConfigEnhanced;
     viteConfigs.values.forEach((v) => {
         (0, utils_js_1.assertUsage)((0, utils_js_1.isObject)(v.value), `${v.definedAt} should be an object`);
-        viteConfigEnhanced = (0, vite_1.mergeConfig)(v.value, viteConfigEnhanced ?? {});
+        viteConfigEnhanced = (0, vite_1.mergeConfig)(viteConfigEnhanced ?? {}, v.value);
     });
     return viteConfigEnhanced;
 }

package/dist/cjs/node/cli/context.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isVikeCli = isVikeCli;
+exports.setContextCliCommand = setContextCliCommand;
+const utils_js_1 = require("./utils.js");
+const globalObject = (0, utils_js_1.getGlobalObject)('cli/context.ts', {});
+function getCliCommand() {
+    return globalObject.cliCommand;
+}
+function isVikeCli() {
+    return !!globalObject.cliCommand;
+}
+function setContextCliCommand(command) {
+    (0, utils_js_1.assert)(!globalObject.cliCommand);
+    globalObject.cliCommand = command;
+}

package/dist/cjs/node/cli/entry.js

@@ -40,9 +40,11 @@ const utils_js_1 = require("./utils.js");
 const index_js_1 = require("../api/index.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const parseCli_js_1 = require("./parseCli.js");
+const context_js_1 = require("./context.js");
 cli();
 async function cli() {
     const { command } = (0, parseCli_js_1.parseCli)();
+    (0, context_js_1.setContextCliCommand)(command);
     if (command === 'dev') {
         await cmdDev();
     }

package/dist/cjs/node/cli/utils.js

@@ -21,3 +21,4 @@ const onLoad_js_1 = require("./onLoad.js");
 __exportStar(require("../../utils/assert.js"), exports);
 __exportStar(require("../../utils/projectInfo.js"), exports);
 __exportStar(require("../../utils/includes.js"), exports);
+__exportStar(require("../../utils/getGlobalObject.js"), exports);

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

@@ -8,12 +8,14 @@ exports.autoFullBuild = autoFullBuild;
 const vite_1 = require("vite");
 const utils_js_1 = require("../utils.js");
 const runPrerender_js_1 = require("../../prerender/runPrerender.js");
-const isPrerenderAutoRunEnabled_js_1 = require("../../prerender/isPrerenderAutoRunEnabled.js");
+const context_js_1 = require("../../prerender/context.js");
 const isViteCliCall_js_1 = require("../shared/isViteCliCall.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const logErrorHint_js_1 = require("../../runtime/renderPage/logErrorHint.js");
 const buildConfig_js_1 = require("./buildConfig.js");
 const getVikeConfig_js_1 = require("./importUserCode/v1-design/getVikeConfig.js");
+const context_js_2 = require("../../api/context.js");
+const context_js_3 = require("../../cli/context.js");
 let forceExit = false;
 function autoFullBuild() {
     let config;
@@ -74,33 +76,43 @@ async function triggerFullBuild(config, vikeConfigGlobal, bundle) {
     if (!bundle[buildConfig_js_1.manifestTempFile])
         return;
     const configFromCli = !(0, isViteCliCall_js_1.isViteCliCall)() ? null : (0, isViteCliCall_js_1.getViteConfigFromCli)();
-    const configInline = {
-        ...configFromCli,
-        configFile: configFromCli?.configFile || config.configFile,
-        root: config.root,
-        build: {
-            ...configFromCli?.build
-        }
-    };
-    try {
-        await (0, vite_1.build)({
-            ...configInline,
+    let configInline;
+    if (config._viteConfigEnhanced) {
+        configInline = config._viteConfigEnhanced;
+    }
+    else {
+        configInline = {
+            ...configFromCli,
+            configFile: configFromCli?.configFile || config.configFile,
+            root: config.root,
             build: {
-                ...configInline.build,
-                ssr: true
+                ...configFromCli?.build
             }
-        });
+        };
+    }
+    try {
+        await (0, vite_1.build)(setSSR(configInline));
     }
     catch (err) {
         console.error(err);
         (0, logErrorHint_js_1.logErrorHint)(err);
         process.exit(1);
     }
-    if ((0, isPrerenderAutoRunEnabled_js_1.isPrerenderAutoRunEnabled)(vikeConfigGlobal)) {
-        await (0, runPrerender_js_1.runPrerenderFromAutoRun)(configInline);
-        forceExit = true;
+    if ((0, context_js_1.isPrerenderAutoRunEnabled)(vikeConfigGlobal)) {
+        const { prerenderContextPublic } = await (0, runPrerender_js_1.runPrerenderFromAutoRun)(configInline);
+        config.vike.prerenderContext = prerenderContextPublic;
+        forceExit = (0, context_js_3.isVikeCli)() || (0, isViteCliCall_js_1.isViteCliCall)();
     }
 }
+function setSSR(configInline) {
+    return {
+        ...configInline,
+        build: {
+            ...configInline.build,
+            ssr: true
+        }
+    };
+}
 function abortViteBuildSsr(vikeConfigGlobal) {
     if (vikeConfigGlobal.disableAutoFullBuild !== true && (0, isViteCliCall_js_1.isViteCliCall)() && (0, isViteCliCall_js_1.getViteConfigFromCli)()?.build.ssr) {
         (0, utils_js_1.assertWarning)(false, `The CLI call ${picocolors_1.default.cyan('$ vite build --ssr')} is superfluous since ${picocolors_1.default.cyan('$ vite build')} also builds the server-side. If you want two separate build steps then use https://vike.dev/disableAutoFullBuild or use Vite's ${picocolors_1.default.cyan('build()')} API.`, { onlyOnce: true });
@@ -110,7 +122,8 @@ function abortViteBuildSsr(vikeConfigGlobal) {
 function isDisabled(vikeConfigGlobal) {
     const { disableAutoFullBuild } = vikeConfigGlobal;
     if (disableAutoFullBuild === null || disableAutoFullBuild === 'prerender') {
-        return !(0, isViteCliCall_js_1.isViteCliCall)();
+        const isViteApi = !(0, isViteCliCall_js_1.isViteCliCall)() && !(0, context_js_2.isVikeCliOrApi)();
+        return isViteApi;
     }
     else {
         return disableAutoFullBuild;

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

@@ -13,7 +13,7 @@ function baseUrls() {
             const isDev = config._isDev;
             (0, utils_js_1.assert)(typeof isDev === 'boolean');
             const baseViteOriginal = config.base ?? '/__UNSET__'; // '/__UNSET__' because Vite resolves `_baseViteOriginal: null` to `undefined`
-            basesResolved = (0, resolveBase_js_1.resolveBase)(baseViteOriginal, config.vike.vikeConfigGlobal.baseServer, config.vike.vikeConfigGlobal.baseAssets);
+            basesResolved = (0, resolveBase_js_1.resolveBase)(baseViteOriginal, config._vikeConfigGlobal.baseServer, config._vikeConfigGlobal.baseAssets);
             // We cannot define these in configResolved() because Vite picks up the env variables before any configResolved() hook is called
             process.env.BASE_SERVER = basesResolved.baseServer;
             process.env.BASE_ASSETS = basesResolved.baseAssets;

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

@@ -16,7 +16,7 @@ const isViteCliCall_js_1 = require("../shared/isViteCliCall.js");
 const context_js_1 = require("../../api/context.js");
 const getVikeConfig_js_1 = require("./importUserCode/v1-design/getVikeConfig.js");
 const prepareViteApiCall_js_1 = require("../../api/prepareViteApiCall.js");
-const isPrerenderAutoRunEnabled_js_1 = require("../../prerender/isPrerenderAutoRunEnabled.js");
+const context_js_2 = require("../../prerender/context.js");
 const pluginName = 'vike:commonConfig';
 function commonConfig(vikeVitePluginOptions) {
     return [
@@ -35,9 +35,11 @@ function commonConfig(vikeVitePluginOptions) {
                         _isDev: isDev,
                         _root: root,
                         _vikeVitePluginOptions: vikeVitePluginOptions,
-                        vike: vikeConfig,
-                        // TODO/v1-release: remove
-                        configVikePromise: Promise.resolve(vikeConfig.vikeConfigGlobal)
+                        vike: { global: vikeConfig.global },
+                        // TODO/now: remove
+                        _vikeConfigGlobal: vikeConfig.vikeConfigGlobal,
+                        // TODO/v1-release: remove https://github.com/vikejs/vike/issues/2122
+                        configVikePromise: Promise.resolve({ prerender: !!vikeConfig.vikeConfigGlobal.prerender })
                     };
                 }
             }
@@ -80,7 +82,7 @@ function commonConfig(vikeVitePluginOptions) {
                     // VITE_CONFIG
                     const configFromEnvVar = (0, getEnvVarObject_js_1.getEnvVarObject)('VITE_CONFIG');
                     if (configFromEnvVar)
-                        configFromVike = (0, vite_1.mergeConfig)(configFromEnvVar, configFromVike);
+                        configFromVike = (0, vite_1.mergeConfig)(configFromVike, configFromEnvVar);
                     return configFromVike;
                 }
             }
@@ -147,7 +149,7 @@ function assertVikeCliOrApi(config) {
         onlyOnce: true
     });
 }
-// TODO/v1-release: remove
+// TODO/v1-release: remove https://github.com/vikejs/vike/issues/2122
 function temp_supportOldInterface(config) {
     if (!('vitePluginSsr' in config))
         return;
@@ -155,14 +157,14 @@ function temp_supportOldInterface(config) {
     if ((0, utils_js_1.hasProp)(config.vitePluginSsr, 'prerender', 'object')) {
         (0, utils_js_1.assert)((0, utils_js_1.hasProp)(config.vitePluginSsr.prerender, 'disableAutoRun', 'boolean'));
         if (config.vitePluginSsr.prerender.disableAutoRun) {
-            (0, isPrerenderAutoRunEnabled_js_1.temp_disablePrerenderAutoRun)();
+            (0, context_js_2.temp_disablePrerenderAutoRun)();
         }
         return;
     }
     if ((0, utils_js_1.hasProp)(config.vitePluginSsr, 'disableAutoFullBuild')) {
         if (config.vitePluginSsr.disableAutoFullBuild) {
             (0, utils_js_1.assert)(config.vitePluginSsr.disableAutoFullBuild === 'prerender');
-            (0, isPrerenderAutoRunEnabled_js_1.temp_disablePrerenderAutoRun)();
+            (0, context_js_2.temp_disablePrerenderAutoRun)();
         }
         return;
     }

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

@@ -28,12 +28,13 @@ function getCodePageConfigsSerialized(pageConfigs, isForClientSide, isClientRout
     const lines = [];
     pageConfigs.forEach((pageConfig) => {
         const { pageId, routeFilesystem, isErrorPage } = pageConfig;
-        const virtualFileIdPageConfigValuesAll = (0, virtualFilePageConfigValuesAll_js_1.getVirtualFileIdPageConfigValuesAll)(pageId, isForClientSide);
         lines.push(`  {`);
         lines.push(`    pageId: ${JSON.stringify(pageId)},`);
         lines.push(`    isErrorPage: ${JSON.stringify(isErrorPage)},`);
         lines.push(`    routeFilesystem: ${JSON.stringify(routeFilesystem)},`);
-        lines.push(`    loadConfigValuesAll: () => import(${JSON.stringify(virtualFileIdPageConfigValuesAll)}),`);
+        const virtualFileId = JSON.stringify((0, virtualFilePageConfigValuesAll_js_1.getVirtualFileIdPageConfigValuesAll)(pageId, isForClientSide));
+        const load = `() => ({ moduleId: ${virtualFileId}, moduleExports: import(${virtualFileId}) })`;
+        lines.push(`    loadConfigValuesAll: ${load},`);
         lines.push(`    configValuesSerialized: {`);
         lines.push(...(0, serializeConfigValues_js_1.serializeConfigValues)(pageConfig, importStatements, (configEnv) => (0, isRuntimeEnvMatch_js_1.isRuntimeEnvMatch)(configEnv, { isForClientSide, isClientRouting, isDev }), '    ', true));
         lines.push(`    },`);

package/dist/cjs/node/prerender/{isPrerenderAutoRunEnabled.js → context.js}

@@ -2,8 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isPrerenderAutoRunEnabled = isPrerenderAutoRunEnabled;
 exports.temp_disablePrerenderAutoRun = temp_disablePrerenderAutoRun;
+exports.isPrerendering = isPrerendering;
+exports.setContextIsPrerendering = setContextIsPrerendering;
 const getGlobalObject_js_1 = require("../../utils/getGlobalObject.js");
-const globalObject = (0, getGlobalObject_js_1.getGlobalObject)('isPrerenderAutoRunEnabled.ts', {});
+const globalObject = (0, getGlobalObject_js_1.getGlobalObject)('prerender/context.ts', {});
 function isPrerenderAutoRunEnabled(vikeConfigGlobal) {
     return (vikeConfigGlobal.prerender &&
         !vikeConfigGlobal.prerender.disableAutoRun &&
@@ -14,3 +16,9 @@ function isPrerenderAutoRunEnabled(vikeConfigGlobal) {
 function temp_disablePrerenderAutoRun() {
     globalObject.isDisabled = true;
 }
+function isPrerendering() {
+    return !!globalObject.isPrerendering;
+}
+function setContextIsPrerendering() {
+    globalObject.isPrerendering = true;
+}

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

@@ -65,6 +65,7 @@ const logErrorHint_js_1 = require("../runtime/renderPage/logErrorHint.js");
 const executeHook_js_1 = require("../../shared/hooks/executeHook.js");
 const getConfigValueBuildTime_js_1 = require("../../shared/page-configs/getConfigValueBuildTime.js");
 const prepareViteApiCall_js_1 = require("../api/prepareViteApiCall.js");
+const context_js_1 = require("./context.js");
 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.
@@ -84,16 +85,20 @@ async function runPrerenderFromCLIPrerenderCommand() {
     runPrerender_forceExit();
 }
 async function runPrerenderFromAutoRun(viteConfig) {
+    let prerenderContextPublic;
     try {
-        await runPrerender({ viteConfig });
+        const ret = await runPrerender({ viteConfig });
+        prerenderContextPublic = ret.prerenderContextPublic;
     }
     catch (err) {
         console.error(err);
         (0, logErrorHint_js_1.logErrorHint)(err);
         process.exit(1);
     }
+    return { prerenderContextPublic };
 }
 async function runPrerender(options = {}, standaloneTrigger) {
+    (0, context_js_1.setContextIsPrerendering)();
     checkOutdatedOptions(options);
     (0, utils_js_1.onSetupPrerender)();
     (0, globalContext_js_1.setGlobalContext_isPrerendering)();
@@ -120,35 +125,36 @@ async function runPrerender(options = {}, standaloneTrigger) {
     await (0, globalContext_js_1.initGlobalContext_runPrerender)();
     const globalContext = (0, globalContext_js_1.getGlobalContext)();
     globalContext.pageFilesAll.forEach(assertExportNames);
-    const prerenderContext = {};
-    (0, utils_js_1.objectAssign)(prerenderContext, {
-        _urlHandler: null,
-        _noExtraDir: noExtraDir ?? false,
+    const prerenderContext = {
+        noExtraDir: noExtraDir ?? false,
         pageContexts: [],
-        pageContextInit: options.pageContextInit ?? null
-    });
+        pageContextInit: options.pageContextInit ?? null,
+        prerenderedPageContexts: {},
+        output: []
+    };
     const doNotPrerenderList = [];
     await collectDoNoPrerenderList(vikeConfig.pageConfigs, doNotPrerenderList, concurrencyLimit);
     await callOnBeforePrerenderStartHooks(prerenderContext, concurrencyLimit, doNotPrerenderList);
     await handlePagesWithStaticRoutes(prerenderContext, doNotPrerenderList, concurrencyLimit);
     await callOnPrerenderStartHook(prerenderContext);
-    const prerenderedPageContexts = {};
     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) {
-            prerenderedPageContexts[htmlFile.pageId] = htmlFile.pageContext;
+            prerenderContext.prerenderedPageContexts[htmlFile.pageId] = htmlFile.pageContext;
         }
-        await writeFiles(htmlFile, root, outDirClient, options.onPagePrerender, logLevel);
+        await writeFiles(htmlFile, root, outDirClient, options.onPagePrerender, prerenderContext.output, logLevel);
     };
     await routeAndPrerender(prerenderContext, concurrencyLimit, onComplete);
-    warnContradictoryNoPrerenderList(prerenderedPageContexts, doNotPrerenderList);
-    await prerender404(prerenderedPageContexts, prerenderContext, onComplete);
+    warnContradictoryNoPrerenderList(prerenderContext.prerenderedPageContexts, doNotPrerenderList);
+    await prerender404(prerenderContext, onComplete);
     if (logLevel === 'info') {
         console.log(`${picocolors_1.default.green(`✓`)} ${prerenderedCount} HTML documents pre-rendered.`);
     }
-    warnMissingPages(prerenderedPageContexts, doNotPrerenderList, partial);
-    return { viteConfig };
+    warnMissingPages(prerenderContext.prerenderedPageContexts, doNotPrerenderList, partial);
+    const prerenderContextPublic = makePublic(prerenderContext);
+    return { viteConfig, prerenderContextPublic };
 }
 async function collectDoNoPrerenderList(pageConfigs, doNotPrerenderList, concurrencyLimit) {
     // V1 design
@@ -339,7 +345,7 @@ function createPageContext(urlOriginal, prerenderContext) {
     const pageContext = {
         _urlHandler: null,
         _urlRewrite: null,
-        _noExtraDir: prerenderContext._noExtraDir,
+        _noExtraDir: prerenderContext.noExtraDir,
         _prerenderContext: prerenderContext
     };
     const pageContextInit = {
@@ -425,17 +431,20 @@ async function callOnPrerenderStartHook(prerenderContext) {
     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);
-    let result = await (0, executeHook_js_1.executeHook)(() => hookFn({
-        pageContexts: prerenderContext.pageContexts,
+    let result = await (0, executeHook_js_1.executeHook)(() => {
+        const prerenderContextPublic = makePublic(prerenderContext);
         // TODO/v1-release: remove warning
-        get prerenderPageContexts() {
-            (0, utils_js_1.assertWarning)(false, `prerenderPageContexts has been renamed pageContexts, see ${docLink}`, {
-                showStackTrace: true,
-                onlyOnce: true
-            });
-            return prerenderContext.pageContexts;
-        }
-    }), onPrerenderStartHook, null);
+        Object.defineProperty(prerenderContextPublic, 'prerenderPageContexts', {
+            get() {
+                (0, utils_js_1.assertWarning)(false, `prerenderPageContexts has been renamed pageContexts, see ${docLink}`, {
+                    showStackTrace: true,
+                    onlyOnce: true
+                });
+                return prerenderContext.pageContexts;
+            }
+        });
+        return hookFn(prerenderContextPublic);
+    }, onPrerenderStartHook, null);
     restoreEnumerable();
     if (result === null || result === undefined) {
         return;
@@ -542,7 +551,7 @@ async function routeAndPrerender(prerenderContext, concurrencyLimit, onComplete)
             pageContext,
             htmlString: documentHtml,
             pageContextSerialized,
-            doNotCreateExtraDirectory: prerenderContext._noExtraDir,
+            doNotCreateExtraDirectory: prerenderContext.noExtraDir,
             pageId
         });
     })));
@@ -577,8 +586,8 @@ function warnMissingPages(prerenderedPageContexts, doNotPrerenderList, partial)
         (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(prerenderedPageContexts, prerenderContext, onComplete) {
-    if (!Object.values(prerenderedPageContexts).find(({ urlOriginal }) => urlOriginal === '/404')) {
+async function prerender404(prerenderContext, onComplete) {
+    if (!Object.values(prerenderContext.prerenderedPageContexts).find(({ urlOriginal }) => urlOriginal === '/404')) {
         let result;
         try {
             result = await (0, renderPageAlreadyRouted_js_1.prerender404Page)(prerenderContext.pageContextInit);
@@ -601,22 +610,23 @@ async function prerender404(prerenderedPageContexts, prerenderContext, onComplet
         }
     }
 }
-async function writeFiles({ urlOriginal, pageContext, htmlString, pageContextSerialized, doNotCreateExtraDirectory }, root, outDirClient, onPagePrerender, logLevel) {
+async function writeFiles({ urlOriginal, pageContext, htmlString, pageContextSerialized, doNotCreateExtraDirectory }, root, outDirClient, onPagePrerender, output, logLevel) {
     (0, utils_js_1.assert)(urlOriginal.startsWith('/'));
     const writeJobs = [
-        write(urlOriginal, pageContext, '.html', htmlString, root, outDirClient, doNotCreateExtraDirectory, onPagePrerender, logLevel)
+        write(urlOriginal, pageContext, 'HTML', htmlString, root, outDirClient, doNotCreateExtraDirectory, onPagePrerender, output, logLevel)
     ];
     if (pageContextSerialized !== null) {
-        writeJobs.push(write(urlOriginal, pageContext, '.pageContext.json', pageContextSerialized, root, outDirClient, doNotCreateExtraDirectory, onPagePrerender, logLevel));
+        writeJobs.push(write(urlOriginal, pageContext, 'JSON', pageContextSerialized, root, outDirClient, doNotCreateExtraDirectory, onPagePrerender, output, logLevel));
     }
     await Promise.all(writeJobs);
 }
-async function write(urlOriginal, pageContext, fileExtension, fileContent, root, outDirClient, doNotCreateExtraDirectory, onPagePrerender, logLevel) {
+async function write(urlOriginal, pageContext, fileType, fileContent, root, outDirClient, doNotCreateExtraDirectory, onPagePrerender, output, logLevel) {
     let fileUrl;
-    if (fileExtension === '.html') {
+    if (fileType === 'HTML') {
         fileUrl = (0, utils_js_1.urlToFile)(urlOriginal, '.html', doNotCreateExtraDirectory);
     }
     else {
+        (0, utils_js_1.assert)(fileType === 'JSON');
         fileUrl = (0, getPageContextRequestUrl_js_1.getPageContextRequestUrl)(urlOriginal);
     }
     (0, utils_js_1.assertPosixPath)(fileUrl);
@@ -628,6 +638,12 @@ async function write(urlOriginal, pageContext, fileExtension, fileContent, root,
     (0, utils_js_1.assertPosixPath)(outDirClient);
     (0, utils_js_1.assertPosixPath)(filePathRelative);
     const filePath = path_1.default.posix.join(outDirClient, filePathRelative);
+    output.push({
+        filePath,
+        fileType,
+        fileContent,
+        pageContext
+    });
     if (onPagePrerender) {
         const prerenderPageContext = {};
         (0, utils_js_1.objectAssign)(prerenderPageContext, pageContext);
@@ -796,3 +812,9 @@ prerenderConfig) {
         (0, utils_js_1.assertUsage)(false, `Setting ${picocolors_1.default.cyan(`prerender.${prop}`)} ${errMsg}`);
     }
 }
+function makePublic(prerenderContext) {
+    const prerenderContextPublic = (0, utils_js_1.makePublicCopy)(prerenderContext, 'prerenderContext', [
+        'pageContexts'
+    ]);
+    return prerenderContextPublic;
+}

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

@@ -33,3 +33,4 @@ __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);

package/dist/cjs/node/runtime/globalContext.js

@@ -53,28 +53,8 @@ async function getGlobalContextAsync(isProduction) {
     return makePublic(globalContext);
 }
 function makePublic(globalContext) {
-    const globalContextPublic = {
-        // TODO/now: add viteConfig and vikeConfig
-        assetsManifest: globalContext.assetsManifest
-    };
-    // Add internals (and prepended _ prefix to their keys)
-    {
-        const publicKeys = Object.keys(globalContextPublic);
-        (0, utils_js_1.objectKeys)(globalContext)
-            .filter((key) => !publicKeys.includes(key))
-            .forEach((key) => {
-            const keyPublic = `_${key}`;
-            Object.defineProperty(globalContextPublic, keyPublic, {
-                enumerable: true,
-                get() {
-                    (0, utils_js_1.assertWarning)(false, `Using internal globalContext.${keyPublic} which is discouraged: it may break in any minor version update. Instead, reach out on GitHub and elaborate your use case.`, {
-                        onlyOnce: true
-                    });
-                    return globalContext[key];
-                }
-            });
-        });
-    }
+    // TODO/now: add viteConfig and vikeConfig
+    const globalContextPublic = (0, utils_js_1.makePublicCopy)(globalContext, 'globalContext', ['assetsManifest']);
     return globalContextPublic;
 }
 function setGlobalContext_viteDevServer(viteDevServer) {

package/dist/cjs/node/runtime/page-files/setup.js

@@ -1,3 +1,3 @@
 "use strict";
-// TODO/v1-release: remove
+// TODO/v1-release: remove https://github.com/vikejs/vike/issues/2122
 // This doesn't do anything anymore. (It's kept to avoid introducing a breaking change.)

package/dist/cjs/node/runtime/utils.js

@@ -76,3 +76,4 @@ __exportStar(require("../../utils/isVikeReactApp.js"), exports);
 __exportStar(require("../../utils/getPropAccessNotation.js"), exports);
 __exportStar(require("../../utils/PROJECT_VERSION.js"), exports);
 __exportStar(require("../../utils/genPromise.js"), exports);
+__exportStar(require("../../utils/makePublicCopy.js"), exports);