vike 0.4.217-commit-99ea561 → 0.4.218-commit-01a099d

package/dist/esm/node/plugin/plugins/baseUrls.js

@@ -1,36 +1,42 @@
 export { baseUrls };
 import { resolveBase, resolveBaseFromResolvedConfig } from '../../shared/resolveBase.js';
 import { assert } from '../utils.js';
-import { getVikeConfig } from './importUserCode/v1-design/getVikeConfig.js';
+import { getVikeConfig, getVikeConfig2 } from './importUserCode/v1-design/getVikeConfig.js';
+import { assertViteRoot, getViteRoot, normalizeViteRoot } from '../../api/prepareViteApiCall.js';
 function baseUrls(vikeVitePluginOptions) {
-    let bases;
+    let basesResolved;
+    let root;
     return {
         name: 'vike:baseUrls',
         enforce: 'post',
-        async config(config) {
-            // TODO: fix bug: use getVikeConfig2() and udpate check below
-            bases = resolveBaseFromUserConfig(config, vikeVitePluginOptions);
-            const { baseServer, baseAssets } = bases;
+        async config(config, env) {
+            const isDev = config._isDev;
+            assert(typeof isDev === 'boolean');
+            const operation = env.command === 'build' ? 'build' : env.isPreview ? 'preview' : 'dev';
+            root = config.root ? normalizeViteRoot(config.root) : await getViteRoot(operation);
+            assert(root);
+            const baseViteOriginal = config.base ?? '/__UNSET__'; // '/__UNSET__' because Vite resolves `_baseViteOriginal: null` to `undefined`
+            const vikeConfig = await getVikeConfig2(root, isDev, vikeVitePluginOptions);
+            basesResolved = resolveBase(baseViteOriginal, vikeConfig.vikeConfigGlobal.baseServer, vikeConfig.vikeConfigGlobal.baseAssets);
             // We cannot define these in configResolved() because Vite picks up the env variables before any configResolved() hook is called
-            process.env.BASE_SERVER = baseServer;
-            process.env.BASE_ASSETS = baseAssets;
+            process.env.BASE_SERVER = basesResolved.baseServer;
+            process.env.BASE_ASSETS = basesResolved.baseAssets;
             return {
                 envPrefix: [
                     'VITE_', // Vite doesn't seem to merge in its default, see https://github.com/vikejs/vike/issues/554
                     'BASE_SERVER',
                     'BASE_ASSETS'
                 ],
-                base: baseAssets, // Make Vite inject baseAssets to imports e.g. `import logoUrl from './logo.svg.js'`
-                _baseViteOriginal: config.base ?? '/__UNSET__' // Vite resolves `_baseViteOriginal: null` to `undefined`
+                base: basesResolved.baseAssets, // Make Vite inject baseAssets to imports e.g. `import logoUrl from './logo.svg.js'`
+                _baseViteOriginal: baseViteOriginal
             };
         },
         async configResolved(config) {
+            assertViteRoot(root, config);
             const vikeConfig = await getVikeConfig(config);
-            const { baseServer, baseAssets } = vikeConfig.vikeConfigGlobal;
-            const basesResolved = resolveBaseFromResolvedConfig(baseServer, baseAssets, config);
-            // Ensure that the premature base URL resolving we did in config() isn't erroneous
-            assert(basesResolved.baseServer === bases.baseServer);
-            assert(basesResolved.baseAssets === bases.baseAssets);
+            const basesResolved2 = resolveBaseFromResolvedConfig(vikeConfig.vikeConfigGlobal.baseServer, vikeConfig.vikeConfigGlobal.baseAssets, config);
+            assert(basesResolved2.baseServer === basesResolved.baseServer);
+            assert(basesResolved2.baseAssets === basesResolved.baseAssets);
             /* In dev, Vite seems buggy around setting vite.config.js#base to an absolute URL (e.g. http://localhost:8080/cdn/)
              *  - In dev, Vite removes the URL origin. (I.e. it resolves the user config `vite.config.js#base: 'http://localhost:8080/cdn/'` to resolved config `config.base === '/cdn/'`.)
              *  - Instead of having an internal Vike assertion fail, we let the user discover Vite's buggy behavior.
@@ -39,7 +45,3 @@ function baseUrls(vikeVitePluginOptions) {
         }
     };
 }
-function resolveBaseFromUserConfig(config, vikeVitePluginOptions) {
-    const baseViteOriginal = config.base ?? null;
-    return resolveBase(baseViteOriginal, vikeVitePluginOptions?.baseServer ?? null, vikeVitePluginOptions?.baseAssets ?? null);
-}

package/dist/esm/node/plugin/plugins/buildConfig.js

@@ -11,7 +11,7 @@ import { createRequire } from 'module';
 import fs from 'fs/promises';
 import path from 'path';
 import { fixServerAssets, fixServerAssets_assertCssCodeSplit, fixServerAssets_assertCssTarget, fixServerAssets_assertCssTarget_populate, fixServerAssets_isEnabled } from './buildConfig/fixServerAssets.js';
-import { set_ASSETS_MAP } from './importBuild/index.js';
+import { set_ASSETS_MAP } from './buildEntry/index.js';
 import { prependEntriesDir } from '../../shared/prependEntriesDir.js';
 import { getFilePathResolved } from '../shared/getFilePath.js';
 import { getConfigValueBuildTime } from '../../../shared/page-configs/getConfigValueBuildTime.js';
@@ -117,7 +117,7 @@ async function getEntries(config) {
     if (viteIsSSR(config)) {
         const pageEntries = getPageEntries(pageConfigs);
         const entries = {
-            // importBuild: resolve('dist/esm/node/importBuild.js'), // TODO/next-major-release: remove
+            // buildEntry: resolve('dist/esm/node/buildEntry.js'), // TODO/next-major-release: remove
             ...pageFileEntries,
             // Ensure Rollup generates a bundle per page: https://github.com/vikejs/vike/issues/349#issuecomment-1166247275
             ...pageEntries

package/dist/esm/node/plugin/plugins/{importBuild → buildEntry}/getVikeManifest.d.ts

@@ -1,5 +1,5 @@
 export { getVikeManifest };
 import { type PluginManifest } from '../../../shared/assertPluginManifest.js';
-import type { VikeConfigGlobal } from '../importUserCode/v1-design/getVikeConfig/resolveVikeConfigGlobal.js';
+import type { VikeConfigGlobal } from '../importUserCode/v1-design/getVikeConfig.js';
 import type { ResolvedConfig } from 'vite';
 declare function getVikeManifest(vikeConfigGlobal: VikeConfigGlobal, viteConfig: ResolvedConfig): PluginManifest;

package/dist/esm/node/plugin/plugins/{importBuild → buildEntry}/index.d.ts

@@ -1,8 +1,8 @@
-export { importBuild };
+export { buildEntry };
 export { set_ASSETS_MAP };
 import type { Plugin, Rollup } from 'vite';
 type Bundle = Rollup.OutputBundle;
 type Options = Rollup.NormalizedOutputOptions;
-declare function importBuild(): Plugin[];
+declare function buildEntry(): Plugin[];
 /** Set the value of the ASSETS_MAP constant inside dist/server/entry.js (or dist/server/index.js) */
 declare function set_ASSETS_MAP(options: Options, bundle: Bundle): Promise<void>;

package/dist/esm/node/plugin/plugins/{importBuild → buildEntry}/index.js

@@ -1,23 +1,23 @@
-export { importBuild };
+export { buildEntry };
 export { set_ASSETS_MAP };
 import { serverProductionEntryPlugin } from '@brillout/vite-plugin-server-entry/plugin';
+import { virtualFileIdImportUserCodeServer } from '../../../shared/virtual-files/virtualFileImportUserCode.js';
+import { getVikeManifest } from './getVikeManifest.js';
+import { getVikeConfig } from '../importUserCode/v1-design/getVikeConfig.js';
 import { assert, getOutDirs, toPosixPath } from '../../utils.js';
+import fs from 'fs/promises';
 import path from 'path';
 import { createRequire } from 'module';
-import { getVikeManifest } from './getVikeManifest.js';
-import fs from 'fs/promises';
-import { virtualFileIdImportUserCodeServer } from '../../../shared/virtual-files/virtualFileImportUserCode.js';
-import { getVikeConfig } from '../importUserCode/v1-design/getVikeConfig.js';
 // @ts-ignore Shimmed by dist-cjs-fixup.js for CJS build.
 const importMetaUrl = import.meta.url;
 const require_ = createRequire(importMetaUrl);
 const ASSETS_MAP = '__VITE_ASSETS_MAP__';
-function importBuild() {
+function buildEntry() {
     let config;
     let vikeConfigGlobal;
     return [
         {
-            name: 'vike:importBuild:config',
+            name: 'vike:buildEntry',
             enforce: 'post',
             async configResolved(config_) {
                 config = config_;
@@ -38,17 +38,16 @@ function getServerProductionEntryCode(config, vikeConfigGlobal) {
     const vikeManifest = getVikeManifest(vikeConfigGlobal, config);
     // Let's eventually simplify and move everything to a single virtual module
     const importerCode = [
-        `  import { setImportBuildGetters } from '${importPath}';`,
+        `  import { setBuildEntry } from '${importPath}';`,
         `  import * as pageFiles from '${virtualFileIdImportUserCodeServer}';`,
         `  {`,
         // We first set the values to a variable because of a Rollup bug, and this workaround doesn't work: https://github.com/vikejs/vike/commit/d5f3a4f7aae5a8bc44192e6cbb2bcb9007be188d
         `    const assetsManifest = ${ASSETS_MAP};`,
         `    const pluginManifest = ${JSON.stringify(vikeManifest, null, 2)};`,
-        '    setImportBuildGetters({',
-        `      pageFiles: () => pageFiles,`,
-        `      getAssetsManifest: () => assetsManifest,`,
-        // TODO: rename pluginManifest -> vikeManifest
-        `      pluginManifest: () => pluginManifest,`,
+        '    setBuildEntry({',
+        `      pageFiles,`,
+        `      assetsManifest,`,
+        `      pluginManifest,`,
         '    });',
         `  }`,
         ''
@@ -85,12 +84,12 @@ function find_ASSETS_MAP(bundle) {
 function getImportPath(config) {
     // We resolve filePathAbsolute even if we don't use it: we use require.resolve() as an assertion that the relative path is correct
     const filePathAbsolute = toPosixPath(
-    // [RELATIVE_PATH_FROM_DIST] Current file: node_modules/vike/dist/esm/node/plugin/plugins/importBuild/index.js
-    require_.resolve(`../../../../../../dist/esm/node/runtime/globalContext/loadImportBuild.js`));
+    // [RELATIVE_PATH_FROM_DIST] Current file: node_modules/vike/dist/esm/node/plugin/plugins/buildEntry/index.js
+    require_.resolve(`../../../../../../dist/esm/__internal/index.js`));
     if (
-    // Let's implement a new config if a user needs the import to be a relative path instead of 'vike/__internal/loadImportBuild' (AFAIK a relative path is needed only if a framework has npm package 'vike' as direct dependency instead of a peer dependency and if the user of that framework uses pnpm)
+    // Let's implement a new config if a user needs the import to be a relative path instead of 'vike/__internal' (AFAIK a relative path is needed only if a framework has npm package 'vike' as direct dependency instead of a peer dependency and if the user of that framework uses pnpm)
     true) {
-        return 'vike/__internal/loadImportBuild';
+        return 'vike/__internal';
     }
     else {
         const { outDirServer } = getOutDirs(config);

package/dist/esm/node/plugin/plugins/commonConfig.d.ts

@@ -6,4 +6,4 @@ declare module 'vite' {
         _vikeVitePluginOptions?: unknown;
     }
 }
-declare function commonConfig(vikeVitePluginOptions?: unknown): Plugin[];
+declare function commonConfig(vikeVitePluginOptions: unknown): Plugin[];

package/dist/esm/node/plugin/plugins/commonConfig.js

@@ -6,11 +6,11 @@ import { installRequireShim_setUserRootDir } from '@brillout/require-shim';
 import pc from '@brillout/picocolors';
 import path from 'path';
 import { assertResolveAlias } from './commonConfig/assertResolveAlias.js';
-import { pluginName } from './commonConfig/pluginName.js';
 import { getEnvVarObject } from '../shared/getEnvVarObject.js';
 import { isViteCliCall } from '../shared/isViteCliCall.js';
 import { isVikeCliOrApi } from '../../api/context.js';
-function commonConfig(vikeVitePluginOptions = {}) {
+const pluginName = 'vike:commonConfig';
+function commonConfig(vikeVitePluginOptions) {
     return [
         {
             name: `${pluginName}:pre`,

package/dist/esm/node/plugin/plugins/importUserCode/getVirtualFileImportUserCode.d.ts

@@ -1,6 +1,6 @@
 export { getVirtualFileImportUserCode };
 import type { ResolvedConfig } from 'vite';
-import type { VikeConfigGlobal } from './v1-design/getVikeConfig/resolveVikeConfigGlobal.js';
+import type { VikeConfigGlobal } from './v1-design/getVikeConfig.js';
 declare function getVirtualFileImportUserCode(id: string, options: {
     ssr?: boolean;
 } | undefined, vikeConfigGlobal: VikeConfigGlobal, config: ResolvedConfig, isDev: boolean): Promise<string>;

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/configDefinitionsBuiltIn.js

@@ -143,9 +143,7 @@ const configDefinitionsBuiltInGlobal = {
         env: { server: true, client: 'if-client-routing' },
         eager: true
     },
-    prerender: {
-        env: { config: true }
-    },
+    prerender: { env: { config: true } },
     disableAutoFullBuild: { env: { config: true } },
     includeAssetsImportedByServer: { env: { config: true } },
     baseAssets: { env: { config: true } },

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/crawlPlusFiles.js

@@ -1,5 +1,5 @@
 export { crawlPlusFiles };
-import { assertPosixPath, assert, scriptFileExtensions, assertIsSingleModuleInstance, assertIsNotProductionRuntime, isVersionOrAbove, isScriptFile } from '../../../../utils.js';
+import { assertPosixPath, assert, scriptFileExtensions, assertIsSingleModuleInstance, assertIsNotProductionRuntime, isVersionOrAbove, isScriptFile, scriptFileExtensionList } from '../../../../utils.js';
 import path from 'path';
 import glob from 'fast-glob';
 import { exec } from 'child_process';
@@ -68,10 +68,8 @@ async function gitLsFiles(userRootDir, outDirRelativeFromUserRootDir) {
         'git',
         preserveUTF8,
         'ls-files',
-        // We don't filter because:
-        //  - It would skip symlink directories
-        //  - Performance gain seems negligible: https://github.com/vikejs/vike/pull/1688#issuecomment-2166206648
-        // ...scriptFileExtensionList.map((ext) => `"**/+*.${ext}"`),
+        // Performance gain seems negligible: https://github.com/vikejs/vike/pull/1688#issuecomment-2166206648
+        ...scriptFileExtensionList.map((ext) => `"**/+*.${ext}"`),
         // Performance gain is non-negligible.
         //  - https://github.com/vikejs/vike/pull/1688#issuecomment-2166206648
         //  - When node_modules/ is untracked the performance gain could be significant?
@@ -100,18 +98,18 @@ async function gitLsFiles(userRootDir, outDirRelativeFromUserRootDir) {
     }
     const files = [];
     for (const filePath of filesAll) {
-        // Deleted?
-        if (filesDeleted.includes(filePath))
+        // + file?
+        if (!path.posix.basename(filePath).startsWith('+'))
             continue;
         // We have to repeat the same exclusion logic here because the option --exclude of `$ git ls-files` only applies to untracked files. (We use --exclude only to speed up the `$ git ls-files` command.)
         if (!ignoreAsFilterFn(filePath))
             continue;
-        // + file?
-        if (!path.posix.basename(filePath).startsWith('+'))
-            continue;
         // JavaScript file?
         if (!isScriptFile(filePath))
             continue;
+        // Deleted?
+        if (filesDeleted.includes(filePath))
+            continue;
         files.push(filePath);
     }
     return files;

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig.d.ts

@@ -8,11 +8,13 @@ export { getConfigValueInterfaceFile };
 export type { VikeConfigObject };
 export type { InterfaceValueFile };
 export type { InterfaceFile };
+export type { VikeConfigGlobal };
+export type { VikeVitePluginOptions };
 import type { PageConfigGlobalBuildTime, PageConfigBuildTime } from '../../../../../shared/page-configs/PageConfig.js';
 import { type LocationId } from './getVikeConfig/filesystemRouting.js';
 import type { ResolvedConfig } from 'vite';
 import type { FilePathResolved } from '../../../../../shared/page-configs/FilePath.js';
-import type { VikeConfigGlobal } from './getVikeConfig/resolveVikeConfigGlobal.js';
+import { getPageConfigUserFriendlyNew } from '../../../../../shared/page-configs/getPageConfigUserFriendly.js';
 type InterfaceFile = InterfaceConfigFile | InterfaceValueFile;
 type InterfaceFileCommons = {
     locationId: LocationId;
@@ -37,6 +39,9 @@ type VikeConfigObject = {
     pageConfigs: PageConfigBuildTime[];
     pageConfigGlobal: PageConfigGlobalBuildTime;
     vikeConfigGlobal: VikeConfigGlobal;
+    vikeConfigNew: {
+        global: ReturnType<typeof getPageConfigUserFriendlyNew>;
+    };
 };
 declare const vikeConfigDependencies: Set<string>;
 declare function reloadVikeConfig(config: ResolvedConfig): void;
@@ -47,3 +52,96 @@ declare function getVikeConfig2(userRootDir: string, isDev: boolean, vikeVitePlu
 declare function isV1Design(config: ResolvedConfig): Promise<boolean>;
 declare function isVikeConfigFile(filePath: string): boolean;
 declare function getConfigValueInterfaceFile(interfaceFile: InterfaceFile, configName: string): unknown;
+type VikeConfigGlobal = {
+    prerender: false | {
+        noExtraDir: boolean;
+        parallel: boolean | number;
+        partial: boolean;
+        disableAutoRun: boolean;
+    };
+    disableAutoFullBuild: boolean | 'prerender' | null;
+    includeAssetsImportedByServer: boolean;
+    baseAssets: string | null;
+    baseServer: string | null;
+    redirects: Record<string, string>;
+    trailingSlash: boolean;
+    disableUrlNormalization: boolean;
+};
+type VikeVitePluginOptions = {
+    /**
+     * Enable pre-rendering.
+     *
+     * https://vike.dev/pre-rendering
+     *
+     * @default false
+     */
+    prerender?: boolean | {
+        /**
+         * Don't create a new directory for each HTML file.
+         *
+         * For example, generate `dist/client/about.html` instead of `dist/client/about/index.html`.
+         *
+         * @default false
+         */
+        noExtraDir?: boolean;
+        /**
+         * Number of concurrent pre-render jobs.
+         *
+         * Set to `false` to disable concurrency.
+         *
+         * @default os.cpus().length
+         */
+        parallel?: boolean | number;
+        /**
+     * Allow only some of your pages to be pre-rendered.
+     *
+     * This setting doesn't affect the pre-rendering process: it merely suppresses the warnings when some of your pages cannot be pre-rendered.
+ 
+     * @default false
+     */
+        partial?: boolean;
+        /**
+         * Disable the automatic initiation of the pre-rendering process when running `$ vike build`.
+         *
+         * Use this if you want to programmatically initiate the pre-rendering process instead.
+         *
+         * https://vike.dev/api#prerender
+         *
+         * @default false
+         */
+        disableAutoRun?: boolean;
+    };
+    /** @deprecated See https://vike.dev/disableAutoFullBuild */
+    disableAutoFullBuild?: boolean | 'prerender';
+    /** The Base URL of your server.
+     *
+     * https://vike.dev/base-url
+     */
+    baseServer?: string;
+    /** The Base URL of your static assets.
+     *
+     * https://vike.dev/base-url
+     */
+    baseAssets?: string;
+    /** @deprecated It's now `true` by default. You can remove this option. */
+    includeAssetsImportedByServer?: boolean;
+    /** Permanent redirections (HTTP status code 301)
+     *
+     * https://vike.dev/redirects
+     */
+    redirects?: Record<string, string>;
+    /** Whether URLs should end with a trailing slash.
+     *
+     * https://vike.dev/url-normalization
+     *
+     * @default false
+     */
+    trailingSlash?: boolean;
+    /** Disable automatic URL normalization.
+     *
+     * https://vike.dev/url-normalization
+     *
+     * @default false
+     */
+    disableUrlNormalization?: boolean;
+};

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig.js

@@ -23,7 +23,8 @@ import { clearFilesEnvMap, resolveConfigEnvWithFileName, resolvePointerImportOfC
 import { getFilePathResolved } from '../../../shared/getFilePath.js';
 import { getConfigValueBuildTime } from '../../../../../shared/page-configs/getConfigValueBuildTime.js';
 import { assertExtensionsPeerDependencies, assertExtensionsConventions } from './assertExtensions.js';
-import { resolveVikeConfigGlobal } from './getVikeConfig/resolveVikeConfigGlobal.js';
+import { getPageConfigUserFriendlyNew } from '../../../../../shared/page-configs/getPageConfigUserFriendly.js';
+import { getConfigValuesBase } from '../../../../../shared/page-configs/serialize/serializeConfigValues.js';
 assertIsNotProductionRuntime();
 let restartVite = false;
 let wasConfigInvalid = null;
@@ -239,7 +240,10 @@ async function loadVikeConfig_withErrorHandling(userRootDir, isDev, vikeVitePlug
                     configDefinitions: {},
                     configValueSources: {}
                 },
-                vikeConfigGlobal: resolveVikeConfigGlobal({}, {})
+                vikeConfigGlobal: resolveVikeConfigGlobal({}, {}),
+                vikeConfigNew: {
+                    global: getPageConfigUserFriendlyNew({ configValues: {} })
+                }
             };
             return dummyData;
         }
@@ -248,8 +252,7 @@ async function loadVikeConfig_withErrorHandling(userRootDir, isDev, vikeVitePlug
 async function loadVikeConfig(userRootDir, vikeVitePluginOptions) {
     const interfaceFilesByLocationId = await loadInterfaceFiles(userRootDir);
     const importedFilesLoaded = {};
-    const { pageConfigGlobal, pageConfigGlobalValues } = await getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importedFilesLoaded);
-    const vikeConfigGlobal = resolveVikeConfigGlobal(vikeVitePluginOptions, pageConfigGlobalValues);
+    const { pageConfigGlobal, vikeConfigGlobal } = await getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importedFilesLoaded, vikeVitePluginOptions);
     const pageConfigs = await Promise.all(objectEntries(interfaceFilesByLocationId)
         .filter(([_pageId, interfaceFiles]) => isDefiningPage(interfaceFiles))
         .map(async ([locationId]) => {
@@ -299,7 +302,37 @@ async function loadVikeConfig(userRootDir, vikeVitePluginOptions) {
         return pageConfig;
     }));
     assertPageConfigs(pageConfigs);
-    return { pageConfigs, pageConfigGlobal, vikeConfigGlobal };
+    const configValues = getConfigValues(pageConfigGlobal);
+    const global = getPageConfigUserFriendlyNew({ configValues });
+    return { pageConfigs, pageConfigGlobal, vikeConfigGlobal, vikeConfigNew: { global } };
+}
+function getConfigValues(pageConfig) {
+    const configValues = {};
+    getConfigValuesBase(pageConfig, (configEnv) => !!configEnv.config).forEach((entry) => {
+        if (entry.configValueBase.type === 'computed') {
+            assert('value' in entry); // Help TS
+            const { configValueBase, value, configName } = entry;
+            configValues[configName] = { ...configValueBase, value };
+        }
+        if (entry.configValueBase.type === 'standard') {
+            assert('sourceRelevant' in entry); // Help TS
+            const { configValueBase, sourceRelevant, configName } = entry;
+            assert('value' in sourceRelevant);
+            const { value } = sourceRelevant;
+            configValues[configName] = { ...configValueBase, value };
+        }
+        if (entry.configValueBase.type === 'cumulative') {
+            assert('sourcesRelevant' in entry); // Help TS
+            const { configValueBase, sourcesRelevant, configName } = entry;
+            const values = [];
+            sourcesRelevant.forEach((source) => {
+                assert('value' in source);
+                values.push(source.value);
+            });
+            configValues[configName] = { ...configValueBase, value: values };
+        }
+    });
+    return configValues;
 }
 // TODO/soon: refactor
 //  - Dedupe: most of the assertUsageGlobalConfigs() code below is a copy-paste of the assertUsage() logic inside getGlobalConfigs()
@@ -377,7 +410,7 @@ function getInterfaceFilesRelevant(interfaceFilesByLocationId, locationIdPage) {
         .sort(([locationId1], [locationId2]) => sortAfterInheritanceOrder(locationId1, locationId2, locationIdPage)));
     return interfaceFilesRelevant;
 }
-async function getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importedFilesLoaded) {
+async function getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importedFilesLoaded, vikeVitePluginOptions) {
     const locationIds = objectKeys(interfaceFilesByLocationId);
     const interfaceFilesGlobal = objectFromEntries(objectEntries(interfaceFilesByLocationId).filter(([locationId]) => {
         return isGlobalLocation(locationId, locationIds);
@@ -432,7 +465,31 @@ async function getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importe
             pageConfigGlobalValues[configName] = configValueSource.value;
         }
     }));
-    return { pageConfigGlobal, pageConfigGlobalValues };
+    const vikeConfigGlobal = resolveVikeConfigGlobal(vikeVitePluginOptions, pageConfigGlobalValues);
+    {
+        assert(isObject(vikeVitePluginOptions));
+        Object.entries(vikeVitePluginOptions).forEach(([configName, value]) => {
+            if (pageConfigGlobal.configValueSources[configName])
+                return;
+            pageConfigGlobal.configValueSources[configName] = [];
+            pageConfigGlobal.configValueSources[configName].push({
+                value,
+                configEnv: { config: true },
+                definedAtFilePath: {
+                    ...getFilePathResolved({
+                        userRootDir,
+                        filePathAbsoluteUserRootDir: '/vite.config.js'
+                    }),
+                    fileExportPathToShowToUser: null
+                },
+                locationId: '/',
+                isOverriden: false,
+                valueIsImportedAtRuntime: false,
+                valueIsDefinedByPlusFile: false
+            });
+        });
+    }
+    return { pageConfigGlobal, pageConfigGlobalValues, vikeConfigGlobal };
 }
 async function resolveConfigValueSources(configName, configDef, interfaceFilesRelevant, userRootDir, importedFilesLoaded) {
     const sourcesInfo = [];
@@ -1010,3 +1067,121 @@ function sortConfigValueSources(configValueSources, locationIdPage) {
 function getConfigValueInterfaceFile(interfaceFile, configName) {
     return interfaceFile.fileExportsByConfigName[configName]?.configValue;
 }
+// TODO: refactor code below
+function resolveVikeConfigGlobal(vikeVitePluginOptions, pageConfigGlobalValues) {
+    // TODO/v1-release: remove
+    assertVikeConfigGlobal(vikeVitePluginOptions, ({ prop, errMsg }) => `vite.config.js > vike option ${prop} ${errMsg}`);
+    const configs = [vikeVitePluginOptions];
+    assertVikeConfigGlobal(pageConfigGlobalValues, ({ prop, errMsg }) => {
+        // Can we add the config file path ?
+        return `config ${pc.cyan(prop)} ${errMsg}`;
+    });
+    configs.push(pageConfigGlobalValues);
+    const vikeConfigGlobal = {
+        disableAutoFullBuild: pickFirst(configs.map((c) => c.disableAutoFullBuild)) ?? null,
+        prerender: resolvePrerenderOptions(configs),
+        includeAssetsImportedByServer: pickFirst(configs.map((c) => c.includeAssetsImportedByServer)) ?? true,
+        baseServer: pickFirst(configs.map((c) => c.baseServer)) ?? null,
+        baseAssets: pickFirst(configs.map((c) => c.baseAssets)) ?? null,
+        redirects: merge(configs.map((c) => c.redirects)) ?? {},
+        disableUrlNormalization: pickFirst(configs.map((c) => c.disableUrlNormalization)) ?? false,
+        trailingSlash: pickFirst(configs.map((c) => c.trailingSlash)) ?? false
+    };
+    return vikeConfigGlobal;
+}
+function resolvePrerenderOptions(configs) {
+    if (!configs.some((c) => c.prerender)) {
+        return false;
+    }
+    const configsPrerender = configs.map((c) => c.prerender).filter(isObject2);
+    return {
+        partial: pickFirst(configsPrerender.map((c) => c.partial)) ?? false,
+        noExtraDir: pickFirst(configsPrerender.map((c) => c.noExtraDir)) ?? false,
+        parallel: pickFirst(configsPrerender.map((c) => c.parallel)) ?? true,
+        disableAutoRun: pickFirst(configsPrerender.map((c) => c.disableAutoRun)) ?? false
+    };
+}
+function isObject2(p) {
+    return typeof p === 'object';
+}
+function merge(objs) {
+    const obj = {};
+    objs.forEach((e) => {
+        Object.assign(obj, e);
+    });
+    return obj;
+}
+function pickFirst(arr) {
+    return arr.filter((v) => v !== undefined)[0];
+}
+function assertVikeConfigGlobal(vikeConfigGlobal, wrongUsageMsg) {
+    const wrongUsageError = check(vikeConfigGlobal);
+    if (wrongUsageError) {
+        assertUsage(false, wrongUsageMsg(wrongUsageError));
+    }
+}
+function check(vikeConfigGlobal) {
+    assert(isObject(vikeConfigGlobal));
+    {
+        const prop = 'disableUrlNormalization';
+        if (!hasProp(vikeConfigGlobal, prop, 'boolean') && !hasProp(vikeConfigGlobal, prop, 'undefined'))
+            return { prop, errMsg: 'should be a boolean' };
+    }
+    {
+        const prop = 'trailingSlash';
+        if (!hasProp(vikeConfigGlobal, prop, 'boolean') && !hasProp(vikeConfigGlobal, prop, 'undefined'))
+            return { prop, errMsg: 'should be a boolean' };
+    }
+    {
+        const prop = 'redirects';
+        const { redirects } = vikeConfigGlobal;
+        if (!(redirects === undefined ||
+            (isObject(redirects) && Object.values(redirects).every((v) => typeof v === 'string'))))
+            return { prop, errMsg: 'should be an object of strings' };
+    }
+    {
+        const prop = 'disableAutoFullBuild';
+        if (!hasProp(vikeConfigGlobal, prop, 'boolean') &&
+            !hasProp(vikeConfigGlobal, prop, 'undefined') &&
+            !(vikeConfigGlobal[prop] === 'prerender'))
+            return { prop, errMsg: "should be a boolean or 'prerender'" };
+    }
+    {
+        const prop = 'includeAssetsImportedByServer';
+        if (!hasProp(vikeConfigGlobal, prop, 'boolean') && !hasProp(vikeConfigGlobal, prop, 'undefined'))
+            return { prop, errMsg: 'should be a boolean' };
+    }
+    {
+        const prop = 'prerender';
+        if (!hasProp(vikeConfigGlobal, prop, 'object') &&
+            !hasProp(vikeConfigGlobal, prop, 'boolean') &&
+            !hasProp(vikeConfigGlobal, prop, 'undefined'))
+            return { prop, errMsg: 'should be an object or a boolean' };
+    }
+    const configVikePrerender = vikeConfigGlobal.prerender;
+    if (typeof configVikePrerender === 'object') {
+        {
+            const p = 'partial';
+            if (!hasProp(configVikePrerender, p, 'boolean') && !hasProp(configVikePrerender, p, 'undefined'))
+                return { prop: `prerender.${p}`, errMsg: 'should be a boolean' };
+        }
+        {
+            const p = 'noExtraDir';
+            if (!hasProp(configVikePrerender, p, 'boolean') && !hasProp(configVikePrerender, p, 'undefined'))
+                return { prop: `prerender.${p}`, errMsg: 'should be a boolean' };
+        }
+        {
+            const p = 'disableAutoRun';
+            if (!hasProp(configVikePrerender, p, 'boolean') && !hasProp(configVikePrerender, p, 'undefined'))
+                return { prop: `prerender.${p}`, errMsg: 'should be a boolean' };
+        }
+        {
+            const p = 'parallel';
+            if (!hasProp(configVikePrerender, p, 'boolean') &&
+                !hasProp(configVikePrerender, p, 'number') &&
+                !hasProp(configVikePrerender, p, 'undefined'))
+                return { prop: `prerender.${p}`, errMsg: 'should be a boolean or a number' };
+        }
+    }
+    return null;
+}

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVirtualFilePageConfigs.js

@@ -5,7 +5,8 @@ import { getVikeConfig } from './getVikeConfig.js';
 import { isRuntimeEnvMatch } from './isRuntimeEnvMatch.js';
 import { serializeConfigValues } from '../../../../../shared/page-configs/serialize/serializeConfigValues.js';
 async function getVirtualFilePageConfigs(isForClientSide, isDev, id, isClientRouting, config) {
-    const { pageConfigs, pageConfigGlobal } = await getVikeConfig(config, { doNotRestartViteOnError: true });
+    const vikeConfig = await getVikeConfig(config, { doNotRestartViteOnError: true });
+    const { pageConfigs, pageConfigGlobal } = vikeConfig;
     return getCode(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, isClientRouting);
 }
 function getCode(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, isClientRouting) {

package/dist/esm/node/plugin/plugins/setGlobalContext.js

@@ -33,7 +33,7 @@ function setGlobalContext() {
                 order: 'post',
                 async handler(config) {
                     const { outDirRoot } = getOutDirs(config);
-                    assertFilePathAbsoluteFilesystem(outDirRoot); // Needed for loadImportBuild(outDir) of @brillout/vite-plugin-server-entry
+                    assertFilePathAbsoluteFilesystem(outDirRoot); // Needed for `importServerProductionEntry({ outDir })` of @brillout/vite-plugin-server-entry
                     setGlobalContext_viteConfig(config, outDirRoot);
                     const vikeConfig = await getVikeConfig(config);
                     setGlobalContext_vikeConfig(vikeConfig);

package/dist/esm/node/plugin/plugins/workaroundVite6HmrRegression.d.ts

@@ -0,0 +1,3 @@
+export { workaroundVite6HmrRegression };
+import type { Plugin } from 'vite';
+declare function workaroundVite6HmrRegression(): Plugin;