vike 0.4.231 → 0.4.232-commit-ec54a7e

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

@@ -36,17 +36,17 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.runPrerenderFromAPI = runPrerenderFromAPI;
-exports.runPrerenderFromCLIPrerenderCommand = runPrerenderFromCLIPrerenderCommand;
-exports.runPrerenderFromAutoRun = runPrerenderFromAutoRun;
-exports.runPrerender_forceExit = runPrerender_forceExit;
-const path_1 = __importDefault(require("path"));
+exports.runPrerender = runPrerender;
+// Failed attempt to run this file (i.e. pre-rendering) in a separate process: https://github.com/vikejs/vike/commit/48feda87012115b32a5c9701da354cb8c138dfd2
+// - The issue is that prerenderContext needs to be serialized for being able to pass it from the child process to the parent process.
+// - The prerenderContext is used by vike-vercel
+const node_path_1 = __importDefault(require("node:path"));
 const index_js_1 = require("../../shared/route/index.js");
 const utils_js_1 = require("./utils.js");
 const renderPageAlreadyRouted_js_1 = require("../runtime/renderPage/renderPageAlreadyRouted.js");
 const createPageContextServerSide_js_1 = require("../runtime/renderPage/createPageContextServerSide.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
-const os_1 = require("os");
+const node_os_1 = require("node:os");
 const globalContext_js_1 = require("../runtime/globalContext.js");
 const vite_1 = require("vite");
 const getPageFiles_js_1 = require("../../shared/getPageFiles.js");
@@ -59,53 +59,18 @@ const abort_js_1 = require("../../shared/route/abort.js");
 const loadPageConfigsLazyServerSide_js_1 = require("../runtime/renderPage/loadPageConfigsLazyServerSide.js");
 const getHook_js_1 = require("../../shared/hooks/getHook.js");
 const noRouteMatch_js_1 = require("../../shared/route/noRouteMatch.js");
-const getVikeConfig_js_1 = require("../plugin/plugins/importUserCode/v1-design/getVikeConfig.js");
-const logErrorHint_js_1 = require("../runtime/renderPage/logErrorHint.js");
+const resolveVikeConfigInternal_js_1 = require("../vite/shared/resolveVikeConfigInternal.js");
 const execHook_js_1 = require("../../shared/hooks/execHook.js");
-const prepareViteApiCall_js_1 = require("../api/prepareViteApiCall.js");
 const context_js_1 = require("./context.js");
 const resolvePrerenderConfig_js_1 = require("./resolvePrerenderConfig.js");
-const getOutDirs_js_1 = require("../plugin/shared/getOutDirs.js");
-const context_js_2 = require("../cli/context.js");
-const isViteCliCall_js_1 = require("../plugin/shared/isViteCliCall.js");
-const commonConfig_js_1 = require("../plugin/plugins/commonConfig.js");
+const getOutDirs_js_1 = require("../vite/shared/getOutDirs.js");
 const node_fs_1 = __importDefault(require("node:fs"));
 const getProxyForPublicUsage_js_1 = require("../../shared/getProxyForPublicUsage.js");
+const resolveRedirects_js_1 = require("../runtime/renderPage/resolveRedirects.js");
+const utils_js_2 = require("../runtime/utils.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.
-    // - We don't use logErrorHint() because we don't have control over what happens with the error. For example, if the user land purposely swallows the error then the hint shouldn't be logged. Also, it's best if the hint is shown to the user *after* the error, but we cannot do/guarentee that.
-}
-async function runPrerenderFromCLIPrerenderCommand() {
-    try {
-        const { viteConfigFromUserEnhanced } = await (0, prepareViteApiCall_js_1.prepareViteApiCall)({}, 'prerender');
-        await runPrerender({ viteConfig: viteConfigFromUserEnhanced }, '$ vike prerender');
-    }
-    catch (err) {
-        console.error(err);
-        // Error may come from user-land; we need to use logErrorHint()
-        (0, logErrorHint_js_1.logErrorHint)(err);
-        process.exit(1);
-    }
-    runPrerender_forceExit();
-    (0, utils_js_1.assert)(false);
-}
-async function runPrerenderFromAutoRun(viteConfig) {
-    try {
-        await runPrerender({ viteConfig });
-    }
-    catch (err) {
-        // Avoid Rollup prefixing the error with [vike:build:pluginAutoFullBuild], see for example https://github.com/vikejs/vike/issues/472#issuecomment-1276274203
-        console.error(err);
-        (0, logErrorHint_js_1.logErrorHint)(err);
-        process.exit(1);
-    }
-    const forceExit = (0, context_js_2.isVikeCli)() || (0, isViteCliCall_js_1.isViteCliCall)();
-    return { forceExit };
-}
-async function runPrerender(options = {}, standaloneTrigger) {
-    (0, context_js_1.setContextIsPrerendering)();
+async function runPrerender(options = {}, trigger) {
+    (0, context_js_1.setWasPrerenderRun)(trigger);
     checkOutdatedOptions(options);
     (0, utils_js_1.onSetupPrerender)();
     (0, globalContext_js_1.setGlobalContext_isPrerendering)();
@@ -116,15 +81,15 @@ async function runPrerender(options = {}, standaloneTrigger) {
     }
     await disableReactStreaming();
     const viteConfig = await (0, vite_1.resolveConfig)(options.viteConfig || {}, 'build', 'production');
-    const vikeConfig = await (0, getVikeConfig_js_1.getVikeConfig)(viteConfig);
-    const vike = (0, commonConfig_js_1.getVikeConfigInternal)(viteConfig);
-    const { outDirClient, outDirServer } = (0, getOutDirs_js_1.getOutDirs)(viteConfig);
-    const { root } = viteConfig;
+    const vikeConfig = await (0, resolveVikeConfigInternal_js_1.getVikeConfigInternal)();
+    const { outDirServer } = (0, getOutDirs_js_1.getOutDirs)(viteConfig);
     const prerenderConfigGlobal = (0, resolvePrerenderConfig_js_1.resolvePrerenderConfigGlobal)(vikeConfig);
     const { partial, noExtraDir, parallel, defaultLocalValue, isPrerenderingEnabled } = prerenderConfigGlobal;
     if (!isPrerenderingEnabled) {
-        (0, utils_js_1.assert)(standaloneTrigger);
-        /* TODO/soon: use this again a little while after https://github.com/magne4000/vite-plugin-vercel/pull/156 is merged.
+        (0, utils_js_1.assert)(trigger !== 'auto-run');
+        /* TODO/v1-release: use this assertUsage() again.
+         * - Make sure https://github.com/magne4000/vite-plugin-vercel/pull/156 is merged before using this assertUsage() again. (Otherwise vite-plugin-vercel will trigger this assertUsage() call.)
+         *   - Done: PR is merged as of June 20205
         assertUsage(
           false,
           `You're executing ${pc.cyan(standaloneTrigger)} but you didn't enable pre-rendering. Use the ${pc.cyan('prerender')} setting (${pc.underline('https://vike.dev/prerender')}) to enable pre-rendering for at least one page.`
@@ -132,7 +97,7 @@ async function runPrerender(options = {}, standaloneTrigger) {
         */
         return { viteConfig };
     }
-    const concurrencyLimit = (0, utils_js_1.pLimit)(parallel === false || parallel === 0 ? 1 : parallel === true || parallel === undefined ? (0, os_1.cpus)().length : parallel);
+    const concurrencyLimit = (0, utils_js_1.pLimit)(parallel === false || parallel === 0 ? 1 : parallel === true || parallel === undefined ? (0, node_os_1.cpus)().length : parallel);
     await (0, globalContext_js_1.initGlobalContext_runPrerender)();
     const { globalContext } = await (0, globalContext_js_1.getGlobalContextServerInternal)();
     globalContext._pageFilesAll.forEach(assertExportNames);
@@ -141,10 +106,10 @@ async function runPrerender(options = {}, standaloneTrigger) {
         output: [],
         _noExtraDir: noExtraDir,
         _pageContextInit: options.pageContextInit ?? null,
-        _prerenderedPageContexts: {}
+        _prerenderedPageContexts: {},
     };
     const doNotPrerenderList = [];
-    await collectDoNoPrerenderList(vikeConfig.pageConfigs, doNotPrerenderList, defaultLocalValue, concurrencyLimit, globalContext);
+    await collectDoNoPrerenderList(vikeConfig._pageConfigs, doNotPrerenderList, defaultLocalValue, concurrencyLimit, globalContext);
     // Allow user to create `pageContext` for parameterized routes and/or bulk data fetching
     // https://vike.dev/onBeforePrerenderStart
     await callOnBeforePrerenderStartHooks(prerenderContext, globalContext, concurrencyLimit, doNotPrerenderList);
@@ -162,18 +127,25 @@ async function runPrerender(options = {}, standaloneTrigger) {
     const onComplete = async (htmlFile) => {
         prerenderedCount++;
         const { pageId } = htmlFile.pageContext;
-        (0, utils_js_1.assert)(pageId);
-        prerenderContext._prerenderedPageContexts[pageId] = htmlFile.pageContext;
-        await writeFiles(htmlFile, root, outDirClient, options.onPagePrerender, prerenderContext.output, logLevel);
+        (0, utils_js_1.assert)((typeof pageId === 'string' && pageId) || pageId === null);
+        if (pageId) {
+            prerenderContext._prerenderedPageContexts[pageId] = htmlFile.pageContext;
+        }
+        await writeFiles(htmlFile, viteConfig, options.onPagePrerender, prerenderContext, logLevel);
     };
     await prerenderPages(prerenderContext, concurrencyLimit, onComplete);
     warnContradictoryNoPrerenderList(prerenderContext._prerenderedPageContexts, doNotPrerenderList);
+    const { redirects, isPrerenderingEnabledForAllPages } = prerenderConfigGlobal;
+    if (redirects !== null ? redirects : isPrerenderingEnabledForAllPages) {
+        const showWarningUponDynamicRedirects = !prerenderConfigGlobal.partial;
+        await prerenderRedirects(globalContext, onComplete, showWarningUponDynamicRedirects);
+    }
     if (logLevel === 'info') {
         console.log(`${picocolors_1.default.green(`✓`)} ${prerenderedCount} HTML documents pre-rendered.`);
     }
     await warnMissingPages(prerenderContext._prerenderedPageContexts, globalContext, doNotPrerenderList, partial);
     const prerenderContextPublic = preparePrerenderContextForPublicUsage(prerenderContext);
-    (0, utils_js_1.objectAssign)(vike.prerenderContext, prerenderContextPublic, true);
+    (0, utils_js_1.objectAssign)(vikeConfig.prerenderContext, prerenderContextPublic, true);
     if (prerenderConfigGlobal.isPrerenderingEnabledForAllPages && !prerenderConfigGlobal.keepDistServer) {
         node_fs_1.default.rmSync(outDirServer, { recursive: true });
     }
@@ -250,7 +222,7 @@ async function callOnBeforePrerenderStartHooks(prerenderContext, globalContext,
             hookName: 'onBeforePrerenderStart',
             hookFilePath,
             pageId: pageConfig.pageId,
-            hookTimeout
+            hookTimeout,
         });
     })));
     // 0.4 design
@@ -275,7 +247,7 @@ async function callOnBeforePrerenderStartHooks(prerenderContext, globalContext,
             hookName: 'prerender',
             hookFilePath,
             pageId: p.pageId,
-            hookTimeout: (0, getHook_js_1.getHookTimeoutDefault)('onBeforePrerenderStart')
+            hookTimeout: (0, getHook_js_1.getHookTimeoutDefault)('onBeforePrerenderStart'),
         });
     })));
     await Promise.all(onBeforePrerenderStartHooks.map(({ pageId, ...hook }) => concurrencyLimit(async () => {
@@ -340,7 +312,7 @@ function getUrlList404(globalContext) {
         urlList.push({
             // A URL is required for `viteDevServer.transformIndexHtml(url,html)`
             urlOriginal: '/404',
-            pageId: errorPageId
+            pageId: errorPageId,
         });
     }
     return urlList;
@@ -358,10 +330,10 @@ async function createPageContexts(urlList, prerenderContext, globalContext, conc
 async function createPageContextPrerendering(urlOriginal, prerenderContext, globalContext, is404, pageId, providedByHook) {
     const pageContextInit = {
         urlOriginal,
-        ...prerenderContext._pageContextInit
+        ...prerenderContext._pageContextInit,
     };
     const pageContext = await (0, createPageContextServerSide_js_1.createPageContextServerSide)(pageContextInit, globalContext, {
-        isPrerendering: true
+        isPrerendering: true,
     });
     (0, utils_js_1.assert)(pageContext.isPrerendering === true);
     (0, utils_js_1.objectAssign)(pageContext, {
@@ -372,7 +344,7 @@ async function createPageContextPrerendering(urlOriginal, prerenderContext, glob
         _prerenderContext: prerenderContext,
         _providedByHook: providedByHook,
         _urlOriginalModifiedByHook: null,
-        is404
+        is404,
     });
     if (!is404) {
         const pageContextFromRoute = await (0, index_js_1.route)(pageContext);
@@ -386,10 +358,10 @@ async function createPageContextPrerendering(urlOriginal, prerenderContext, glob
         (0, utils_js_1.objectAssign)(pageContext, {
             pageId,
             _debugRouteMatches: [],
-            routeParams: {}
+            routeParams: {},
         });
     }
-    (0, utils_js_1.objectAssign)(pageContext, await (0, loadPageConfigsLazyServerSide_js_1.loadPageConfigsLazyServerSide)(pageContext));
+    (0, utils_js_2.augmentType)(pageContext, await (0, loadPageConfigsLazyServerSide_js_1.loadPageConfigsLazyServerSide)(pageContext));
     let usesClientRouter;
     {
         const { pageId } = pageContext;
@@ -429,7 +401,7 @@ function assertRouteMatch(pageContextFromRoute, pageContext) {
         (0, utils_js_1.assertUsage)(false, `The ${hookName}() hook defined by ${hookFilePath} returns a URL ${picocolors_1.default.cyan(urlOriginal)} that ${noRouteMatch_js_1.noRouteMatch}. Make sure that the URLs returned by ${hookName}() always match the route of a page.`);
     }
     else {
-        // `prerenderHookFile` is `null` when the URL was deduced by the Filesytem Routing of `.page.js` files. The `onBeforeRoute()` can override Filesystem Routing; it is therefore expected that the deduced URL may not match any page.
+        // `prerenderHookFile` is `null` when the URL was deduced by the Filesystem Routing of `.page.js` files. The `onBeforeRoute()` can override Filesystem Routing; it is therefore expected that the deduced URL may not match any page.
         (0, utils_js_1.assert)(pageContextFromRoute._routingProvidedByOnBeforeRouteHook);
         // Abort since the URL doesn't correspond to any page
         return;
@@ -446,7 +418,7 @@ async function callOnPrerenderStartHook(prerenderContext, globalContext, concurr
             onPrerenderStartHook = {
                 ...hook,
                 // Make TypeScript happy
-                hookName
+                hookName,
             };
         }
     }
@@ -459,7 +431,7 @@ async function callOnPrerenderStartHook(prerenderContext, globalContext, concurr
             if (!p.exportNames?.includes('onBeforePrerender'))
                 return false;
             (0, utils_js_1.assertUsage)(p.fileType !== '.page.client', `${p.filePath} (which is a \`.page.client.js\` file) has \`export { onBeforePrerender }\` but it is only allowed in \`.page.server.js\` or \`.page.js\` files`);
-            (0, utils_js_1.assertUsage)(p.isDefaultPageFile, `${p.filePath} has \`export { onBeforePrerender }\` but it is only allowed in \`_defaut.page.\` files`);
+            (0, utils_js_1.assertUsage)(p.isDefaultPageFile, `${p.filePath} has \`export { onBeforePrerender }\` but it is only allowed in \`_default.page.\` files`);
             return true;
         });
         if (pageFilesWithOnBeforePrerenderHook.length === 0) {
@@ -480,7 +452,7 @@ async function callOnPrerenderStartHook(prerenderContext, globalContext, concurr
             hookFn: hook.onBeforePrerender,
             hookFilePath: hook.hookFilePath,
             hookName: 'onBeforePrerender',
-            hookTimeout
+            hookTimeout,
         };
     }
     if (!onPrerenderStartHook) {
@@ -498,7 +470,7 @@ async function callOnPrerenderStartHook(prerenderContext, globalContext, concurr
                 return pageContext.urlOriginal;
             },
             enumerable: false,
-            configurable: true
+            configurable: true,
         });
         (0, utils_js_1.assert)((0, utils_js_1.isPropertyGetter)(pageContext, 'url'));
         (0, utils_js_1.assert)(pageContext.urlOriginal);
@@ -529,8 +501,8 @@ async function callOnPrerenderStartHook(prerenderContext, globalContext, concurr
         (0, utils_js_1.assertWarning)(false, `${errPrefix} returns ${picocolors_1.default.cyan('{ globalContext: { prerenderPageContexts } }')} but the return value has been renamed to ${picocolors_1.default.cyan('{ prerenderContext: { pageContexts } }')}, see ${docLink}`, { onlyOnce: true });
         result = {
             prerenderContext: {
-                pageContexts: result.globalContext.prerenderPageContexts
-            }
+                pageContexts: result.globalContext.prerenderPageContexts,
+            },
         };
     }
     (0, utils_js_1.assertUsage)((0, utils_js_1.isObjectWithKeys)(result, ['prerenderContext']) &&
@@ -556,7 +528,7 @@ async function callOnPrerenderStartHook(prerenderContext, globalContext, concurr
         if (pageContext.urlOriginal !== pageContext._urlOriginalBeforeHook && !pageContext.is404) {
             pageContext._urlOriginalModifiedByHook = {
                 hookFilePath,
-                hookName
+                hookName,
             };
             const pageContextFromRoute = await (0, index_js_1.route)(pageContext, 
             // Avoid calling onBeforeRoute() twice, otherwise onBeforeRoute() will wrongfully believe URL doesn't have locale after onBeforeRoute() already removed the local from the URL when called the first time.
@@ -581,7 +553,6 @@ async function prerenderPages(prerenderContext, concurrencyLimit, onComplete) {
             pageContext,
             htmlString: documentHtml,
             pageContextSerialized,
-            doNotCreateExtraDirectory: prerenderContext._noExtraDir ?? pageContext.is404
         });
     })));
 }
@@ -610,23 +581,24 @@ async function warnMissingPages(prerenderedPageContexts, globalContext, doNotPre
         .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 });
+        (0, utils_js_1.assertWarning)(partial, `Cannot pre-render page ${pageAt} because it has a non-static route, while there isn't any ${hookName}() hook returning an URL matching the page's route. You must use a ${hookName}() hook (https://vike.dev/${hookName}) for providing the list of URLs to be pre-rendered for that page. If you want to skip pre-rendering that page, you can remove this warning by setting +prerender to false at ${pageAt} (https://vike.dev/prerender#toggle) or by setting +prerender.partial to true (https://vike.dev/prerender#partial).`, { onlyOnce: true });
     });
 }
-async function writeFiles({ pageContext, htmlString, pageContextSerialized, doNotCreateExtraDirectory }, root, outDirClient, onPagePrerender, output, logLevel) {
-    const { urlOriginal } = pageContext;
-    (0, utils_js_1.assert)(urlOriginal.startsWith('/'));
-    const writeJobs = [
-        write(urlOriginal, pageContext, 'HTML', htmlString, root, outDirClient, doNotCreateExtraDirectory, onPagePrerender, output, logLevel)
-    ];
+async function writeFiles({ pageContext, htmlString, pageContextSerialized }, viteConfig, onPagePrerender, prerenderContext, logLevel) {
+    const writeJobs = [write(pageContext, 'HTML', htmlString, viteConfig, onPagePrerender, prerenderContext, logLevel)];
     if (pageContextSerialized !== null) {
-        writeJobs.push(write(urlOriginal, pageContext, 'JSON', pageContextSerialized, root, outDirClient, doNotCreateExtraDirectory, onPagePrerender, output, logLevel));
+        writeJobs.push(write(pageContext, 'JSON', pageContextSerialized, viteConfig, onPagePrerender, prerenderContext, logLevel));
     }
     await Promise.all(writeJobs);
 }
-async function write(urlOriginal, pageContext, fileType, fileContent, root, outDirClient, doNotCreateExtraDirectory, onPagePrerender, output, logLevel) {
+async function write(pageContext, fileType, fileContent, viteConfig, onPagePrerender, prerenderContext, logLevel) {
+    const { urlOriginal } = pageContext;
+    (0, utils_js_1.assert)(urlOriginal.startsWith('/'));
+    const { outDirClient } = (0, getOutDirs_js_1.getOutDirs)(viteConfig);
+    const { root } = viteConfig;
     let fileUrl;
     if (fileType === 'HTML') {
+        const doNotCreateExtraDirectory = prerenderContext._noExtraDir ?? pageContext.is404;
         fileUrl = (0, utils_js_1.urlToFile)(urlOriginal, '.html', doNotCreateExtraDirectory);
     }
     else {
@@ -637,35 +609,35 @@ async function write(urlOriginal, pageContext, fileType, fileContent, root, outD
     (0, utils_js_1.assert)(fileUrl.startsWith('/'));
     const filePathRelative = fileUrl.slice(1);
     (0, utils_js_1.assert)(!filePathRelative.startsWith('/'), 
-    // Let's remove this debug info after we add a assertUsage() avoiding https://github.com/vikejs/vike/issues/1929
+    // https://github.com/vikejs/vike/issues/1929
     { urlOriginal, fileUrl });
     (0, utils_js_1.assertPosixPath)(outDirClient);
     (0, utils_js_1.assertPosixPath)(filePathRelative);
-    const filePath = path_1.default.posix.join(outDirClient, filePathRelative);
+    const filePath = node_path_1.default.posix.join(outDirClient, filePathRelative);
     (0, utils_js_1.objectAssign)(pageContext, {
         _prerenderResult: {
             filePath,
-            fileContent
-        }
+            fileContent,
+        },
     });
-    output.push({
+    prerenderContext.output.push({
         filePath,
         fileType,
         fileContent,
-        pageContext
+        pageContext,
     });
     if (onPagePrerender) {
         await onPagePrerender(pageContext);
     }
     else {
-        const { promises } = await Promise.resolve().then(() => __importStar(require('fs')));
+        const { promises } = await Promise.resolve().then(() => __importStar(require('node:fs')));
         const { writeFile, mkdir } = promises;
-        await mkdir(path_1.default.posix.dirname(filePath), { recursive: true });
+        await mkdir(node_path_1.default.posix.dirname(filePath), { recursive: true });
         await writeFile(filePath, fileContent);
         if (logLevel === 'info') {
             (0, utils_js_1.assertPosixPath)(root);
             (0, utils_js_1.assertPosixPath)(outDirClient);
-            let outDirClientRelative = path_1.default.posix.relative(root, outDirClient);
+            let outDirClientRelative = node_path_1.default.posix.relative(root, outDirClient);
             if (!outDirClientRelative.endsWith('/')) {
                 outDirClientRelative = outDirClientRelative + '/';
             }
@@ -715,7 +687,7 @@ function checkOutdatedOptions(options) {
     ['base', 'outDir'].forEach((prop) => {
         (0, utils_js_1.assertWarning)(options[prop] === undefined, `[prerender()] Option ${picocolors_1.default.cyan(prop)} is outdated and has no effect (vike now automatically determines ${picocolors_1.default.cyan(prop)})`, {
             showStackTrace: true,
-            onlyOnce: true
+            onlyOnce: true,
         });
     });
 }
@@ -736,16 +708,6 @@ function isSameUrl(url1, url2) {
 function normalizeUrl(url) {
     return '/' + url.split('/').filter(Boolean).join('/');
 }
-function runPrerender_forceExit() {
-    // Force exit; known situations where pre-rendering is hanging:
-    //  - https://github.com/vikejs/vike/discussions/774#discussioncomment-5584551
-    //  - https://github.com/vikejs/vike/issues/807#issuecomment-1519010902
-    process.exit(0);
-    /* I guess there is no need to tell the user about it? Let's see if a user complains.
-     * I don't known whether there is a way to call process.exit(0) only if needed, thus I'm not sure if there is a way to conditionally show a assertInfo().
-    assertInfo(false, "Pre-rendering was forced exit. (Didn't gracefully exit because the event queue isn't empty. This is usally fine, see ...", { onlyOnce: false })
-    */
-}
 function assertIsNotAbort(err, urlOriginal) {
     if (!(0, abort_js_1.isAbortError)(err))
         return;
@@ -766,10 +728,10 @@ function preparePrerenderContextForPublicUsage(prerenderContext) {
             get() {
                 (0, utils_js_1.assertWarning)(false, `prerenderPageContexts has been renamed pageContexts, see ${picocolors_1.default.underline(docLink)}`, {
                     showStackTrace: true,
-                    onlyOnce: true
+                    onlyOnce: true,
                 });
                 return prerenderContext.pageContexts;
-            }
+            },
         });
     }
     // Required because of https://vike.dev/i18n#pre-rendering
@@ -780,3 +742,41 @@ function preparePrerenderContextForPublicUsage(prerenderContext) {
     const prerenderContextPublic = (0, getProxyForPublicUsage_js_1.getProxyForPublicUsage)(prerenderContext, 'prerenderContext');
     return prerenderContextPublic;
 }
+async function prerenderRedirects(globalContext, onComplete, showWarningUponDynamicRedirects) {
+    const redirects = globalContext.config.redirects ?? [];
+    const redirectsStatic = (0, resolveRedirects_js_1.getStaticRedirectsForPrerender)(redirects, showWarningUponDynamicRedirects);
+    for (const [urlSource, urlTarget] of Object.entries(redirectsStatic)) {
+        const urlOriginal = urlSource;
+        const htmlString = getRedirectHtml(urlTarget);
+        await onComplete({
+            pageContext: { urlOriginal, pageId: null, is404: false, isRedirect: true },
+            htmlString,
+            pageContextSerialized: null,
+        });
+    }
+}
+function getRedirectHtml(urlTarget) {
+    const urlTargetSafe = (0, utils_js_1.escapeHtml)(urlTarget);
+    // To test it: /test/playground => http://localhost:3000/download
+    const htmlString = `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta http-equiv="refresh" content="0;url=${urlTargetSafe}">
+  <title>Redirect ${urlTargetSafe}</title>
+  <style>body{opacity:0}</style>
+  <noscript>
+  <style>body{opacity:1}</style>
+  </noscript>
+</head>
+<body style="min-height: 100vh; margin: 0; font-family: sans-serif; display: flex; justify-content: center; align-items: center; transition: opacity 0.3s;">
+  <script>setTimeout(()=>{document.body.style.opacity=1},2000)</script>
+  <div>
+    <h1>Redirect <a href="${urlTargetSafe}"><code style="background-color: #eaeaea; padding: 3px 5px; border-radius: 4px;">${urlTargetSafe}</code></a></h1>
+    <p>If you aren't redirected, click the link above.</p>
+    <!-- This HTML was generated by Vike. -->
+  </div>
+</body>
+</html>`;
+    return htmlString;
+}

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

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runPrerenderFromAPI = runPrerenderFromAPI;
+exports.runPrerenderFromCLIPrerenderCommand = runPrerenderFromCLIPrerenderCommand;
+exports.runPrerenderFromAutoRun = runPrerenderFromAutoRun;
+exports.runPrerender_forceExit = runPrerender_forceExit;
+const utils_js_1 = require("./utils.js");
+const logErrorHint_js_1 = require("../runtime/renderPage/logErrorHint.js");
+const prepareViteApiCall_js_1 = require("../api/prepareViteApiCall.js");
+const context_js_1 = require("../cli/context.js");
+const isViteCliCall_js_1 = require("../vite/shared/isViteCliCall.js");
+const runPrerender_js_1 = require("./runPrerender.js");
+async function runPrerenderFromAPI(options = {}) {
+    // - 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.
+    // - We don't use logErrorHint() because we don't have control over what happens with the error. For example, if the user land purposely swallows the error then the hint shouldn't be logged. Also, it's best if the hint is shown to the user *after* the error, but we cannot do/guarentee that.
+    const { viteConfig } = await (0, runPrerender_js_1.runPrerender)(options, 'prerender()');
+    return { viteConfig };
+}
+async function runPrerenderFromCLIPrerenderCommand() {
+    try {
+        const { viteConfigFromUserEnhanced } = await (0, prepareViteApiCall_js_1.prepareViteApiCall)({}, 'prerender');
+        await (0, runPrerender_js_1.runPrerender)({ viteConfig: viteConfigFromUserEnhanced }, '$ vike prerender');
+    }
+    catch (err) {
+        console.error(err);
+        // Error may come from user-land; we need to use logErrorHint()
+        (0, logErrorHint_js_1.logErrorHint)(err);
+        process.exit(1);
+    }
+    runPrerender_forceExit();
+    (0, utils_js_1.assert)(false);
+}
+async function runPrerenderFromAutoRun(viteConfig) {
+    try {
+        await (0, runPrerender_js_1.runPrerender)({ viteConfig }, 'auto-run');
+    }
+    catch (err) {
+        // Avoid Rollup prefixing the error with [vike:build:pluginAutoFullBuild], see for example https://github.com/vikejs/vike/issues/472#issuecomment-1276274203
+        console.error(err);
+        (0, logErrorHint_js_1.logErrorHint)(err);
+        process.exit(1);
+    }
+    const forceExit = (0, context_js_1.isVikeCli)() || (0, isViteCliCall_js_1.isViteCliCall)();
+    return { forceExit };
+}
+function runPrerender_forceExit() {
+    // Force exit; known situations where pre-rendering is hanging:
+    //  - https://github.com/vikejs/vike/discussions/774#discussioncomment-5584551
+    //  - https://github.com/vikejs/vike/issues/807#issuecomment-1519010902
+    process.exit(0);
+    /* I guess there is no need to tell the user about it? Let's see if a user complains.
+     * I don't known whether there is a way to call process.exit(0) only if needed, thus I'm not sure if there is a way to conditionally show a assertInfo().
+    assertInfo(false, "Pre-rendering was forced exit. (Didn't gracefully exit because the event queue isn't empty. This is usually fine, see ...", { onlyOnce: false })
+    */
+}

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

@@ -34,3 +34,4 @@ __exportStar(require("../../utils/isObject.js"), exports);
 __exportStar(require("../../utils/isNullish.js"), exports);
 __exportStar(require("../../utils/preservePropertyGetters.js"), exports);
 __exportStar(require("../../utils/changeEnumerable.js"), exports);
+__exportStar(require("../../utils/escapeHtml.js"), exports);