vike 0.4.231 → 0.4.232-commit-ec54a7e

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

@@ -2,7 +2,7 @@ export { build };
 import { prepareViteApiCall } from './prepareViteApiCall.js';
 import { build as buildVite, version, createBuilder } from 'vite';
 import { isVikeCli } from '../cli/context.js';
-import { isPrerendering } from '../prerender/context.js';
+import { wasPrerenderRun } from '../prerender/context.js';
 import { assert, assertVersion } from './utils.js';
 /**
  * Programmatically trigger `$ vike build`
@@ -14,7 +14,7 @@ async function build(options = {}) {
     // Pass it to pluginAutoFullBuild()
     if (viteConfigFromUserEnhanced)
         viteConfigFromUserEnhanced._viteConfigFromUserEnhanced = viteConfigFromUserEnhanced;
-    if (vikeConfig.global.config.vite6BuilderApp) {
+    if (vikeConfig.config.vite6BuilderApp) {
         // This assertion isn't reliable: the user may still use a Vite version older than 6.0.0 — see https://github.com/vitejs/vite/pull/19355
         assertVersion('Vite', version, '6.0.0');
         const builder = await createBuilder(viteConfigFromUserEnhanced);
@@ -32,8 +32,13 @@ async function build(options = {}) {
         //    > Rationale: https://github.com/vikejs/vike/issues/2123
         await buildVite(viteConfigFromUserEnhanced);
         // After pre-rendering, when using the Vike CLI, the process is forcefully exited at the end of the buildVite() call above.
-        if (isVikeCli() && isPrerendering())
+        if (
+        // When calling Vike's prerender() API pre-rendering is run without force exit
+        ![false, 'prerender()'].includes(wasPrerenderRun()) &&
+            // When calling Vike's build() API pre-rendering is auto run without force exit
+            isVikeCli()) {
             assert(false);
+        }
     }
     return {
     /* We don't return `viteConfig` because `viteConfigFromUserEnhanced` is `InlineConfig` not `ResolvedConfig`

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

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

package/dist/esm/node/api/prepareViteApiCall.d.ts

@@ -4,9 +4,9 @@ export { assertViteRoot };
 export { normalizeViteRoot };
 import type { InlineConfig, ResolvedConfig } from 'vite';
 import type { APIOptions, Operation } from './types.js';
-import { type VikeConfigObject } from '../plugin/plugins/importUserCode/v1-design/getVikeConfig.js';
+import { type VikeConfigInternal } from '../vite/shared/resolveVikeConfigInternal.js';
 declare function prepareViteApiCall(options: APIOptions, operation: Operation): Promise<{
-    vikeConfig: VikeConfigObject;
+    vikeConfig: VikeConfigInternal;
     viteConfigResolved: ResolvedConfig;
     viteConfigFromUserEnhanced: InlineConfig | undefined;
 }>;

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

@@ -4,12 +4,12 @@ export { assertViteRoot };
 export { normalizeViteRoot };
 import { loadConfigFromFile, mergeConfig, resolveConfig } from 'vite';
 import { clearContextApiOperation, setContextApiOperation } from './context.js';
-import { getVikeConfig2, getVikeConfigFromCliOrEnv } from '../plugin/plugins/importUserCode/v1-design/getVikeConfig.js';
-import path from 'path';
+import { getVikeConfigInternal, getVikeConfigFromCliOrEnv, setVikeConfigContext, } from '../vite/shared/resolveVikeConfigInternal.js';
+import path from 'node:path';
 import { assert, assertUsage, getGlobalObject, isObject, pick, toPosixPath } from './utils.js';
 import pc from '@brillout/picocolors';
 import { clearGlobalContext } from '../runtime/globalContext.js';
-import { getEnvVarObject } from '../plugin/shared/getEnvVarObject.js';
+import { getEnvVarObject } from '../vite/shared/getEnvVarObject.js';
 const globalObject = getGlobalObject('api/prepareViteApiCall.ts', {});
 async function prepareViteApiCall(options, operation) {
     clear();
@@ -24,19 +24,24 @@ function clear() {
 }
 async function resolveConfigs(viteConfigFromUserApiOptions, operation) {
     const viteInfo = await getViteInfo(viteConfigFromUserApiOptions, operation);
-    const vikeConfig = await getVikeConfig2(viteInfo.root, operation === 'dev', viteInfo.vikeVitePluginOptions);
+    setVikeConfigContext({
+        userRootDir: viteInfo.root,
+        isDev: operation === 'dev',
+        vikeVitePluginOptions: viteInfo.vikeVitePluginOptions,
+    });
+    const vikeConfig = await getVikeConfigInternal();
     const viteConfigFromUserEnhanced = applyVikeViteConfig(viteInfo.viteConfigFromUserEnhanced, vikeConfig);
     const { viteConfigResolved } = await assertViteRoot2(viteInfo.root, viteConfigFromUserEnhanced, 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
 // - For example, Vike extensions adding Vite plugins
 function applyVikeViteConfig(viteConfigFromUserEnhanced, vikeConfig) {
-    const viteConfigs = vikeConfig.global._from.configsCumulative.vite;
+    const viteConfigs = vikeConfig._from.configsCumulative.vite;
     if (!viteConfigs)
         return viteConfigFromUserEnhanced;
     viteConfigs.values.forEach((v) => {
@@ -55,10 +60,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 = pick(getVikeConfigFromCliOrEnv().vikeConfigFromCliOrEnv, ['mode']);
@@ -89,10 +94,10 @@ async function getViteInfo(viteConfigFromUserApiOptions, operation) {
     else {
         // Add Vike to plugins if not present.
         // Using a dynamic import because the script calling the Vike API may not live in the same place as vite.config.js, thus vike/plugin may resolved to two different node_modules/vike directories.
-        const { plugin: vikePlugin } = await import('../plugin/index.js');
+        const { plugin: vikePlugin } = await import('../vite/index.js');
         viteConfigFromUserEnhanced = {
             ...viteConfigFromUserEnhanced,
-            plugins: [...(viteConfigFromUserEnhanced?.plugins ?? []), vikePlugin()]
+            plugins: [...(viteConfigFromUserEnhanced?.plugins ?? []), vikePlugin()],
         };
         const res = findVikeVitePlugin(viteConfigFromUserEnhanced);
         assert(res);
@@ -105,9 +110,9 @@ function findVikeVitePlugin(viteConfig) {
     let vikeVitePluginOptions;
     let vikeVitePuginFound = false;
     viteConfig?.plugins?.forEach((p) => {
-        if (p && '__vikeVitePluginOptions' in p) {
+        if (p && '_vikeVitePluginOptions' in p) {
             vikeVitePuginFound = true;
-            const options = p.__vikeVitePluginOptions;
+            const options = p._vikeVitePluginOptions;
             vikeVitePluginOptions ?? (vikeVitePluginOptions = {});
             Object.assign(vikeVitePluginOptions, options);
         }
@@ -125,7 +130,7 @@ async function loadViteConfigFile(viteConfigFromUserApiOptions, operation) {
         mode,
         command,
         isSsrBuild: command === 'build' && !!config.build?.ssr,
-        isPreview
+        isPreview,
     };
     let { configFile } = config;
     if (configFile !== false) {

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

@@ -1,5 +1,5 @@
 export { prerender };
-import { type PrerenderOptions } from '../prerender/runPrerender.js';
+import type { PrerenderOptions } from '../prerender/runPrerender.js';
 import type { ResolvedConfig } from 'vite';
 /**
  * Programmatically trigger `$ vike prerender`

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

@@ -1,5 +1,5 @@
 export { prerender };
-import { runPrerenderFromAPI } from '../prerender/runPrerender.js';
+import { runPrerenderFromAPI } from '../prerender/runPrerenderEntry.js';
 import { prepareViteApiCall } from './prepareViteApiCall.js';
 /**
  * Programmatically trigger `$ vike prerender`
@@ -11,6 +11,6 @@ async function prerender(options = {}) {
     options.viteConfig = viteConfigFromUserEnhanced;
     const { viteConfig } = await runPrerenderFromAPI(options);
     return {
-        viteConfig
+        viteConfig,
     };
 }

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

@@ -2,7 +2,7 @@ export { preview };
 import { prepareViteApiCall } from './prepareViteApiCall.js';
 import { preview as previewVite } from 'vite';
 import { importServerProductionIndex } from '@brillout/vite-plugin-server-entry/runtime';
-import { getOutDirs } from '../plugin/shared/getOutDirs.js';
+import { getOutDirs } from '../vite/shared/getOutDirs.js';
 import { assertWarning } from './utils.js';
 import pc from '@brillout/picocolors';
 import path from 'node:path';
@@ -21,14 +21,14 @@ async function preview(options = {}) {
         const outServerIndexRelative = path.relative(viteConfigResolved.root, outServerIndex);
         assertWarning(false, `Never run ${pc.cyan('$ vike preview')} in production, run ${pc.cyan(`$ node ${outServerIndexRelative}`)} instead (or Bun/Deno).`, { onlyOnce: true });
         return {
-            viteConfig: viteConfigResolved
+            viteConfig: viteConfigResolved,
         };
     }
     else {
         const server = await previewVite(viteConfigFromUserEnhanced);
         return {
             viteServer: server,
-            viteConfig: server.config
+            viteConfig: server.config,
         };
     }
 }

package/dist/esm/node/api/types.d.ts

@@ -1,7 +1,7 @@
 export type { APIOptions };
 export type { Operation };
 import type { InlineConfig } from 'vite';
-import type { Config } from '../../shared/page-configs/Config.js';
+import type { Config } from '../../types/Config.js';
 type APIOptions = {
     /**
      * Vite config.

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

@@ -30,7 +30,7 @@ async function cmdDev() {
             const startupDurationString = pc.dim(`ready in ${pc.reset(pc.bold(String(Math.ceil(performance.now() - startTime))))} ms`);
             const hasExistingLogs = process.stdout.bytesWritten > 0 || process.stderr.bytesWritten > 0;
             info(`  ${pc.yellow(`${pc.bold('Vike')} v${PROJECT_VERSION}`)}  ${startupDurationString}\n`, {
-                clear: !hasExistingLogs
+                clear: !hasExistingLogs,
             });
             viteServer.printUrls();
         }
@@ -75,7 +75,7 @@ async function cmdPreview() {
     }
 }
 async function cmdPrerender() {
-    const { runPrerenderFromCLIPrerenderCommand } = await import('../prerender/runPrerender.js');
+    const { runPrerenderFromCLIPrerenderCommand } = await import('../prerender/runPrerenderEntry.js');
     await runPrerenderFromCLIPrerenderCommand();
 }
 process.on('unhandledRejection', (rejectValue) => {

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

@@ -1,12 +1,12 @@
 export { parseCli };
 import pc from '@brillout/picocolors';
 import { assert, includes, PROJECT_VERSION } from './utils.js';
-import { parseJson5 } from '../plugin/shared/getEnvVarObject.js';
+import { parseJson5 } from '../vite/shared/getEnvVarObject.js';
 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();
@@ -67,7 +67,7 @@ function showHelp() {
         `More Vike settings can be passed over the ${pc.cyan('VIKE_CONFIG')} environment variable or as ${pc.cyan('CLI options')}.`,
         `More Vite settings can be passed over the ${pc.cyan('VITE_CONFIG')} environment variable.`,
         ``,
-        `See ${pc.underline('https://vike.dev/cli')} for more information.`
+        `See ${pc.underline('https://vike.dev/cli')} for more information.`,
     ].join('\n'));
     process.exit(1);
 }

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

@@ -11,6 +11,6 @@ const onPopState = (() => { });
 function warnNoEffect(caller) {
     assertWarning(false, `Calling ${caller}() on the server-side has no effect`, {
         showStackTrace: true,
-        onlyOnce: false
+        onlyOnce: false,
     });
 }

package/dist/esm/node/createPageRenderer.js

@@ -17,7 +17,7 @@ function showWarnings(options) {
             viteDevServer !== undefined && 'viteDevServer',
             root !== undefined && 'root',
             outDir !== undefined && 'outDir',
-            isProduction !== undefined && 'isProduction'
+            isProduction !== undefined && 'isProduction',
         ].filter(notFalse);
         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/esm/node/prerender/context.d.ts

@@ -1,9 +1,10 @@
 export { isPrerenderAutoRunEnabled };
 export { temp_disablePrerenderAutoRun };
-export { isPrerendering };
-export { setContextIsPrerendering };
-import type { VikeConfigObject } from '../plugin/plugins/importUserCode/v1-design/getVikeConfig.js';
-declare function isPrerenderAutoRunEnabled(vikeConfig: VikeConfigObject): boolean;
+export { wasPrerenderRun };
+export { setWasPrerenderRun };
+import type { VikeConfigInternal } from '../vite/shared/resolveVikeConfigInternal.js';
+import type { PrerenderTrigger } from './runPrerender.js';
+declare function isPrerenderAutoRunEnabled(vikeConfig: VikeConfigInternal): boolean;
 declare function temp_disablePrerenderAutoRun(): void;
-declare function isPrerendering(): boolean;
-declare function setContextIsPrerendering(): void;
+declare function wasPrerenderRun(): false | PrerenderTrigger;
+declare function setWasPrerenderRun(trigger: PrerenderTrigger): void;

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

@@ -1,7 +1,7 @@
 export { isPrerenderAutoRunEnabled };
 export { temp_disablePrerenderAutoRun };
-export { isPrerendering };
-export { setContextIsPrerendering };
+export { wasPrerenderRun };
+export { setWasPrerenderRun };
 import { getGlobalObject } from '../../utils/getGlobalObject.js';
 import { resolvePrerenderConfigGlobal } from './resolvePrerenderConfig.js';
 const globalObject = getGlobalObject('prerender/context.ts', {});
@@ -10,15 +10,15 @@ function isPrerenderAutoRunEnabled(vikeConfig) {
     return (prerenderConfigGlobal.isPrerenderingEnabled &&
         !(prerenderConfigGlobal || {}).disableAutoRun &&
         !globalObject.isDisabled &&
-        vikeConfig.global.config.disableAutoFullBuild !== 'prerender');
+        vikeConfig.config.disableAutoFullBuild !== 'prerender');
 }
 // TODO/v1-release: remove
 function temp_disablePrerenderAutoRun() {
     globalObject.isDisabled = true;
 }
-function isPrerendering() {
-    return !!globalObject.isPrerendering;
+function wasPrerenderRun() {
+    return globalObject.wasPrerenderRun || false;
 }
-function setContextIsPrerendering() {
-    globalObject.isPrerendering = true;
+function setWasPrerenderRun(trigger) {
+    globalObject.wasPrerenderRun = trigger;
 }

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

@@ -1,9 +1,10 @@
 export { resolvePrerenderConfigGlobal };
 export { resolvePrerenderConfigLocal };
-import { VikeConfigObject } from '../plugin/plugins/importUserCode/v1-design/getVikeConfig.js';
-import type { PageConfigBuildTime } from '../../shared/page-configs/PageConfig.js';
-declare function resolvePrerenderConfigGlobal(vikeConfig: VikeConfigObject): {
+import { VikeConfigInternal } from '../vite/shared/resolveVikeConfigInternal.js';
+import type { PageConfigBuildTime } from '../../types/PageConfig.js';
+declare function resolvePrerenderConfigGlobal(vikeConfig: Pick<VikeConfigInternal, 'config' | '_pageConfigs' | '_from'>): {
     partial: boolean;
+    redirects: boolean | null;
     noExtraDir: boolean | null;
     keepDistServer: boolean;
     parallel: number | boolean;

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

@@ -5,14 +5,15 @@ import { getConfigValueBuildTime } from '../../shared/page-configs/getConfigValu
 // When setting +prerender to an object => it also enables pre-rendering
 const defaultValueForObject = true;
 function resolvePrerenderConfigGlobal(vikeConfig) {
-    const prerenderConfigs = vikeConfig.global.config.prerender || [];
+    const prerenderConfigs = vikeConfig.config.prerender || [];
     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;
     {
@@ -24,20 +25,20 @@ function resolvePrerenderConfigGlobal(vikeConfig) {
     // TODO/next-major: remove
     // Backwards compatibility for `vike({prerender:true})` in vite.config.js
     {
-        const valuesWithDefinedAt = vikeConfig.global._from.configsCumulative.prerender?.values ?? [];
+        const valuesWithDefinedAt = vikeConfig._from.configsCumulative.prerender?.values ?? [];
         if (valuesWithDefinedAt.some((v) => v.definedAt.includes('vite.config.js') && v.value)) {
             defaultLocalValue = true;
         }
     }
     objectAssign(prerenderConfigGlobal, {
         defaultLocalValue,
-        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)
+        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),
     });
     // TODO/next-major remove
-    if (vikeConfig.pageConfigs.length === 0 && defaultLocalValue)
+    if (vikeConfig._pageConfigs.length === 0 && defaultLocalValue)
         prerenderConfigGlobal.isPrerenderingEnabled = true;
     return prerenderConfigGlobal;
 }