vike 0.4.247 → 0.4.249

package/dist/node/api/dev.d.ts

@@ -0,0 +1,21 @@
+export { dev };
+export { startupLog };
+import { type ResolvedConfig, type ViteDevServer } from 'vite';
+import type { ApiOptions } from './types.js';
+/**
+ * Programmatically trigger `$ vike dev`
+ *
+ * https://vike.dev/api#dev
+ */
+declare function dev(options?: ApiOptions & {
+    startupLog?: boolean;
+}): Promise<{
+    viteServer: ViteDevServer;
+    viteConfig: ResolvedConfig;
+    viteVersion: string;
+}>;
+declare function startupLog(resolvedUrls: ResolvedServerUrls, viteServer: ViteDevServer): Promise<void>;
+interface ResolvedServerUrls {
+    local: string[];
+    network: string[];
+}

package/dist/node/api/dev.js

@@ -0,0 +1,82 @@
+export { dev };
+// TO-DO/eventually: remove if it doesn't end up being used
+export { startupLog };
+import { prepareViteApiCall } from './prepareViteApiCall.js';
+import { createServer } from 'vite';
+import { assert, assertIsNotProductionRuntime, colorVike, colorVite, PROJECT_VERSION } from './utils.js';
+import pc from '@brillout/picocolors';
+import { processStartupLog } from '../vite/shared/loggerVite.js';
+assertIsNotProductionRuntime();
+/**
+ * Programmatically trigger `$ vike dev`
+ *
+ * https://vike.dev/api#dev
+ */
+async function dev(options = {}) {
+    const { viteConfigFromUserResolved } = await prepareViteApiCall(options, 'dev');
+    const server = await createServer(viteConfigFromUserResolved);
+    const viteServer = server;
+    const viteConfig = server.config;
+    const viteVersion = viteConfig._viteVersionResolved;
+    assert(viteVersion);
+    if (viteServer.httpServer)
+        await viteServer.listen();
+    if (options.startupLog) {
+        if (viteServer.resolvedUrls) {
+            startupLog(viteServer.resolvedUrls, viteServer);
+        }
+        else {
+            // TO-DO/eventually: remove if it doesn't end up being used
+            ;
+            viteConfig.server.startupLog = (resolvedUrls) => startupLog(resolvedUrls, viteServer);
+        }
+    }
+    return {
+        viteServer,
+        viteConfig,
+        viteVersion,
+    };
+}
+const startTime = performance.now();
+async function startupLog(resolvedUrls, viteServer) {
+    const viteConfig = viteServer.config;
+    const viteVersion = viteConfig._viteVersionResolved;
+    assert(viteVersion);
+    const startupDurationString = pc.dim(`ready in ${pc.reset(pc.bold(String(Math.ceil(performance.now() - startTime))))} ms`);
+    const sep = pc.dim('·');
+    const firstLine = `\n  ${colorVike('Vike')} ${pc.yellow(`v${PROJECT_VERSION}`)} ${sep} ${colorVite('Vite')} ${pc.cyan(`v${viteVersion}`)} ${sep} ${startupDurationString}\n`;
+    const ret = processStartupLog(firstLine, viteConfig);
+    console.log(ret.firstLine);
+    const { isCompact } = ret;
+    // We don't call viteServer.printUrls() because Vite throws an error if `resolvedUrls` is missing:
+    // https://github.com/vitejs/vite/blob/df5a30d2690a2ebc4824a79becdcef30538dc602/packages/vite/src/node/server/index.ts#L745
+    printServerUrls(resolvedUrls, viteConfig.server.host);
+    viteServer.bindCLIShortcuts({ print: true });
+    if (!isCompact)
+        console.log();
+}
+// Copied & adapted from Vite
+// https://github.com/vitejs/vite/blob/df5a30d2690a2ebc4824a79becdcef30538dc602/packages/vite/src/node/logger.ts#L168-L188
+function printServerUrls(urls, optionsHost) {
+    // [Begin] interop
+    const colors = pc;
+    const info = (msg) => console.log(msg);
+    // [End] interop
+    const colorUrl = (url) => colors.underline(removeTrailingSlash(url));
+    for (const url of urls.local) {
+        info(`  ${colors.green('➜')}  ${colors.bold('Local')}:   ${colorUrl(url)}`);
+    }
+    for (const url of urls.network) {
+        info(`  ${colors.green('➜')}  ${colors.bold('Network')}: ${colorUrl(url)}`);
+    }
+    if (urls.network.length === 0 && optionsHost === undefined) {
+        info(colors.dim(`  ${colors.green('➜')}  ${colors.bold('Network')}: use `) +
+            colors.bold('--host') +
+            colors.dim(' to expose'));
+    }
+}
+function removeTrailingSlash(url) {
+    if (url.endsWith('/'))
+        return url.slice(0, -1); // remove trailing slash
+    return url;
+}

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

@@ -0,0 +1,6 @@
+export { prepareViteApiCall };
+import type { ApiOptions, ApiOperation } from './types.js';
+declare function prepareViteApiCall(options: ApiOptions, operation: ApiOperation): Promise<{
+    viteConfigResolved: import("vite").ResolvedConfig;
+    viteConfigFromUserResolved: import("vite").UserConfig;
+}>;

package/dist/node/api/prepareViteApiCall.js

@@ -0,0 +1,14 @@
+export { prepareViteApiCall };
+import { clearContextVikeApiOperation, setContextVikeApiOperation } from '../../shared-server-node/api-context.js';
+import { clearGlobalContext } from '../../server/runtime/globalContext.js';
+import { resolveViteConfigFromUser } from './resolveViteConfigFromUser.js';
+async function prepareViteApiCall(options, operation) {
+    clear();
+    setContextVikeApiOperation(operation, options);
+    return resolveViteConfigFromUser();
+}
+// For subsequent API calls, e.g. calling prerender() after build()
+function clear() {
+    clearContextVikeApiOperation();
+    clearGlobalContext();
+}

package/dist/node/api/resolveViteConfigFromUser.d.ts

@@ -0,0 +1,17 @@
+export { resolveViteConfigFromUser };
+export { isOnlyResolvingUserConfig };
+export { getVikeConfigInternalEarly };
+export { getViteRoot };
+export { assertViteRoot };
+export { normalizeViteRoot };
+import type { ResolvedConfig, UserConfig } from 'vite';
+declare function resolveViteConfigFromUser(): Promise<{
+    viteConfigResolved: ResolvedConfig;
+    viteConfigFromUserResolved: UserConfig;
+}>;
+declare function getVikeConfigInternalEarly(): Promise<import("../vite/shared/resolveVikeConfigInternal.js").VikeConfigInternal>;
+declare function isOnlyResolvingUserConfig(): boolean | undefined;
+declare function getViteRoot(viteContext: ViteContext): Promise<string>;
+type ViteContext = 'build' | 'preview' | 'dev';
+declare function normalizeViteRoot(root: string): string;
+declare function assertViteRoot(rootResolvedEarly: string, config: ResolvedConfig): void;

package/dist/node/api/resolveViteConfigFromUser.js

@@ -0,0 +1,226 @@
+export { resolveViteConfigFromUser };
+export { isOnlyResolvingUserConfig };
+export { getVikeConfigInternalEarly };
+export { getViteRoot };
+export { assertViteRoot };
+export { normalizeViteRoot };
+import { loadConfigFromFile, mergeConfig, resolveConfig } from 'vite';
+import { getVikeConfigInternal, getVikeConfigFromCliOrEnv, setVikeConfigContext, isVikeConfigContextSet, } from '../vite/shared/resolveVikeConfigInternal.js';
+import path from 'node:path';
+import { assert, assertUsage, assertWarning, getGlobalObject, pick, toPosixPath } from './utils.js';
+import pc from '@brillout/picocolors';
+import { getEnvVarObject } from '../vite/shared/getEnvVarObject.js';
+import { getVikeApiOperation, isVikeCliOrApi } from '../../shared-server-node/api-context.js';
+import { getViteCommandFromCli } from '../vite/shared/isViteCli.js';
+const globalObject = getGlobalObject('api/prepareViteApiCall.ts', {});
+async function resolveViteConfigFromUser() {
+    const { viteContext } = getVikeApiContext();
+    assert(viteContext);
+    const viteInfo = await getViteInfo(viteContext);
+    const { viteConfigFromUserResolved } = viteInfo;
+    const { viteConfigResolved } = await assertViteRoot2(viteInfo.root, viteConfigFromUserResolved, viteContext);
+    return {
+        viteConfigResolved, // ONLY USE if strictly necessary. (We plan to remove assertViteRoot2() as explained in the comments of that function.)
+        viteConfigFromUserResolved,
+    };
+}
+async function getVikeConfigInternalEarly() {
+    assert(!globalObject.isOnlyResolvingUserConfig); // ensure no infinite loop
+    if (!isVikeConfigContextSet()) {
+        const viteContext = getViteContext();
+        const viteInfo = await getViteInfo(viteContext);
+        setVikeConfigContext_(viteInfo, viteContext);
+    }
+    return await getVikeConfigInternal();
+}
+function setVikeConfigContext_(viteInfo, viteContext) {
+    setVikeConfigContext({
+        userRootDir: viteInfo.root,
+        isDev: viteContext === 'dev',
+        vikeVitePluginOptions: viteInfo.vikeVitePluginOptions,
+    });
+}
+function isOnlyResolvingUserConfig() {
+    return globalObject.isOnlyResolvingUserConfig;
+}
+async function getViteRoot(viteContext) {
+    if (!globalObject.root)
+        await getViteInfo(viteContext);
+    assert(globalObject.root);
+    return globalObject.root;
+}
+async function getViteInfo(viteContext) {
+    const { viteConfigFromUserVikeApiOptions } = getVikeApiContext();
+    let viteConfigFromUserResolved = clone(viteConfigFromUserVikeApiOptions ?? {});
+    // Precedence:
+    // 1. (highest precedence)  |  viteConfigFromUserEnvVar          |  VITE_CONFIG
+    // 2.                       |  viteConfigFromUserVikeMode        |  VIKE_CONFIG & Vike CLI options — only `+mode`
+    // 2.                       |  viteConfigFromUserVikeApiOptions  |  Vike API options
+    // 3. (lowest precedence)   |  viteConfigFromUserViteFile        |  vite.config.js
+    // Resolve Vike's +mode setting
+    {
+        const viteConfigFromUserVikeMode = pick(getVikeConfigFromCliOrEnv().vikeConfigFromCliOrEnv, ['mode']);
+        if (Object.keys(viteConfigFromUserVikeMode).length > 0) {
+            viteConfigFromUserResolved = merge(viteConfigFromUserResolved ?? {}, viteConfigFromUserVikeMode);
+        }
+    }
+    // Resolve VITE_CONFIG
+    const viteConfigFromUserEnvVar = getEnvVarObject('VITE_CONFIG');
+    if (viteConfigFromUserEnvVar) {
+        viteConfigFromUserResolved = merge(viteConfigFromUserResolved ?? {}, viteConfigFromUserEnvVar);
+    }
+    // Resolve vite.config.js
+    globalObject.isOnlyResolvingUserConfig = true;
+    const viteConfigFromUserViteConfigFile = await loadViteConfigFile(viteConfigFromUserResolved, viteContext);
+    globalObject.isOnlyResolvingUserConfig = false;
+    // Correct precedence, replicates Vite:
+    // https://github.com/vitejs/vite/blob/4f5845a3182fc950eb9cd76d7161698383113b18/packages/vite/src/node/config.ts#L1001
+    const viteConfigResolved = merge(viteConfigFromUserViteConfigFile ?? {}, viteConfigFromUserResolved ?? {});
+    const root = normalizeViteRoot(viteConfigResolved.root ?? process.cwd());
+    globalObject.root = root;
+    // - Find options `vike(options)` set in vite.config.js
+    //   - TO-DO/next-major-release: remove
+    // - Add Vike's Vite plugin if missing
+    let vikeVitePluginOptions;
+    const found = findVikeVitePlugin(viteConfigResolved);
+    if (found) {
+        vikeVitePluginOptions = found.vikeVitePluginOptions;
+    }
+    else {
+        // Show a warning because Vike supports Vite's CLI (as well as third-party CLIs).
+        // - Encourage users to define a vite.config.js file that also works with Vite's CLI (and potentially other third-party CLIs).
+        // - Vike-based frameworks, such as DocPress, allow their users to omit defining a vite.config.js file.
+        assertWarning(!viteConfigFromUserViteConfigFile, // Only show the warning if the user defined a vite.config.js file
+        "Omitting Vike's Vite plugin (inside your vite.config.js) is deprecated — make sure to always add Vike's Vite plugin https://vike.dev/vite-plugin", { onlyOnce: true });
+        // 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('../vite/index.js');
+        viteConfigFromUserResolved = {
+            ...viteConfigFromUserResolved,
+            plugins: [...(viteConfigFromUserResolved?.plugins ?? []), vikePlugin()],
+        };
+        const res = findVikeVitePlugin(viteConfigFromUserResolved);
+        assert(res);
+        vikeVitePluginOptions = res.vikeVitePluginOptions;
+    }
+    assert(vikeVitePluginOptions);
+    return { root, vikeVitePluginOptions, viteConfigFromUserResolved };
+}
+/** `c2` overrides `c1` */
+function merge(c1, c2) {
+    return mergeConfig(c1, c2);
+}
+function clone(c) {
+    return mergeConfig({}, c);
+}
+function findVikeVitePlugin(viteConfig) {
+    let vikeVitePluginOptions;
+    let vikeVitePuginFound = false;
+    viteConfig?.plugins?.forEach((p) => {
+        if (p && '_vikeVitePluginOptions' in p) {
+            vikeVitePuginFound = true;
+            const options = p._vikeVitePluginOptions;
+            vikeVitePluginOptions ?? (vikeVitePluginOptions = {});
+            Object.assign(vikeVitePluginOptions, options);
+        }
+    });
+    if (!vikeVitePuginFound)
+        return null;
+    return { vikeVitePluginOptions };
+}
+// Copied from https://github.com/vitejs/vite/blob/4f5845a3182fc950eb9cd76d7161698383113b18/packages/vite/src/node/config.ts#L961-L1005
+async function loadViteConfigFile(viteConfigFromUserResolved, viteContext) {
+    const viteContextResolved = resolveViteContext(viteConfigFromUserResolved, viteContext);
+    const [inlineConfig, command, defaultMode, _defaultNodeEnv, isPreview] = viteContextResolved;
+    let config = inlineConfig;
+    let mode = inlineConfig.mode || defaultMode;
+    const configEnv = {
+        mode,
+        command,
+        isSsrBuild: command === 'build' && !!config.build?.ssr,
+        isPreview,
+    };
+    let { configFile } = config;
+    if (configFile !== false) {
+        const loadResult = await loadConfigFromFile(configEnv, configFile, config.root, config.logLevel, config.customLogger);
+        if (!loadResult)
+            return null;
+        assert(loadResult.config);
+        return loadResult.config;
+    }
+    return null;
+}
+function getViteContext() {
+    const vikeApiOperation = getVikeApiOperation();
+    const viteCommand = getViteCommandFromCli();
+    assert(!(viteCommand && vikeApiOperation));
+    if (vikeApiOperation)
+        return getViteContextWithOperation(vikeApiOperation.operation);
+    assert(!isVikeCliOrApi());
+    if (viteCommand === 'dev' || viteCommand === 'optimize') {
+        return 'dev';
+    }
+    if (viteCommand === 'build') {
+        return 'build';
+    }
+    if (viteCommand === 'preview') {
+        return 'preview';
+    }
+    // Third-party CLIs.
+    // - Component development (e.g. Storybook) => let's consider it development
+    // - Testing (e.g. Vitest) => let's consider it development
+    return 'dev';
+}
+function getViteContextWithOperation(operation) {
+    if (operation === 'build' || operation === 'prerender') {
+        return 'build';
+    }
+    if (operation === 'preview') {
+        return 'preview';
+    }
+    if (operation === 'dev') {
+        return 'dev';
+    }
+    assert(false);
+}
+function getVikeApiContext() {
+    const vikeApiOperation = getVikeApiOperation();
+    if (!vikeApiOperation)
+        return { viteConfigFromUserVikeApiOptions: null, viteContext: null };
+    const { options, operation } = vikeApiOperation;
+    const viteConfigFromUserVikeApiOptions = options.viteConfig;
+    const viteContext = getViteContextWithOperation(operation);
+    return { viteConfigFromUserVikeApiOptions, viteContext };
+}
+function resolveViteContext(inlineConfig = {}, viteContext) {
+    const isBuild = viteContext === 'build';
+    const isPreview = viteContext === 'preview';
+    const isDev = viteContext === 'dev';
+    const command = isBuild ? 'build' : 'serve';
+    const defaultMode = isDev ? 'development' : 'production';
+    const defaultNodeEnv = defaultMode;
+    const viteContextResolved = [inlineConfig, command, defaultMode, defaultNodeEnv, isPreview];
+    return viteContextResolved;
+}
+function normalizeViteRoot(root) {
+    // `path.resolve(viteConfigFromUserViteFile.configFile, root)` could be more intuitive than `path.resolve(process.cwd(), root)` but we replicate Vite's behavior (`vite.config.js` should follow Vite's API), see:
+    // https://github.com/vitejs/vite/blob/4f5845a3182fc950eb9cd76d7161698383113b18/packages/vite/src/node/config.ts#L1063
+    return toPosixPath(
+    // Equivalent to `path.resolve(process.cwd(), root)`
+    path.resolve(root));
+}
+const errMsg = `A Vite plugin is modifying the Vite setting ${pc.cyan('root')} which is forbidden`;
+async function assertViteRoot2(root, viteConfigFromUserResolved, viteContext) {
+    const viteContextResolved = resolveViteContext(viteConfigFromUserResolved, viteContext);
+    // We can eventually remove this resolveConfig() call (along with removing the whole assertViteRoot2() function which is redundant with the assertViteRoot() function) so that Vike doesn't make any resolveConfig() (except for pre-rendering and preview which is required). But let's keep it for now, just to see whether calling resolveConfig() can be problematic.
+    const viteConfigResolved = await resolveConfig(...viteContextResolved);
+    assertUsage(normalizeViteRoot(viteConfigResolved.root) === normalizeViteRoot(root), errMsg);
+    return { viteConfigResolved };
+}
+function assertViteRoot(rootResolvedEarly, config) {
+    const rootResolved = config.root;
+    const rootGlobal = globalObject.root;
+    if (rootGlobal)
+        assert(normalizeViteRoot(rootGlobal) === normalizeViteRoot(rootResolvedEarly));
+    assertUsage(normalizeViteRoot(rootResolvedEarly) === normalizeViteRoot(rootResolved), errMsg);
+}

package/dist/node/api/utils.d.ts

@@ -0,0 +1,11 @@
+export * from '../../utils/assert.js';
+export * from '../../utils/getGlobalObject.js';
+export * from '../../utils/path.js';
+export * from '../../utils/isObject.js';
+export * from '../../utils/assertVersion.js';
+export * from '../../utils/pick.js';
+export * from '../../utils/assertSetup.js';
+export * from '../../utils/isCallable.js';
+export * from '../../utils/colorsServer.js';
+export * from '../../utils/colorsClient.js';
+export * from '../../utils/PROJECT_VERSION.js';

package/dist/node/api/utils.js

@@ -0,0 +1,15 @@
+// Utils needed by Vike's API
+// We call onLoad() here so that it's called even when only a subset of the API is loaded. (Making the assert() calls inside onLoad() a lot stronger.)
+import { onLoad } from './onLoad.js';
+onLoad();
+export * from '../../utils/assert.js';
+export * from '../../utils/getGlobalObject.js';
+export * from '../../utils/path.js';
+export * from '../../utils/isObject.js';
+export * from '../../utils/assertVersion.js';
+export * from '../../utils/pick.js';
+export * from '../../utils/assertSetup.js';
+export * from '../../utils/isCallable.js';
+export * from '../../utils/colorsServer.js';
+export * from '../../utils/colorsClient.js';
+export * from '../../utils/PROJECT_VERSION.js';

package/dist/node/cli/entry.js

@@ -0,0 +1,67 @@
+import { dev, build, preview } from '../api/index.js';
+import pc from '@brillout/picocolors';
+import { parseCli } from './parseCli.js';
+import { setContextCliCommand } from './context.js';
+cli();
+async function cli() {
+    const { command, cliOptions } = parseCli();
+    setContextCliCommand(command, cliOptions);
+    if (command === 'dev') {
+        await cmdDev();
+    }
+    else if (command === 'build') {
+        await cmdBuild();
+    }
+    else if (command === 'preview') {
+        await cmdPreview();
+    }
+    else if (command === 'prerender') {
+        await cmdPrerender();
+    }
+}
+async function cmdDev() {
+    try {
+        await dev({ startupLog: true });
+    }
+    catch (err) {
+        console.error(pc.red(`Error while starting dev server:`));
+        // Error comes from Vite; no need to use addErrorHint()
+        console.error(err);
+        process.exit(1);
+    }
+}
+async function cmdBuild() {
+    try {
+        await build();
+    }
+    catch (err) {
+        console.error(pc.red(`Error during build:`));
+        // Error comes from Vite; no need to use addErrorHint()
+        console.error(err);
+        process.exit(1);
+    }
+    // See comments at runPrerender_forceExit()
+    process.exit(0);
+}
+async function cmdPreview() {
+    try {
+        const { viteServer } = await preview();
+        if (viteServer) {
+            viteServer.printUrls();
+            viteServer.bindCLIShortcuts({ print: true });
+        }
+    }
+    catch (err) {
+        console.error(pc.red(`Error while starting preview server:`));
+        // Error comes from Vite; no need to use addErrorHint()
+        console.error(err);
+        process.exit(1);
+    }
+}
+async function cmdPrerender() {
+    const { runPrerenderFromCLIPrerenderCommand } = await import('../prerender/runPrerenderEntry.js');
+    await runPrerenderFromCLIPrerenderCommand();
+}
+process.on('unhandledRejection', (rejectValue) => {
+    throw rejectValue;
+});

package/dist/node/createDevMiddleware.d.ts

@@ -0,0 +1,10 @@
+export { createDevMiddleware };
+import type { ResolvedConfig, Connect, ViteDevServer } from 'vite';
+import type { ApiOptions } from './api/types.js';
+declare function createDevMiddleware(options?: {
+    root?: string;
+} & ApiOptions): Promise<{
+    devMiddleware: Connect.Server;
+    viteServer: ViteDevServer;
+    viteConfig: ResolvedConfig;
+}>;

package/dist/node/createDevMiddleware.js

@@ -0,0 +1,25 @@
+export { createDevMiddleware };
+import { createServer } from 'vite';
+import { prepareViteApiCall } from './api/prepareViteApiCall.js';
+/*
+ * Create server middleware for development with HMR and lazy-transpiling.
+ *
+ * https://vike.dev/createDevMiddleware
+ */
+async function createDevMiddleware(options = {}) {
+    const optionsMod = {
+        ...options,
+        viteConfig: {
+            ...options.viteConfig,
+            root: options.root ?? options.viteConfig?.root,
+            server: {
+                ...options.viteConfig?.server,
+                middlewareMode: options.viteConfig?.server?.middlewareMode ?? true,
+            },
+        },
+    };
+    const { viteConfigFromUserResolved } = await prepareViteApiCall(optionsMod, 'dev');
+    const server = await createServer(viteConfigFromUserResolved);
+    const devMiddleware = server.middlewares;
+    return { devMiddleware, viteServer: server, viteConfig: server.config };
+}

package/dist/node/prerender/resolvePrerenderConfig.js

@@ -0,0 +1,64 @@
+export { resolvePrerenderConfigGlobal };
+export { resolvePrerenderConfigLocal };
+import { assert, assertUsage, isArray, isObject, objectAssign } from './utils.js';
+import { getConfigValueBuildTime } from '../../shared-server-client/page-configs/getConfigValueBuildTime.js';
+import { getConfigDefinedAt } from '../../shared-server-client/page-configs/getConfigDefinedAt.js';
+// When setting +prerender to an object => it also enables pre-rendering
+const defaultValueForObject = true;
+function resolvePrerenderConfigGlobal(vikeConfig) {
+    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,
+    };
+    let defaultLocalValue = false;
+    {
+        const valueFirst = prerenderConfigs.filter((p) => !isObject(p) || p.enable !== null)[0];
+        if (valueFirst === true || (isObject(valueFirst) && (valueFirst.enable ?? defaultValueForObject))) {
+            defaultLocalValue = true;
+        }
+    }
+    // TO-DO/next-major-release: remove
+    // Backwards compatibility for `vike({prerender:true})` in vite.config.js
+    {
+        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),
+    });
+    // TO-DO/next-major-release: remove
+    if (vikeConfig._pageConfigs.length === 0 && defaultLocalValue)
+        prerenderConfigGlobal.isPrerenderingEnabled = true;
+    return prerenderConfigGlobal;
+}
+function resolvePrerenderConfigLocal(pageConfig) {
+    const configValue = getConfigValueBuildTime(pageConfig, 'prerender');
+    if (!configValue)
+        return null;
+    const values = configValue.value;
+    assert(isArray(values));
+    const value = values[0];
+    assert(isArray(configValue.definedAtData));
+    const configDefinedAt = getConfigDefinedAt('Config', 'prerender', configValue.definedAtData);
+    assertUsage(typeof value === 'boolean', `${configDefinedAt} must be a boolean (it isn't defined at a global location)`);
+    const prerenderConfigLocal = { value };
+    return prerenderConfigLocal;
+}
+function isObject2(value) {
+    return typeof value === 'object' && value !== null;
+}
+function pickFirst(arr) {
+    return arr.filter((v) => v !== undefined)[0];
+}