vike 0.4.218 → 0.4.220-commit-a9f46b8

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

@@ -15,13 +15,23 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+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 };
 };
@@ -30,7 +40,6 @@ exports.runPrerenderFromAPI = runPrerenderFromAPI;
 exports.runPrerenderFromCLIPrerenderCommand = runPrerenderFromCLIPrerenderCommand;
 exports.runPrerenderFromAutoRun = runPrerenderFromAutoRun;
 exports.runPrerender_forceExit = runPrerender_forceExit;
-require("../runtime/page-files/setup.js");
 const path_1 = __importDefault(require("path"));
 const index_js_1 = require("../../shared/route/index.js");
 const utils_js_1 = require("./utils.js");
@@ -43,7 +52,7 @@ const getPageFiles_js_1 = require("../../shared/getPageFiles.js");
 const getPageContextRequestUrl_js_1 = require("../../shared/getPageContextRequestUrl.js");
 const resolveRouteString_js_1 = require("../../shared/route/resolveRouteString.js");
 const helpers_js_1 = require("../../shared/page-configs/helpers.js");
-const getConfigValue_js_1 = require("../../shared/page-configs/getConfigValue.js");
+const getConfigValueRuntime_js_1 = require("../../shared/page-configs/getConfigValueRuntime.js");
 const loadConfigValues_js_1 = require("../../shared/page-configs/loadConfigValues.js");
 const error_page_js_1 = require("../../shared/error-page.js");
 const getPageContextUrlComputed_js_1 = require("../../shared/getPageContextUrlComputed.js");
@@ -56,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.
@@ -74,19 +84,21 @@ async function runPrerenderFromCLIPrerenderCommand() {
     }
     runPrerender_forceExit();
 }
-async function runPrerenderFromAutoRun(viteConfig, 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);
     }
-    if (forceExit)
-        runPrerender_forceExit();
+    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)();
@@ -97,11 +109,11 @@ async function runPrerender(options = {}, standaloneTrigger) {
     }
     await disableReactStreaming();
     const viteConfig = await (0, vite_1.resolveConfig)(options.viteConfig || {}, 'build', 'production');
-    assertLoadedConfig(viteConfig, options);
     const vikeConfig = await (0, getVikeConfig_js_1.getVikeConfig)(viteConfig);
     const { outDirClient } = (0, utils_js_1.getOutDirs)(viteConfig);
     const { root } = viteConfig;
     const prerenderConfig = vikeConfig.vikeConfigGlobal.prerender;
+    validatePrerenderConfig(prerenderConfig);
     if (!prerenderConfig) {
         (0, utils_js_1.assert)(standaloneTrigger);
         (0, utils_js_1.assertWarning)(prerenderConfig, `You're executing ${picocolors_1.default.cyan(standaloneTrigger)} but the config ${picocolors_1.default.cyan('prerender')} isn't set to true`, {
@@ -111,39 +123,40 @@ async function runPrerender(options = {}, standaloneTrigger) {
     const { partial = false, noExtraDir = false, parallel = true } = prerenderConfig || {};
     const concurrencyLimit = (0, utils_js_1.pLimit)(parallel === false || parallel === 0 ? 1 : parallel === true || parallel === undefined ? (0, os_1.cpus)().length : parallel);
     await (0, globalContext_js_1.initGlobalContext_runPrerender)();
-    const renderContext = await (0, renderPageAlreadyRouted_js_1.getRenderContext)();
-    renderContext.pageFilesAll.forEach(assertExportNames);
-    const prerenderContext = {};
-    (0, utils_js_1.objectAssign)(prerenderContext, {
-        _urlHandler: null,
-        _noExtraDir: noExtraDir ?? false,
+    const globalContext = (0, globalContext_js_1.getGlobalContext)();
+    globalContext.pageFilesAll.forEach(assertExportNames);
+    const prerenderContext = {
+        noExtraDir: noExtraDir ?? false,
         pageContexts: [],
-        pageContextInit: options.pageContextInit ?? null
-    });
+        pageContextInit: options.pageContextInit ?? null,
+        prerenderedPageContexts: {},
+        output: []
+    };
     const doNotPrerenderList = [];
-    await collectDoNoPrerenderList(renderContext, vikeConfig.pageConfigs, doNotPrerenderList, concurrencyLimit);
-    await callOnBeforePrerenderStartHooks(prerenderContext, renderContext, concurrencyLimit, doNotPrerenderList);
-    await handlePagesWithStaticRoutes(prerenderContext, renderContext, doNotPrerenderList, concurrencyLimit);
-    await callOnPrerenderStartHook(prerenderContext, renderContext);
-    const prerenderedPageContexts = {};
+    await collectDoNoPrerenderList(vikeConfig.pageConfigs, doNotPrerenderList, concurrencyLimit);
+    await callOnBeforePrerenderStartHooks(prerenderContext, concurrencyLimit, doNotPrerenderList);
+    await handlePagesWithStaticRoutes(prerenderContext, doNotPrerenderList, concurrencyLimit);
+    await callOnPrerenderStartHook(prerenderContext);
     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, renderContext, 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, renderContext, partial);
-    return { viteConfig };
+    warnMissingPages(prerenderContext.prerenderedPageContexts, doNotPrerenderList, partial);
+    const prerenderContextPublic = makePublic(prerenderContext);
+    return { viteConfig, prerenderContextPublic };
 }
-async function collectDoNoPrerenderList(renderContext, pageConfigs, doNotPrerenderList, concurrencyLimit) {
+async function collectDoNoPrerenderList(pageConfigs, doNotPrerenderList, concurrencyLimit) {
     // V1 design
     pageConfigs.forEach((pageConfig) => {
         const configName = 'prerender';
@@ -161,7 +174,8 @@ async function collectDoNoPrerenderList(renderContext, pageConfigs, doNotPrerend
     });
     // Old design
     // TODO/v1-release: remove
-    await Promise.all(renderContext.pageFilesAll
+    const globalContext = (0, globalContext_js_1.getGlobalContext)();
+    await Promise.all(globalContext.pageFilesAll
         .filter((p) => {
         assertExportNames(p);
         if (!p.exportNames?.includes('doNotPrerender'))
@@ -173,8 +187,8 @@ async function collectDoNoPrerenderList(renderContext, pageConfigs, doNotPrerend
         (0, utils_js_1.assert)(p.loadFile);
         await p.loadFile();
     })));
-    renderContext.allPageIds.forEach((pageId) => {
-        const pageFilesServerSide = (0, getPageFiles_js_1.getPageFilesServerSide)(renderContext.pageFilesAll, pageId);
+    globalContext.allPageIds.forEach((pageId) => {
+        const pageFilesServerSide = (0, getPageFiles_js_1.getPageFilesServerSide)(globalContext.pageFilesAll, pageId);
         for (const p of pageFilesServerSide) {
             if (!p.exportNames?.includes('doNotPrerender'))
                 continue;
@@ -203,10 +217,11 @@ function assertExportNames(pageFile) {
     const { exportNames, fileType } = pageFile;
     (0, utils_js_1.assert)(exportNames || fileType === '.page.route' || fileType === '.css', pageFile.filePath);
 }
-async function callOnBeforePrerenderStartHooks(prerenderContext, renderContext, concurrencyLimit, doNotPrerenderList) {
+async function callOnBeforePrerenderStartHooks(prerenderContext, concurrencyLimit, doNotPrerenderList) {
     const onBeforePrerenderStartHooks = [];
+    const globalContext = (0, globalContext_js_1.getGlobalContext)();
     // V1 design
-    await Promise.all(renderContext.pageConfigs.map((pageConfig) => concurrencyLimit(async () => {
+    await Promise.all(globalContext.pageConfigs.map((pageConfig) => concurrencyLimit(async () => {
         const hookName = 'onBeforePrerenderStart';
         const pageConfigLoaded = await (0, loadConfigValues_js_1.loadConfigValues)(pageConfig, false);
         const hook = (0, getHook_js_1.getHookFromPageConfig)(pageConfigLoaded, hookName);
@@ -222,7 +237,7 @@ async function callOnBeforePrerenderStartHooks(prerenderContext, renderContext,
         });
     })));
     // 0.4 design
-    await Promise.all(renderContext.pageFilesAll
+    await Promise.all(globalContext.pageFilesAll
         .filter((p) => {
         assertExportNames(p);
         if (!p.exportNames?.includes('prerender'))
@@ -263,7 +278,7 @@ async function callOnBeforePrerenderStartHooks(prerenderContext, renderContext,
                     (0, utils_js_1.assertUsage)(false, `URL ${picocolors_1.default.cyan(url)} provided ${providedTwice}. Make sure to provide the URL only once instead.`);
                 }
             }
-            const pageContextNew = createPageContext(url, renderContext, prerenderContext);
+            const pageContextNew = createPageContext(url, prerenderContext);
             (0, utils_js_1.objectAssign)(pageContextNew, {
                 _providedByHook: {
                     hookFilePath,
@@ -280,9 +295,10 @@ async function callOnBeforePrerenderStartHooks(prerenderContext, renderContext,
         });
     })));
 }
-async function handlePagesWithStaticRoutes(prerenderContext, renderContext, doNotPrerenderList, concurrencyLimit) {
+async function handlePagesWithStaticRoutes(prerenderContext, doNotPrerenderList, concurrencyLimit) {
     // Pre-render pages with a static route
-    await Promise.all(renderContext.pageRoutes.map((pageRoute) => concurrencyLimit(async () => {
+    const globalContext = (0, globalContext_js_1.getGlobalContext)();
+    await Promise.all(globalContext.pageRoutes.map((pageRoute) => concurrencyLimit(async () => {
         const { pageId } = pageRoute;
         if (doNotPrerenderList.find((p) => p.pageId === pageId)) {
             return;
@@ -307,7 +323,7 @@ async function handlePagesWithStaticRoutes(prerenderContext, renderContext, doNo
             return;
         }
         const routeParams = {};
-        const pageContext = createPageContext(urlOriginal, renderContext, prerenderContext);
+        const pageContext = createPageContext(urlOriginal, prerenderContext);
         (0, utils_js_1.objectAssign)(pageContext, {
             _providedByHook: null,
             routeParams,
@@ -325,11 +341,11 @@ async function handlePagesWithStaticRoutes(prerenderContext, renderContext, doNo
         prerenderContext.pageContexts.push(pageContext);
     })));
 }
-function createPageContext(urlOriginal, renderContext, prerenderContext) {
+function createPageContext(urlOriginal, prerenderContext) {
     const pageContext = {
         _urlHandler: null,
         _urlRewrite: null,
-        _noExtraDir: prerenderContext._noExtraDir,
+        _noExtraDir: prerenderContext.noExtraDir,
         _prerenderContext: prerenderContext
     };
     const pageContextInit = {
@@ -337,17 +353,18 @@ function createPageContext(urlOriginal, renderContext, prerenderContext) {
     };
     (0, utils_js_1.objectAssign)(pageContextInit, prerenderContext.pageContextInit);
     {
-        const pageContextInitEnhanced = (0, renderPageAlreadyRouted_js_1.getPageContextInitEnhanced)(pageContextInit, renderContext);
+        const pageContextInitEnhanced = (0, renderPageAlreadyRouted_js_1.getPageContextInitEnhanced)(pageContextInit);
         (0, utils_js_1.objectAssign)(pageContext, pageContextInitEnhanced);
     }
     return pageContext;
 }
-async function callOnPrerenderStartHook(prerenderContext, renderContext) {
+async function callOnPrerenderStartHook(prerenderContext) {
+    const globalContext = (0, globalContext_js_1.getGlobalContext)();
     let onPrerenderStartHook;
     // V1 design
-    if (renderContext.pageConfigs.length > 0) {
+    if (globalContext.pageConfigs.length > 0) {
         const hookName = 'onPrerenderStart';
-        const hook = (0, getHook_js_1.getHookFromPageConfigGlobal)(renderContext.pageConfigGlobal, hookName);
+        const hook = (0, getHook_js_1.getHookFromPageConfigGlobal)(globalContext.pageConfigGlobal, hookName);
         if (hook) {
             (0, utils_js_1.assert)(hook.hookName === 'onPrerenderStart');
             onPrerenderStartHook = {
@@ -359,9 +376,9 @@ async function callOnPrerenderStartHook(prerenderContext, renderContext) {
     }
     // Old design
     // TODO/v1-release: remove
-    if (renderContext.pageConfigs.length === 0) {
+    if (globalContext.pageConfigs.length === 0) {
         const hookTimeout = (0, getHook_js_1.getHookTimeoutDefault)('onBeforePrerender');
-        const pageFilesWithOnBeforePrerenderHook = renderContext.pageFilesAll.filter((p) => {
+        const pageFilesWithOnBeforePrerenderHook = globalContext.pageFilesAll.filter((p) => {
             assertExportNames(p);
             if (!p.exportNames?.includes('onBeforePrerender'))
                 return false;
@@ -414,17 +431,20 @@ async function callOnPrerenderStartHook(prerenderContext, renderContext) {
     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;
@@ -506,10 +526,10 @@ async function routeAndPrerender(prerenderContext, concurrencyLimit, onComplete)
             if (pageContext._pageConfigs.length > 0) {
                 const pageConfig = pageContext._pageConfigs.find((p) => p.pageId === pageId);
                 (0, utils_js_1.assert)(pageConfig);
-                usesClientRouter = (0, getConfigValue_js_1.getConfigValueRuntime)(pageConfig, 'clientRouting', 'boolean')?.value ?? false;
+                usesClientRouter = (0, getConfigValueRuntime_js_1.getConfigValueRuntime)(pageConfig, 'clientRouting', 'boolean')?.value ?? false;
             }
             else {
-                usesClientRouter = globalContext.pluginManifest.usesClientRouter;
+                usesClientRouter = globalContext.usesClientRouter;
             }
         }
         (0, utils_js_1.objectAssign)(pageContext, {
@@ -531,7 +551,7 @@ async function routeAndPrerender(prerenderContext, concurrencyLimit, onComplete)
             pageContext,
             htmlString: documentHtml,
             pageContextSerialized,
-            doNotCreateExtraDirectory: prerenderContext._noExtraDir,
+            doNotCreateExtraDirectory: prerenderContext.noExtraDir,
             pageId
         });
     })));
@@ -549,27 +569,28 @@ function warnContradictoryNoPrerenderList(prerenderedPageContexts, doNotPrerende
         (0, utils_js_1.assertWarning)(false, `The ${providedByHook.hookName}() hook defined by ${providedByHook.hookFilePath} returns the URL ${picocolors_1.default.cyan(urlOriginal)}, while ${setByConfigFile} sets the config ${picocolors_1.default.cyan(setByConfigName)} to ${picocolors_1.default.cyan(String(setByConfigValue))}. This is contradictory: either don't set the config ${picocolors_1.default.cyan(setByConfigName)} to ${picocolors_1.default.cyan(String(setByConfigValue))} or remove the URL ${picocolors_1.default.cyan(urlOriginal)} from the list of URLs to be pre-rendered.`, { onlyOnce: true });
     });
 }
-function warnMissingPages(prerenderedPageContexts, doNotPrerenderList, renderContext, partial) {
-    const isV1 = renderContext.pageConfigs.length > 0;
+function warnMissingPages(prerenderedPageContexts, doNotPrerenderList, partial) {
+    const globalContext = (0, globalContext_js_1.getGlobalContext)();
+    const isV1 = globalContext.pageConfigs.length > 0;
     const hookName = isV1 ? 'onBeforePrerenderStart' : 'prerender';
     /* TODO/after-v1-design-release: document setting `prerender: false` as an alternative to using prerender.partial (both in the warnings and the docs)
     const optOutName = isV1 ? 'prerender' : 'doNotPrerender'
     const msgAddendum = `Explicitly opt-out by setting the config ${optOutName} to ${isV1 ? 'false' : 'true'} or use the option prerender.partial`
     */
-    renderContext.allPageIds
+    globalContext.allPageIds
         .filter((pageId) => !prerenderedPageContexts[pageId])
         .filter((pageId) => !doNotPrerenderList.find((p) => p.pageId === pageId))
-        .filter((pageId) => !(0, error_page_js_1.isErrorPage)(pageId, renderContext.pageConfigs))
+        .filter((pageId) => !(0, error_page_js_1.isErrorPage)(pageId, globalContext.pageConfigs))
         .forEach((pageId) => {
         const pageAt = isV1 ? pageId : `\`${pageId}.page.*\``;
         (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, renderContext, 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)(renderContext, prerenderContext.pageContextInit);
+            result = await (0, renderPageAlreadyRouted_js_1.prerender404Page)(prerenderContext.pageContextInit);
         }
         catch (err) {
             assertIsNotAbort(err, 'the 404 page');
@@ -589,22 +610,23 @@ async function prerender404(prerenderedPageContexts, renderContext, prerenderCon
         }
     }
 }
-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);
@@ -616,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);
@@ -700,25 +728,6 @@ async function disableReactStreaming() {
     const { disable } = mod;
     disable();
 }
-function assertLoadedConfig(viteConfig, options) {
-    if (viteConfig.plugins.some((p) => p.name.startsWith('vike'))) {
-        return;
-    }
-    const { configFile } = viteConfig;
-    if (configFile) {
-        (0, utils_js_1.assertUsage)(false, `${configFile} doesn't install the vike plugin`);
-    }
-    else {
-        if (!options.viteConfig) {
-            (0, utils_js_1.assertUsage)(false, `[prerender()] No vite.config.js file found at ${process.cwd()}. Use the option ${picocolors_1.default.cyan('prerender({ viteConfig })')}.`, { showStackTrace: true });
-        }
-        else {
-            (0, utils_js_1.assertUsage)(false, `[prerender()] The Vite config ${picocolors_1.default.cyan('prerender({ viteConfig })')} is missing the vike plugin.`, {
-                showStackTrace: true
-            });
-        }
-    }
-}
 function isSameUrl(url1, url2) {
     return normalizeUrl(url1) === normalizeUrl(url2);
 }
@@ -768,3 +777,44 @@ function makePageContextComputedUrlNonEnumerable(pageContexts) {
         });
     }
 }
+function validatePrerenderConfig(
+// Guaranteed by configDef.type to be either an object or boolean
+prerenderConfig) {
+    if (!prerenderConfig || typeof prerenderConfig === 'boolean')
+        return;
+    (0, utils_js_1.assert)((0, utils_js_1.isObject)(prerenderConfig));
+    const wrongValue = (() => {
+        {
+            const p = 'partial';
+            if (!(0, utils_js_1.hasProp)(prerenderConfig, p, 'boolean') && !(0, utils_js_1.hasProp)(prerenderConfig, p, 'undefined'))
+                return { prop: p, errMsg: 'should be a boolean' };
+        }
+        {
+            const p = 'noExtraDir';
+            if (!(0, utils_js_1.hasProp)(prerenderConfig, p, 'boolean') && !(0, utils_js_1.hasProp)(prerenderConfig, p, 'undefined'))
+                return { prop: p, errMsg: 'should be a boolean' };
+        }
+        {
+            const p = 'disableAutoRun';
+            if (!(0, utils_js_1.hasProp)(prerenderConfig, p, 'boolean') && !(0, utils_js_1.hasProp)(prerenderConfig, p, 'undefined'))
+                return { prop: p, errMsg: 'should be a boolean' };
+        }
+        {
+            const p = 'parallel';
+            if (!(0, utils_js_1.hasProp)(prerenderConfig, p, 'boolean') &&
+                !(0, utils_js_1.hasProp)(prerenderConfig, p, 'number') &&
+                !(0, utils_js_1.hasProp)(prerenderConfig, p, 'undefined'))
+                return { prop: p, errMsg: 'should be a boolean or a number' };
+        }
+    })();
+    if (wrongValue) {
+        const { prop, errMsg } = wrongValue;
+        (0, utils_js_1.assertUsage)(false, `Setting ${picocolors_1.default.cyan(`prerender.${prop}`)} ${errMsg}`);
+    }
+}
+function makePublic(prerenderContext) {
+    const prerenderContextPublic = (0, utils_js_1.makePublicCopy)(prerenderContext, 'prerenderContext', [
+        'pageContexts'
+    ]);
+    return prerenderContextPublic;
+}

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

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