vike 0.4.218 → 0.4.220-commit-a9f46b8

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

@@ -1,6 +1,6 @@
 export { commonConfig };
 import { mergeConfig } from 'vite';
-import { assert, assertUsage, assertWarning, findPackageJson, isDevCheck, isDocker } from '../utils.js';
+import { assert, assertUsage, assertWarning, findPackageJson, hasProp, isDevCheck, isDocker, isObject } from '../utils.js';
 import { assertRollupInput } from './buildConfig.js';
 import { installRequireShim_setUserRootDir } from '@brillout/require-shim';
 import pc from '@brillout/picocolors';
@@ -9,6 +9,9 @@ import { assertResolveAlias } from './commonConfig/assertResolveAlias.js';
 import { getEnvVarObject } from '../shared/getEnvVarObject.js';
 import { isViteCliCall } from '../shared/isViteCliCall.js';
 import { isVikeCliOrApi } from '../../api/context.js';
+import { getVikeConfig2 } from './importUserCode/v1-design/getVikeConfig.js';
+import { assertViteRoot, getViteRoot, normalizeViteRoot } from '../../api/prepareViteApiCall.js';
+import { temp_disablePrerenderAutoRun } from '../../prerender/context.js';
 const pluginName = 'vike:commonConfig';
 function commonConfig(vikeVitePluginOptions) {
     return [
@@ -17,10 +20,21 @@ function commonConfig(vikeVitePluginOptions) {
             enforce: 'pre',
             config: {
                 order: 'pre',
-                handler(_config, env) {
+                async handler(configFromUser, env) {
+                    const isDev = isDevCheck(env);
+                    const operation = env.command === 'build' ? 'build' : env.isPreview ? 'preview' : 'dev';
+                    const root = configFromUser.root ? normalizeViteRoot(configFromUser.root) : await getViteRoot(operation);
+                    assert(root);
+                    const vikeConfig = await getVikeConfig2(root, isDev, vikeVitePluginOptions);
                     return {
-                        _isDev: isDevCheck(env),
-                        _vikeVitePluginOptions: vikeVitePluginOptions
+                        _isDev: isDev,
+                        _root: root,
+                        _vikeVitePluginOptions: vikeVitePluginOptions,
+                        vike: { global: vikeConfig.global },
+                        // TODO/now: remove
+                        _vikeConfigGlobal: vikeConfig.vikeConfigGlobal,
+                        // TODO/v1-release: remove https://github.com/vikejs/vike/issues/2122
+                        configVikePromise: Promise.resolve({ prerender: !!vikeConfig.vikeConfigGlobal.prerender })
                     };
                 }
             }
@@ -28,6 +42,7 @@ function commonConfig(vikeVitePluginOptions) {
         {
             name: pluginName,
             configResolved(config) {
+                assertViteRoot(config._root, config);
                 assertSingleInstance(config);
                 installRequireShim_setUserRootDir(config.root);
             }
@@ -46,6 +61,7 @@ function commonConfig(vikeVitePluginOptions) {
                     assertResolveAlias(config);
                     assertEsm(config.root);
                     assertVikeCliOrApi(config);
+                    temp_supportOldInterface(config);
                 }
             },
             config: {
@@ -61,7 +77,7 @@ function commonConfig(vikeVitePluginOptions) {
                     // VITE_CONFIG
                     const configFromEnvVar = getEnvVarObject('VITE_CONFIG');
                     if (configFromEnvVar)
-                        configFromVike = mergeConfig(configFromEnvVar, configFromVike);
+                        configFromVike = mergeConfig(configFromVike, configFromEnvVar);
                     return configFromVike;
                 }
             }
@@ -128,3 +144,24 @@ function assertVikeCliOrApi(config) {
         onlyOnce: true
     });
 }
+// TODO/v1-release: remove https://github.com/vikejs/vike/issues/2122
+function temp_supportOldInterface(config) {
+    if (!('vitePluginSsr' in config))
+        return;
+    assert(isObject(config.vitePluginSsr));
+    if (hasProp(config.vitePluginSsr, 'prerender', 'object')) {
+        assert(hasProp(config.vitePluginSsr.prerender, 'disableAutoRun', 'boolean'));
+        if (config.vitePluginSsr.prerender.disableAutoRun) {
+            temp_disablePrerenderAutoRun();
+        }
+        return;
+    }
+    if (hasProp(config.vitePluginSsr, 'disableAutoFullBuild')) {
+        if (config.vitePluginSsr.disableAutoFullBuild) {
+            assert(config.vitePluginSsr.disableAutoFullBuild === 'prerender');
+            temp_disablePrerenderAutoRun();
+        }
+        return;
+    }
+    assert(false);
+}

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.d.ts

@@ -1,12 +1,10 @@
-export { configDefinitionsBuiltIn };
-export { configDefinitionsBuiltInGlobal };
+export { configDefinitionsBuiltInAll };
 export type { ConfigDefinition };
 export type { ConfigDefinitions };
 export type { ConfigDefinitionInternal };
-export type { ConfigNameGlobal };
 export type { ConfigEffect };
 import type { ConfigEnvInternal, ConfigEnv, ConfigValueSources, DefinedAtFilePath } from '../../../../../../shared/page-configs/PageConfig.js';
-import type { Config, ConfigNameBuiltIn } from '../../../../../../shared/page-configs/Config.js';
+import type { Config, ConfigNameBuiltIn, ConfigNameGlobal } from '../../../../../../shared/page-configs/Config.js';
 import { type ConfigDefinedAt } from '../../../../../../shared/page-configs/getConfigDefinedAt.js';
 /** The meta definition of a config.
  *
@@ -46,7 +44,8 @@ type ConfigDefinition = {
      *
      * https://vike.dev/extends#inheritance
      */
-    global?: boolean;
+    global?: boolean | ((value: unknown) => boolean);
+    type?: string | string[];
 };
 /**
  * Function called when the config value is defined.
@@ -74,7 +73,5 @@ type ConfigDefinitionInternal = Omit<ConfigDefinition, 'env'> & {
 };
 type ConfigDefinitions = Record<string, // configName
 ConfigDefinitionInternal>;
-type ConfigDefinitionsBuiltIn = Record<ConfigNameBuiltIn, ConfigDefinitionInternal>;
-declare const configDefinitionsBuiltIn: ConfigDefinitionsBuiltIn;
-type ConfigNameGlobal = 'onPrerenderStart' | 'onBeforeRoute' | 'prerender' | 'disableAutoFullBuild' | 'includeAssetsImportedByServer' | 'baseAssets' | 'baseServer' | 'redirects' | 'trailingSlash' | 'disableUrlNormalization';
-declare const configDefinitionsBuiltInGlobal: Record<ConfigNameGlobal, ConfigDefinitionInternal>;
+type ConfigDefinitionsBuiltIn = Record<ConfigNameBuiltIn | ConfigNameGlobal, ConfigDefinitionInternal>;
+declare const configDefinitionsBuiltInAll: ConfigDefinitionsBuiltIn;

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

@@ -1,8 +1,7 @@
-export { configDefinitionsBuiltIn };
-export { configDefinitionsBuiltInGlobal };
+export { configDefinitionsBuiltInAll };
 import { assert, assertUsage } from '../../../../utils.js';
 import { getConfigDefinedAt } from '../../../../../../shared/page-configs/getConfigDefinedAt.js';
-const configDefinitionsBuiltIn = {
+const configDefinitionsBuiltInAll = {
     onRenderHtml: {
         env: { server: true }
     },
@@ -61,9 +60,6 @@ const configDefinitionsBuiltIn = {
     clientHooks: {
         env: { config: true }
     },
-    prerender: {
-        env: { config: true }
-    },
     hydrationCanBeAborted: {
         env: { client: true }
     },
@@ -132,27 +128,34 @@ const configDefinitionsBuiltIn = {
         env: { client: true }
     },
     // TODO/eventually: define it as a global config.
-    middleware: { env: { server: true }, cumulative: true, eager: true }
-};
-const configDefinitionsBuiltInGlobal = {
+    middleware: { env: { server: true }, cumulative: true, eager: true },
     onPrerenderStart: {
         env: { server: true, production: true },
-        eager: true
+        eager: true,
+        global: true
     },
     onBeforeRoute: {
         env: { server: true, client: 'if-client-routing' },
-        eager: true
-    },
-    prerender: {
-        env: { config: true }
-    },
-    disableAutoFullBuild: { env: { config: true } },
-    includeAssetsImportedByServer: { env: { config: true } },
-    baseAssets: { env: { config: true } },
-    baseServer: { env: { config: true } },
-    redirects: { env: { server: true } },
-    trailingSlash: { env: { server: true } },
-    disableUrlNormalization: { env: { server: true } }
+        eager: true,
+        global: true
+    },
+    prerender: { env: { config: true }, global: (value) => typeof value !== 'object', type: ['boolean', 'object'] },
+    vite: { env: { config: true }, global: true, cumulative: true, type: 'object' },
+    disableAutoFullBuild: {
+        env: { config: true },
+        global: true,
+        type: [
+            'boolean',
+            // Can be 'prerender'
+            'string'
+        ]
+    },
+    includeAssetsImportedByServer: { env: { config: true }, global: true, type: 'boolean' },
+    baseAssets: { env: { config: true }, global: true, type: 'string' },
+    baseServer: { env: { config: true }, global: true, type: 'string' },
+    redirects: { env: { server: true }, global: true, type: 'string{}', cumulative: true },
+    trailingSlash: { env: { server: true }, global: true, type: 'boolean' },
+    disableUrlNormalization: { env: { server: true }, global: true, type: 'boolean' }
 };
 function getConfigEnv(configValueSources, configName) {
     const configValueSource = getConfigValueSource(configValueSources, configName);

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,7 @@ type VikeConfigObject = {
     pageConfigs: PageConfigBuildTime[];
     pageConfigGlobal: PageConfigGlobalBuildTime;
     vikeConfigGlobal: VikeConfigGlobal;
+    global: ReturnType<typeof getPageConfigUserFriendlyNew>;
 };
 declare const vikeConfigDependencies: Set<string>;
 declare function reloadVikeConfig(config: ResolvedConfig): void;
@@ -47,3 +50,95 @@ 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;
+    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

@@ -7,7 +7,7 @@ export { isV1Design };
 export { getConfigValueInterfaceFile };
 import { assertPosixPath, assert, isObject, assertUsage, assertWarning, objectEntries, hasProp, includes, assertIsNotProductionRuntime, getMostSimilar, joinEnglish, lowerFirst, assertKeys, objectKeys, objectFromEntries, makeFirst, isNpmPackageImport, reverse } from '../../../utils.js';
 import path from 'path';
-import { configDefinitionsBuiltIn, configDefinitionsBuiltInGlobal } from './getVikeConfig/configDefinitionsBuiltIn.js';
+import { configDefinitionsBuiltInAll } from './getVikeConfig/configDefinitionsBuiltIn.js';
 import { getLocationId, getFilesystemRouteString, getFilesystemRouteDefinedBy, isInherited, sortAfterInheritanceOrder, isGlobalLocation, applyFilesystemRoutingRootEffect } from './getVikeConfig/filesystemRouting.js';
 import { isTemporaryBuildFile } from './getVikeConfig/transpileAndExecuteFile.js';
 import { isConfigInvalid, isConfigInvalid_set } from '../../../../runtime/renderPage/isConfigInvalid.js';
@@ -23,7 +23,10 @@ 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';
+const configDefinitionsBuiltIn = getConfigDefinitionsBuiltIn();
+const configDefinitionsBuiltInGlobal = getConfigDefinitionsBuiltInGlobal();
 assertIsNotProductionRuntime();
 let restartVite = false;
 let wasConfigInvalid = null;
@@ -239,7 +242,8 @@ async function loadVikeConfig_withErrorHandling(userRootDir, isDev, vikeVitePlug
                     configDefinitions: {},
                     configValueSources: {}
                 },
-                vikeConfigGlobal: resolveVikeConfigGlobal({}, {})
+                vikeConfigGlobal: resolveVikeConfigGlobal({}, {}),
+                global: getPageConfigUserFriendlyNew({ configValues: {} })
             };
             return dummyData;
         }
@@ -248,8 +252,97 @@ 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 [globalConfigs, pageConfigs] = await Promise.all([
+        getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importedFilesLoaded, vikeVitePluginOptions),
+        getPageConfigs(interfaceFilesByLocationId, userRootDir, importedFilesLoaded)
+    ]);
+    return { pageConfigs, ...globalConfigs };
+}
+async function getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importedFilesLoaded, vikeVitePluginOptions) {
+    const locationIds = objectKeys(interfaceFilesByLocationId);
+    const interfaceFilesGlobal = objectFromEntries(objectEntries(interfaceFilesByLocationId).filter(([locationId]) => {
+        return isGlobalLocation(locationId, locationIds);
+    }));
+    // Validate that global configs live in global interface files
+    {
+        const interfaceFilesGlobalPaths = [];
+        objectEntries(interfaceFilesGlobal).forEach(([locationId, interfaceFiles]) => {
+            assert(isGlobalLocation(locationId, locationIds));
+            interfaceFiles.forEach(({ filePath: { filePathAbsoluteUserRootDir } }) => {
+                if (filePathAbsoluteUserRootDir) {
+                    interfaceFilesGlobalPaths.push(filePathAbsoluteUserRootDir);
+                }
+            });
+        });
+        const globalPaths = Array.from(new Set(interfaceFilesGlobalPaths.map((p) => path.posix.dirname(p))));
+        objectEntries(interfaceFilesByLocationId).forEach(([locationId, interfaceFiles]) => {
+            interfaceFiles.forEach((interfaceFile) => {
+                Object.keys(interfaceFile.fileExportsByConfigName).forEach((configName) => {
+                    if (!isGlobalLocation(locationId, locationIds) && isGlobalConfig(configName)) {
+                        assertUsage(false, [
+                            `${interfaceFile.filePath.filePathToShowToUser} defines the config ${pc.cyan(configName)} which is global:`,
+                            globalPaths.length
+                                ? `define ${pc.cyan(configName)} in ${joinEnglish(globalPaths, 'or')} instead`
+                                : `create a global config (e.g. /pages/+config.js) and define ${pc.cyan(configName)} there instead`
+                        ].join(' '));
+                    }
+                });
+            });
+        });
+    }
+    const pageConfigGlobalValues = {};
+    const pageConfigGlobal = {
+        configDefinitions: configDefinitionsBuiltInGlobal,
+        configValueSources: {}
+    };
+    await Promise.all(objectEntries(configDefinitionsBuiltInGlobal).map(async ([configName, configDef]) => {
+        const sources = await resolveConfigValueSources(configName, configDef, interfaceFilesGlobal, userRootDir, importedFilesLoaded);
+        const configValueSource = sources[0];
+        if (!configValueSource)
+            return;
+        pageConfigGlobal.configValueSources[configName] = sources;
+        // TODO/now
+        if (configName === 'onBeforeRoute' || configName === 'onPrerenderStart') {
+            assert(!('value' in configValueSource));
+        }
+        else {
+            assert('value' in configValueSource);
+            // TODO/now
+            if (configName === 'prerender' && typeof configValueSource.value === 'boolean')
+                return;
+            pageConfigGlobalValues[configName] = configValueSource.value;
+        }
+    }));
     const vikeConfigGlobal = resolveVikeConfigGlobal(vikeVitePluginOptions, pageConfigGlobalValues);
+    {
+        assert(isObject(vikeVitePluginOptions));
+        Object.entries(vikeVitePluginOptions).forEach(([configName, value]) => {
+            var _a;
+            assert(includes(objectKeys(configDefinitionsBuiltInGlobal), configName));
+            const configDef = configDefinitionsBuiltInGlobal[configName];
+            const sources = ((_a = pageConfigGlobal.configValueSources)[configName] ?? (_a[configName] = []));
+            sources.push({
+                value,
+                configEnv: configDef.env,
+                definedAtFilePath: {
+                    ...getFilePathResolved({
+                        userRootDir,
+                        filePathAbsoluteUserRootDir: '/vite.config.js'
+                    }),
+                    fileExportPathToShowToUser: null
+                },
+                locationId: '/',
+                isOverriden: configDef.cumulative ? false : sources.length > 0,
+                valueIsImportedAtRuntime: false,
+                valueIsDefinedByPlusFile: false
+            });
+        });
+    }
+    const configValues = getConfigValues(pageConfigGlobal);
+    const global = getPageConfigUserFriendlyNew({ configValues });
+    return { pageConfigGlobal, vikeConfigGlobal, global };
+}
+async function getPageConfigs(interfaceFilesByLocationId, userRootDir, importedFilesLoaded) {
     const pageConfigs = await Promise.all(objectEntries(interfaceFilesByLocationId)
         .filter(([_pageId, interfaceFiles]) => isDefiningPage(interfaceFiles))
         .map(async ([locationId]) => {
@@ -299,9 +392,37 @@ async function loadVikeConfig(userRootDir, vikeVitePluginOptions) {
         return pageConfig;
     }));
     assertPageConfigs(pageConfigs);
-    return { pageConfigs, pageConfigGlobal, vikeConfigGlobal };
+    return pageConfigs;
 }
-// TODO/soon: refactor
+function getConfigValues(pageConfig) {
+    const configValues = {};
+    getConfigValuesBase(pageConfig, (configEnv) => !!configEnv.config, null).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/now: refactor
 //  - Dedupe: most of the assertUsageGlobalConfigs() code below is a copy-paste of the assertUsage() logic inside getGlobalConfigs()
 //    - This assertUsage() message is slightly better: use this one for getGlobalConfigs()
 // Global configs should be defined at global locations
@@ -318,7 +439,7 @@ function assertUsageGlobalConfigs(interfaceFilesRelevantList, configDefinitions,
             if (isGlobalConfig(configName))
                 return;
             const configDef = getConfigDefinition(configDefinitions, configName, interfaceFile.filePath.filePathToShowToUser);
-            if (configDef.global) {
+            if (configDef.global === true) {
                 const locationIds = objectKeys(interfaceFilesByLocationId);
                 if (!isGlobalLocation(interfaceFile.locationId, locationIds)) {
                     const interfaceFilesGlobal = objectFromEntries(objectEntries(interfaceFilesByLocationId).filter(([locationId]) => {
@@ -377,63 +498,6 @@ function getInterfaceFilesRelevant(interfaceFilesByLocationId, locationIdPage) {
         .sort(([locationId1], [locationId2]) => sortAfterInheritanceOrder(locationId1, locationId2, locationIdPage)));
     return interfaceFilesRelevant;
 }
-async function getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importedFilesLoaded) {
-    const locationIds = objectKeys(interfaceFilesByLocationId);
-    const interfaceFilesGlobal = objectFromEntries(objectEntries(interfaceFilesByLocationId).filter(([locationId]) => {
-        return isGlobalLocation(locationId, locationIds);
-    }));
-    // Validate that global configs live in global interface files
-    {
-        const interfaceFilesGlobalPaths = [];
-        objectEntries(interfaceFilesGlobal).forEach(([locationId, interfaceFiles]) => {
-            assert(isGlobalLocation(locationId, locationIds));
-            interfaceFiles.forEach(({ filePath: { filePathAbsoluteUserRootDir } }) => {
-                if (filePathAbsoluteUserRootDir) {
-                    interfaceFilesGlobalPaths.push(filePathAbsoluteUserRootDir);
-                }
-            });
-        });
-        const globalPaths = Array.from(new Set(interfaceFilesGlobalPaths.map((p) => path.posix.dirname(p))));
-        objectEntries(interfaceFilesByLocationId).forEach(([locationId, interfaceFiles]) => {
-            interfaceFiles.forEach((interfaceFile) => {
-                Object.keys(interfaceFile.fileExportsByConfigName).forEach((configName) => {
-                    if (!isGlobalLocation(locationId, locationIds) && isGlobalConfig(configName)) {
-                        assertUsage(false, [
-                            `${interfaceFile.filePath.filePathToShowToUser} defines the config ${pc.cyan(configName)} which is global:`,
-                            globalPaths.length
-                                ? `define ${pc.cyan(configName)} in ${joinEnglish(globalPaths, 'or')} instead`
-                                : `create a global config (e.g. /pages/+config.js) and define ${pc.cyan(configName)} there instead`
-                        ].join(' '));
-                    }
-                });
-            });
-        });
-    }
-    const pageConfigGlobalValues = {};
-    const pageConfigGlobal = {
-        configDefinitions: configDefinitionsBuiltInGlobal,
-        configValueSources: {}
-    };
-    await Promise.all(objectEntries(configDefinitionsBuiltInGlobal).map(async ([configName, configDef]) => {
-        const sources = await resolveConfigValueSources(configName, configDef, interfaceFilesGlobal, userRootDir, importedFilesLoaded);
-        const configValueSource = sources[0];
-        if (!configValueSource)
-            return;
-        if (configName === 'onBeforeRoute' || configName === 'onPrerenderStart') {
-            assert(!('value' in configValueSource));
-            pageConfigGlobal.configValueSources[configName] = [configValueSource];
-        }
-        else {
-            assert('value' in configValueSource);
-            if (configName === 'prerender' && typeof configValueSource.value === 'boolean')
-                return;
-            const { filePathToShowToUser } = configValueSource.definedAtFilePath;
-            assertWarning(false, `Being able to define config ${pc.cyan(configName)} in ${filePathToShowToUser} is experimental and will likely be removed. Define the config ${pc.cyan(configName)} in Vike's Vite plugin options instead.`, { onlyOnce: true });
-            pageConfigGlobalValues[configName] = configValueSource.value;
-        }
-    }));
-    return { pageConfigGlobal, pageConfigGlobalValues };
-}
 async function resolveConfigValueSources(configName, configDef, interfaceFilesRelevant, userRootDir, importedFilesLoaded) {
     const sourcesInfo = [];
     // interfaceFilesRelevant is sorted by sortAfterInheritanceOrder()
@@ -976,6 +1040,7 @@ function isLoadableAtBuildTime(configDef) {
     return !!configDef.env.config && !configDef._valueIsFilePath;
 }
 function isGlobalConfig(configName) {
+    // TODO/now
     if (configName === 'prerender')
         return false;
     const configNamesGlobal = getConfigNamesGlobal();
@@ -984,6 +1049,12 @@ function isGlobalConfig(configName) {
 function getConfigNamesGlobal() {
     return Object.keys(configDefinitionsBuiltInGlobal);
 }
+function getConfigDefinitionsBuiltInGlobal() {
+    return objectFromEntries(objectEntries(configDefinitionsBuiltInAll).filter(([_configName, configDef]) => configDef.global !== undefined));
+}
+function getConfigDefinitionsBuiltIn() {
+    return objectFromEntries(objectEntries(configDefinitionsBuiltInAll).filter(([_configName, configDef]) => configDef.global !== true));
+}
 function assertConfigExists(configName, configNamesRelevant, filePathToShowToUser) {
     const configNames = [...configNamesRelevant, ...getConfigNamesGlobal()];
     if (configNames.includes(configName))
@@ -1010,3 +1081,35 @@ function sortConfigValueSources(configValueSources, locationIdPage) {
 function getConfigValueInterfaceFile(interfaceFile, configName) {
     return interfaceFile.fileExportsByConfigName[configName]?.configValue;
 }
+// TODO/now: refactor code below
+function resolveVikeConfigGlobal(vikeVitePluginOptions, pageConfigGlobalValues) {
+    const configs = [vikeVitePluginOptions, 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,
+        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 pickFirst(arr) {
+    return arr.filter((v) => v !== undefined)[0];
+}

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

@@ -31,7 +31,7 @@ function getLoadConfigValuesAll(pageConfig, isForClientSide, pageId, includeAsse
     const importStatements = [];
     const isClientRouting = getConfigValueBuildTime(pageConfig, 'clientRouting', 'boolean')?.value ?? false;
     lines.push('export const configValuesSerialized = {');
-    lines.push(...serializeConfigValues(pageConfig, importStatements, (configEnv) => isRuntimeEnvMatch(configEnv, { isForClientSide, isClientRouting, isDev }), { isEager: false }, ''));
+    lines.push(...serializeConfigValues(pageConfig, importStatements, (configEnv) => isRuntimeEnvMatch(configEnv, { isForClientSide, isClientRouting, isDev }), '', false));
     lines.push('};');
     if (!fixServerAssets_isEnabled() && includeAssetsImportedByServer && isForClientSide && !isDev) {
         importStatements.push(`import '${extractAssetsAddQuery(getVirtualFileIdPageConfigValuesAll(pageId, false))}'`);