vike 0.4.231-commit-e1c3295 → 0.4.232-commit-134207d

package/README.md

@@ -1,3 +1,5 @@
-# [vike.dev](https://vike.dev)
+# `vike`
 
-Docs at [vike.dev](https://vike.dev).
+📚 [Docs](https://vike.dev)  
+⚙️  [Source code](https://github.com/vikejs/vike/tree/main/packages/vike)  
+📦 [npm package](https://npmjs.com/package/vike)  

package/dist/cjs/__internal/index.js

@@ -20,12 +20,12 @@ async function getPagesAndRoutes() {
     const { globalContext } = await (0, globalContext_js_2.getGlobalContextServerInternal)();
     const { 
     //
-    _pageRoutes: pageRoutes, _pageFilesAll: pageFilesAll, _pageConfigs: pageConfigs, _allPageIds: allPageIds } = globalContext;
+    _pageRoutes: pageRoutes, _pageFilesAll: pageFilesAll, _pageConfigs: pageConfigs, _allPageIds: allPageIds, } = globalContext;
     return {
         pageRoutes,
         pageFilesAll,
         pageConfigs,
-        allPageIds
+        allPageIds,
     };
 }
 async function route(pageContext) {

package/dist/cjs/client/runtime-client-routing/globalContext.js

@@ -44,6 +44,6 @@ async function addGlobalContext(globalContext) {
     const { pageRoutes, onBeforeRouteHook } = await (0, loadPageRoutes_js_1.loadPageRoutes)(globalContext._pageFilesAll, globalContext._pageConfigs, globalContext._pageConfigGlobal, globalContext._allPageIds);
     return {
         _pageRoutes: pageRoutes,
-        _onBeforeRouteHook: onBeforeRouteHook
+        _onBeforeRouteHook: onBeforeRouteHook,
     };
 }

package/dist/cjs/client/shared/createGetGlobalContextClient.js

@@ -10,7 +10,7 @@ const globalObject = (0, utils_js_1.getGlobalObject)('createGetGlobalContextClie
     const { promise: globalContextPromise, resolve: globalContextPromiseResolve } = (0, utils_js_1.genPromise)();
     return {
         globalContextPromise,
-        globalContextPromiseResolve
+        globalContextPromiseResolve,
     };
 })());
 function createGetGlobalContextClient(virtualFileExports, isClientRouting, addGlobalContext) {
@@ -34,7 +34,7 @@ function createGetGlobalContextClient(virtualFileExports, isClientRouting, addGl
                  *
                  * We recommend using `import.meta.env.SSR` instead, see https://vike.dev/globalContext
                  */
-                isClientSide: true
+                isClientSide: true,
             };
             (0, utils_js_1.objectAssign)(globalContextAddendum, (0, getJsonSerializedInHtml_js_1.getGlobalContextSerializedInHtml)());
             (0, utils_js_1.objectAssign)(globalContextAddendum, await addGlobalContext?.(globalContext));

package/dist/cjs/client/shared/preparePageContextForPublicUsageClientShared.js

@@ -22,7 +22,7 @@ function preparePageContextForPublicUsageClientMinimal(pageContext) {
     const pageContextPublic = (0, preparePageContextForPublicUsage_js_1.preparePageContextForPublicUsage)(pageContext);
     return pageContextPublic;
 }
-// With Vue + Cient Routing, the `pageContext` is made reactive:
+// With Vue + Client Routing, the `pageContext` is made reactive:
 // ```js
 // import { reactive } from 'vue'
 // // See /examples/vue-full/renderer/createVueApp.ts
@@ -31,7 +31,7 @@ function preparePageContextForPublicUsageClientMinimal(pageContext) {
 function supportVueReactiviy(pageContext) {
     resolveGetters(pageContext);
 }
-// Remove propery descriptor getters because they break Vue's reactivity.
+// Remove property descriptor getters because they break Vue's reactivity.
 // E.g. resolve the `pageContext.urlPathname` getter.
 function resolveGetters(pageContext) {
     Object.entries(pageContext).forEach(([key, val]) => {

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

@@ -34,9 +34,13 @@ async function build(options = {}) {
         //    > Rationale: https://github.com/vikejs/vike/issues/2123
         await (0, vite_1.build)(viteConfigFromUserEnhanced);
         // After pre-rendering, when using the Vike CLI, the process is forcefully exited at the end of the buildVite() call above.
-        const prerenderTrigger = (0, context_js_2.wasPrerenderRun)();
-        if ((0, context_js_1.isVikeCli)() && prerenderTrigger && prerenderTrigger !== 'prerender()')
+        if (
+        // When calling Vike's prerender() API pre-rendering is run without force exit
+        ![false, 'prerender()'].includes((0, context_js_2.wasPrerenderRun)()) &&
+            // When calling Vike's build() API pre-rendering is auto run without force exit
+            (0, context_js_1.isVikeCli)()) {
             (0, utils_js_1.assert)(false);
+        }
     }
     return {
     /* We don't return `viteConfig` because `viteConfigFromUserEnhanced` is `InlineConfig` not `ResolvedConfig`

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

@@ -15,6 +15,6 @@ async function dev(options = {}) {
     const server = await (0, vite_1.createServer)(viteConfigFromUserEnhanced);
     return {
         viteServer: server,
-        viteConfig: server.config
+        viteConfig: server.config,
     };
 }

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

@@ -43,7 +43,7 @@ exports.normalizeViteRoot = normalizeViteRoot;
 const vite_1 = require("vite");
 const context_js_1 = require("./context.js");
 const resolveVikeConfigInternal_js_1 = require("../vite/shared/resolveVikeConfigInternal.js");
-const path_1 = __importDefault(require("path"));
+const node_path_1 = __importDefault(require("node:path"));
 const utils_js_1 = require("./utils.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const globalContext_js_1 = require("../runtime/globalContext.js");
@@ -65,7 +65,7 @@ async function resolveConfigs(viteConfigFromUserApiOptions, operation) {
     (0, resolveVikeConfigInternal_js_1.setVikeConfigContext)({
         userRootDir: viteInfo.root,
         isDev: operation === 'dev',
-        vikeVitePluginOptions: viteInfo.vikeVitePluginOptions
+        vikeVitePluginOptions: viteInfo.vikeVitePluginOptions,
     });
     const vikeConfig = await (0, resolveVikeConfigInternal_js_1.getVikeConfigInternal)();
     const viteConfigFromUserEnhanced = applyVikeViteConfig(viteInfo.viteConfigFromUserEnhanced, vikeConfig);
@@ -73,7 +73,7 @@ async function resolveConfigs(viteConfigFromUserApiOptions, operation) {
     return {
         vikeConfig,
         viteConfigResolved, // ONLY USE if strictly necessary. (We plan to remove assertViteRoot2() as explained in the comments of that function.)
-        viteConfigFromUserEnhanced
+        viteConfigFromUserEnhanced,
     };
 }
 // Apply +vite
@@ -98,10 +98,10 @@ async function getViteRoot(operation) {
 async function getViteInfo(viteConfigFromUserApiOptions, operation) {
     let viteConfigFromUserEnhanced = viteConfigFromUserApiOptions;
     // Precedence:
-    //  1) viteConfigFromUserEnvVar (highest precendence)
+    //  1) viteConfigFromUserEnvVar (highest precedence)
     //  2) viteConfigFromUserVikeConfig
     //  2) viteConfigFromUserApiOptions
-    //  3) viteConfigFromUserViteFile (lowest precendence)
+    //  3) viteConfigFromUserViteFile (lowest precedence)
     // Resolve Vike's +mode setting
     {
         const viteConfigFromUserVikeConfig = (0, utils_js_1.pick)((0, resolveVikeConfigInternal_js_1.getVikeConfigFromCliOrEnv)().vikeConfigFromCliOrEnv, ['mode']);
@@ -135,7 +135,7 @@ async function getViteInfo(viteConfigFromUserApiOptions, operation) {
         const { plugin: vikePlugin } = await Promise.resolve().then(() => __importStar(require('../vite/index.js')));
         viteConfigFromUserEnhanced = {
             ...viteConfigFromUserEnhanced,
-            plugins: [...(viteConfigFromUserEnhanced?.plugins ?? []), vikePlugin()]
+            plugins: [...(viteConfigFromUserEnhanced?.plugins ?? []), vikePlugin()],
         };
         const res = findVikeVitePlugin(viteConfigFromUserEnhanced);
         (0, utils_js_1.assert)(res);
@@ -168,7 +168,7 @@ async function loadViteConfigFile(viteConfigFromUserApiOptions, operation) {
         mode,
         command,
         isSsrBuild: command === 'build' && !!config.build?.ssr,
-        isPreview
+        isPreview,
     };
     let { configFile } = config;
     if (configFile !== false) {
@@ -190,7 +190,7 @@ function normalizeViteRoot(root) {
     // https://github.com/vitejs/vite/blob/4f5845a3182fc950eb9cd76d7161698383113b18/packages/vite/src/node/config.ts#L1063
     return (0, utils_js_1.toPosixPath)(
     // Equivalent to `path.resolve(process.cwd(), root)`
-    path_1.default.resolve(root));
+    node_path_1.default.resolve(root));
 }
 const errMsg = `A Vite plugin is modifying Vite's setting ${picocolors_1.default.cyan('root')} which is forbidden`;
 async function assertViteRoot2(root, viteConfigFromUserEnhanced, operation) {

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

@@ -13,6 +13,6 @@ async function prerender(options = {}) {
     options.viteConfig = viteConfigFromUserEnhanced;
     const { viteConfig } = await (0, runPrerenderEntry_js_1.runPrerenderFromAPI)(options);
     return {
-        viteConfig
+        viteConfig,
     };
 }

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

@@ -26,14 +26,14 @@ async function preview(options = {}) {
         const outServerIndexRelative = node_path_1.default.relative(viteConfigResolved.root, outServerIndex);
         (0, utils_js_1.assertWarning)(false, `Never run ${picocolors_1.default.cyan('$ vike preview')} in production, run ${picocolors_1.default.cyan(`$ node ${outServerIndexRelative}`)} instead (or Bun/Deno).`, { onlyOnce: true });
         return {
-            viteConfig: viteConfigResolved
+            viteConfig: viteConfigResolved,
         };
     }
     else {
         const server = await (0, vite_1.preview)(viteConfigFromUserEnhanced);
         return {
             viteServer: server,
-            viteConfig: server.config
+            viteConfig: server.config,
         };
     }
 }

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

@@ -68,7 +68,7 @@ async function cmdDev() {
             const startupDurationString = picocolors_1.default.dim(`ready in ${picocolors_1.default.reset(picocolors_1.default.bold(String(Math.ceil(performance.now() - startTime))))} ms`);
             const hasExistingLogs = process.stdout.bytesWritten > 0 || process.stderr.bytesWritten > 0;
             info(`  ${picocolors_1.default.yellow(`${picocolors_1.default.bold('Vike')} v${utils_js_1.PROJECT_VERSION}`)}  ${startupDurationString}\n`, {
-                clear: !hasExistingLogs
+                clear: !hasExistingLogs,
             });
             viteServer.printUrls();
         }

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

@@ -11,7 +11,7 @@ const commands = [
     { name: 'dev', desc: 'Start development server' },
     { name: 'build', desc: 'Build for production' },
     { name: 'preview', desc: 'Start preview server using production build (only works for SSG apps)' },
-    { name: 'prerender', desc: 'Pre-render pages (only needed when prerender.disableAutoRun is true)' }
+    { name: 'prerender', desc: 'Pre-render pages (only needed when prerender.disableAutoRun is true)' },
 ];
 function parseCli() {
     const command = getCommand();
@@ -72,7 +72,7 @@ function showHelp() {
         `More Vike settings can be passed over the ${picocolors_1.default.cyan('VIKE_CONFIG')} environment variable or as ${picocolors_1.default.cyan('CLI options')}.`,
         `More Vite settings can be passed over the ${picocolors_1.default.cyan('VITE_CONFIG')} environment variable.`,
         ``,
-        `See ${picocolors_1.default.underline('https://vike.dev/cli')} for more information.`
+        `See ${picocolors_1.default.underline('https://vike.dev/cli')} for more information.`,
     ].join('\n'));
     process.exit(1);
 }

package/dist/cjs/node/client/router.js

@@ -14,6 +14,6 @@ exports.onPopState = onPopState;
 function warnNoEffect(caller) {
     (0, assert_js_1.assertWarning)(false, `Calling ${caller}() on the server-side has no effect`, {
         showStackTrace: true,
-        onlyOnce: false
+        onlyOnce: false,
     });
 }

package/dist/cjs/node/createPageRenderer.js

@@ -18,7 +18,7 @@ function showWarnings(options) {
             viteDevServer !== undefined && 'viteDevServer',
             root !== undefined && 'root',
             outDir !== undefined && 'outDir',
-            isProduction !== undefined && 'isProduction'
+            isProduction !== undefined && 'isProduction',
         ].filter(notFalse);
         (0, utils_js_1.assertWarning)(opts.length === 0, `The options ${str(opts)} you passed to \`createPageRenderer()\` have no effect anymore: they are now automatically determined.`, { onlyOnce: true });
     }

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

@@ -19,7 +19,7 @@ function temp_disablePrerenderAutoRun() {
     globalObject.isDisabled = true;
 }
 function wasPrerenderRun() {
-    return globalObject.wasPrerenderRun;
+    return globalObject.wasPrerenderRun || false;
 }
 function setWasPrerenderRun(trigger) {
     globalObject.wasPrerenderRun = trigger;

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

@@ -11,10 +11,11 @@ function resolvePrerenderConfigGlobal(vikeConfig) {
     const prerenderSettings = prerenderConfigs.filter(isObject2);
     const prerenderConfigGlobal = {
         partial: pickFirst(prerenderSettings.map((c) => c.partial)) ?? false,
+        redirects: pickFirst(prerenderSettings.map((c) => c.redirects)) ?? null,
         noExtraDir: pickFirst(prerenderSettings.map((c) => c.noExtraDir)) ?? null,
         keepDistServer: pickFirst(prerenderSettings.map((c) => c.keepDistServer)) ?? false,
         parallel: pickFirst(prerenderSettings.map((c) => c.parallel)) ?? true,
-        disableAutoRun: pickFirst(prerenderSettings.map((c) => c.disableAutoRun)) ?? false
+        disableAutoRun: pickFirst(prerenderSettings.map((c) => c.disableAutoRun)) ?? false,
     };
     let defaultLocalValue = false;
     {
@@ -36,7 +37,7 @@ function resolvePrerenderConfigGlobal(vikeConfig) {
         isPrerenderingEnabledForAllPages: vikeConfig._pageConfigs.length > 0 &&
             vikeConfig._pageConfigs.every((pageConfig) => resolvePrerenderConfigLocal(pageConfig)?.value ?? defaultLocalValue),
         isPrerenderingEnabled: vikeConfig._pageConfigs.length > 0 &&
-            vikeConfig._pageConfigs.some((pageConfig) => resolvePrerenderConfigLocal(pageConfig)?.value ?? defaultLocalValue)
+            vikeConfig._pageConfigs.some((pageConfig) => resolvePrerenderConfigLocal(pageConfig)?.value ?? defaultLocalValue),
     });
     // TODO/next-major remove
     if (vikeConfig._pageConfigs.length === 0 && defaultLocalValue)

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

@@ -40,13 +40,13 @@ 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 path_1 = __importDefault(require("path"));
+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");
@@ -66,6 +66,7 @@ const resolvePrerenderConfig_js_1 = require("./resolvePrerenderConfig.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 docLink = 'https://vike.dev/i18n#pre-rendering';
 async function runPrerender(options = {}, trigger) {
     (0, context_js_1.setWasPrerenderRun)(trigger);
@@ -80,8 +81,7 @@ async function runPrerender(options = {}, trigger) {
     await disableReactStreaming();
     const viteConfig = await (0, vite_1.resolveConfig)(options.viteConfig || {}, 'build', 'production');
     const vikeConfig = await (0, resolveVikeConfigInternal_js_1.getVikeConfigInternal)();
-    const { outDirClient, outDirServer } = (0, getOutDirs_js_1.getOutDirs)(viteConfig);
-    const { root } = viteConfig;
+    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) {
@@ -96,7 +96,7 @@ async function runPrerender(options = {}, trigger) {
         */
         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);
@@ -105,7 +105,7 @@ async function runPrerender(options = {}, trigger) {
         output: [],
         _noExtraDir: noExtraDir,
         _pageContextInit: options.pageContextInit ?? null,
-        _prerenderedPageContexts: {}
+        _prerenderedPageContexts: {},
     };
     const doNotPrerenderList = [];
     await collectDoNoPrerenderList(vikeConfig._pageConfigs, doNotPrerenderList, defaultLocalValue, concurrencyLimit, globalContext);
@@ -126,12 +126,19 @@ async function runPrerender(options = {}, trigger) {
     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.`);
     }
@@ -214,7 +221,7 @@ async function callOnBeforePrerenderStartHooks(prerenderContext, globalContext,
             hookName: 'onBeforePrerenderStart',
             hookFilePath,
             pageId: pageConfig.pageId,
-            hookTimeout
+            hookTimeout,
         });
     })));
     // 0.4 design
@@ -239,7 +246,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 () => {
@@ -304,7 +311,7 @@ function getUrlList404(globalContext) {
         urlList.push({
             // A URL is required for `viteDevServer.transformIndexHtml(url,html)`
             urlOriginal: '/404',
-            pageId: errorPageId
+            pageId: errorPageId,
         });
     }
     return urlList;
@@ -322,10 +329,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, {
@@ -336,7 +343,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);
@@ -350,7 +357,7 @@ 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));
@@ -393,7 +400,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;
@@ -410,7 +417,7 @@ async function callOnPrerenderStartHook(prerenderContext, globalContext, concurr
             onPrerenderStartHook = {
                 ...hook,
                 // Make TypeScript happy
-                hookName
+                hookName,
             };
         }
     }
@@ -423,7 +430,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) {
@@ -444,7 +451,7 @@ async function callOnPrerenderStartHook(prerenderContext, globalContext, concurr
             hookFn: hook.onBeforePrerender,
             hookFilePath: hook.hookFilePath,
             hookName: 'onBeforePrerender',
-            hookTimeout
+            hookTimeout,
         };
     }
     if (!onPrerenderStartHook) {
@@ -462,7 +469,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);
@@ -493,8 +500,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']) &&
@@ -520,7 +527,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.
@@ -545,7 +552,6 @@ async function prerenderPages(prerenderContext, concurrencyLimit, onComplete) {
             pageContext,
             htmlString: documentHtml,
             pageContextSerialized,
-            doNotCreateExtraDirectory: prerenderContext._noExtraDir ?? pageContext.is404
         });
     })));
 }
@@ -574,23 +580,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 {
@@ -601,35 +608,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 + '/';
             }
@@ -679,7 +686,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,
         });
     });
 }
@@ -720,10 +727,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
@@ -734,3 +741,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

@@ -50,6 +50,6 @@ function runPrerender_forceExit() {
     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 })
+    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);