vike 0.4.220-commit-a9f46b8 → 0.4.220-commit-9a798ce

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

@@ -14,17 +14,16 @@ import { isVikeCli } from '../../cli/context.js';
 let forceExit = false;
 function autoFullBuild() {
     let config;
-    let vikeConfigGlobal;
+    let vikeConfig;
     return [
         {
             name: 'vike:autoFullBuild',
             apply: 'build',
             enforce: 'pre',
             async configResolved(config_) {
-                const vikeConfig = await getVikeConfig(config_);
-                vikeConfigGlobal = vikeConfig.vikeConfigGlobal;
+                vikeConfig = await getVikeConfig(config_);
                 config = config_;
-                abortViteBuildSsr(vikeConfigGlobal);
+                abortViteBuildSsr(vikeConfig);
             },
             writeBundle: {
                 /* We can't use this because it breaks Vite's logging. TODO: try again with latest Vite version.
@@ -33,7 +32,7 @@ function autoFullBuild() {
                 */
                 async handler(_options, bundle) {
                     try {
-                        await triggerFullBuild(config, vikeConfigGlobal, bundle);
+                        await triggerFullBuild(config, vikeConfig, bundle);
                     }
                     catch (err) {
                         // Avoid Rollup prefixing the error with [vike:autoFullBuild], for example see https://github.com/vikejs/vike/issues/472#issuecomment-1276274203
@@ -59,10 +58,10 @@ function autoFullBuild() {
         }
     ];
 }
-async function triggerFullBuild(config, vikeConfigGlobal, bundle) {
+async function triggerFullBuild(config, vikeConfig, bundle) {
     if (config.build.ssr)
         return; // already triggered
-    if (isDisabled(vikeConfigGlobal))
+    if (isDisabled(vikeConfig))
         return;
     // Workaround for @vitejs/plugin-legacy
     //  - The legacy plugin triggers its own Rollup build for the client-side.
@@ -93,7 +92,7 @@ async function triggerFullBuild(config, vikeConfigGlobal, bundle) {
         logErrorHint(err);
         process.exit(1);
     }
-    if (isPrerenderAutoRunEnabled(vikeConfigGlobal)) {
+    if (isPrerenderAutoRunEnabled(vikeConfig)) {
         const { prerenderContextPublic } = await runPrerenderFromAutoRun(configInline);
         config.vike.prerenderContext = prerenderContextPublic;
         forceExit = isVikeCli() || isViteCliCall();
@@ -108,15 +107,15 @@ function setSSR(configInline) {
         }
     };
 }
-function abortViteBuildSsr(vikeConfigGlobal) {
-    if (vikeConfigGlobal.disableAutoFullBuild !== true && isViteCliCall() && getViteConfigFromCli()?.build.ssr) {
+function abortViteBuildSsr(vikeConfig) {
+    if (vikeConfig.global.config.disableAutoFullBuild !== true && isViteCliCall() && getViteConfigFromCli()?.build.ssr) {
         assertWarning(false, `The CLI call ${pc.cyan('$ vite build --ssr')} is superfluous since ${pc.cyan('$ vite build')} also builds the server-side. If you want two separate build steps then use https://vike.dev/disableAutoFullBuild or use Vite's ${pc.cyan('build()')} API.`, { onlyOnce: true });
         process.exit(0);
     }
 }
-function isDisabled(vikeConfigGlobal) {
-    const { disableAutoFullBuild } = vikeConfigGlobal;
-    if (disableAutoFullBuild === null || disableAutoFullBuild === 'prerender') {
+function isDisabled(vikeConfig) {
+    const { disableAutoFullBuild } = vikeConfig.global.config;
+    if (disableAutoFullBuild === undefined || disableAutoFullBuild === 'prerender') {
         const isViteApi = !isViteCliCall() && !isVikeCliOrApi();
         return isViteApi;
     }

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

@@ -11,7 +11,7 @@ function baseUrls() {
             const isDev = config._isDev;
             assert(typeof isDev === 'boolean');
             const baseViteOriginal = config.base ?? '/__UNSET__'; // '/__UNSET__' because Vite resolves `_baseViteOriginal: null` to `undefined`
-            basesResolved = resolveBase(baseViteOriginal, config._vikeConfigGlobal.baseServer, config._vikeConfigGlobal.baseAssets);
+            basesResolved = resolveBase(baseViteOriginal, config.vike.global.config.baseServer ?? null, config.vike.global.config.baseAssets ?? null);
             // We cannot define these in configResolved() because Vite picks up the env variables before any configResolved() hook is called
             process.env.BASE_SERVER = basesResolved.baseServer;
             process.env.BASE_ASSETS = basesResolved.baseAssets;
@@ -27,7 +27,7 @@ function baseUrls() {
         },
         async configResolved(config) {
             const vikeConfig = await getVikeConfig(config);
-            const basesResolved2 = resolveBaseFromResolvedConfig(vikeConfig.vikeConfigGlobal.baseServer, vikeConfig.vikeConfigGlobal.baseAssets, config);
+            const basesResolved2 = resolveBaseFromResolvedConfig(vikeConfig.global.config.baseServer ?? null, vikeConfig.global.config.baseAssets ?? null, 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/)

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 './buildEntry/index.js';
+import { set_ASSETS_MANIFEST } from './buildEntry/index.js';
 import { prependEntriesDir } from '../../shared/prependEntriesDir.js';
 import { getFilePathResolved } from '../shared/getFilePath.js';
 import { getConfigValueBuildTime } from '../../../shared/page-configs/getConfigValueBuildTime.js';
@@ -79,7 +79,7 @@ function buildConfig() {
             name: 'vike:buildConfig:pre',
             apply: 'build',
             // Make sure other writeBundle() hooks are called after this writeBundle() hook.
-            //  - set_ASSETS_MAP() needs to be called before dist/server/ code is executed.
+            //  - set_ASSETS_MANIFEST() needs to be called before dist/server/ code is executed.
             //    - For example, the writeBundle() hook of vite-plugin-vercel needs to be called after this writeBundle() hook, otherwise: https://github.com/vikejs/vike/issues/1527
             enforce: 'pre',
             writeBundle: {
@@ -102,7 +102,7 @@ function buildConfig() {
                         }
                         await fs.rm(clientManifestFilePath);
                         await fs.rm(serverManifestFilePath);
-                        await set_ASSETS_MAP(options, bundle);
+                        await set_ASSETS_MANIFEST(options, bundle);
                     }
                 }
             }
@@ -112,7 +112,10 @@ function buildConfig() {
 async function getEntries(config) {
     const vikeConfig = await getVikeConfig(config);
     const { pageConfigs } = vikeConfig;
-    const pageFileEntries = await getPageFileEntries(config, vikeConfig.vikeConfigGlobal.includeAssetsImportedByServer); // TODO/v1-release: remove
+    // TODO/v1-release: remove
+    const pageFileEntries = await getPageFileEntries(config, 
+    // TODO/now: add meta.default
+    vikeConfig.global.config.includeAssetsImportedByServer ?? true);
     assertUsage(Object.keys(pageFileEntries).length !== 0 || pageConfigs.length !== 0, 'At least one page should be defined, see https://vike.dev/add');
     if (viteIsSSR(config)) {
         const pageEntries = getPageEntries(pageConfigs);

package/dist/esm/node/plugin/plugins/buildEntry/index.d.ts

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

package/dist/esm/node/plugin/plugins/buildEntry/index.js

@@ -1,79 +1,82 @@
 export { buildEntry };
-export { set_ASSETS_MAP };
+export { set_ASSETS_MANIFEST };
 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 { assert, getOutDirs, projectInfo, toPosixPath } from '../../utils.js';
 import fs from 'fs/promises';
 import path from 'path';
 import { createRequire } from 'module';
 // @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__';
+import { isUsingClientRouter } from '../extractExportNamesPlugin.js';
+import { assertBuildInfo, getViteConfigRuntime } from '../../../runtime/globalContext.js';
+const ASSETS_MANIFEST = '__VITE_ASSETS_MANIFEST__';
 function buildEntry() {
     let config;
-    let vikeConfigGlobal;
     return [
         {
             name: 'vike:buildEntry',
             enforce: 'post',
             async configResolved(config_) {
                 config = config_;
-                const vikeConfig = await getVikeConfig(config);
-                vikeConfigGlobal = vikeConfig.vikeConfigGlobal;
             }
         },
         ...serverProductionEntryPlugin({
             getServerProductionEntry: () => {
-                return getServerProductionEntryCode(config, vikeConfigGlobal);
+                return getServerProductionEntryCode(config);
             },
             libraryName: 'Vike'
         })
     ];
 }
-function getServerProductionEntryCode(config, vikeConfigGlobal) {
+function getServerProductionEntryCode(config) {
     const importPath = getImportPath(config);
-    const vikeManifest = getVikeManifest(vikeConfigGlobal, config);
-    // Let's eventually simplify and move everything to a single virtual module
+    const buildInfo = {
+        versionAtBuildTime: projectInfo.projectVersion,
+        usesClientRouter: isUsingClientRouter(), // TODO/v1-release: remove
+        viteConfigRuntime: getViteConfigRuntime(config)
+    };
+    assertBuildInfo(buildInfo);
+    // After the old design is removed, let's maybe simplify and move everything into a single virtual module
     const importerCode = [
         `  import { setGlobalContext_buildEntry } 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)};`,
+        // Because of a Rollup bug, we have to assign ASSETS_MANIFEST to a variable before passing it to setGlobalContext_buildEntry()
+        // - This workaround doesn't work: https://github.com/vikejs/vike/commit/d5f3a4f7aae5a8bc44192e6cbb2bcb9007be188d
+        `    const assetsManifest = ${ASSETS_MANIFEST};`,
+        `    const buildInfo = ${JSON.stringify(buildInfo, null, 2)};`,
         '    setGlobalContext_buildEntry({',
         `      pageFiles,`,
         `      assetsManifest,`,
-        `      pluginManifest,`,
+        `      buildInfo,`,
         '    });',
         `  }`,
         ''
     ].join('\n');
     return importerCode;
 }
-/** Set the value of the ASSETS_MAP constant inside dist/server/entry.js (or dist/server/index.js) */
-async function set_ASSETS_MAP(options, bundle) {
+/** Set the value of the ASSETS_MANIFEST constant inside dist/server/entry.js (or dist/server/index.js) */
+async function set_ASSETS_MANIFEST(options, bundle) {
     const { dir } = options;
     assert(dir);
-    const chunkPath = find_ASSETS_MAP(bundle);
+    const chunkPath = find_ASSETS_MANIFEST(bundle);
     const chunkFilePath = path.join(dir, chunkPath);
     const assetsJsonFilePath = path.join(dir, '..', 'assets.json');
     const [assetsJsonString, chunkFileContent] = await Promise.all([
         await fs.readFile(assetsJsonFilePath, 'utf8'),
         await fs.readFile(chunkFilePath, 'utf8')
     ]);
-    const serverEntryFileContentPatched = chunkFileContent.replace(ASSETS_MAP, assetsJsonString);
+    const serverEntryFileContentPatched = chunkFileContent.replace(ASSETS_MANIFEST, assetsJsonString);
     assert(serverEntryFileContentPatched !== chunkFileContent);
     await fs.writeFile(chunkFilePath, serverEntryFileContentPatched);
 }
-function find_ASSETS_MAP(bundle) {
+function find_ASSETS_MANIFEST(bundle) {
     let chunkPath;
     for (const filePath in bundle) {
         const chunk = bundle[filePath];
-        if ('code' in chunk && chunk.code.includes(ASSETS_MAP)) {
+        if ('code' in chunk && chunk.code.includes(ASSETS_MANIFEST)) {
             assert(!chunkPath);
             chunkPath = filePath;
         }

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

@@ -7,12 +7,12 @@ declare module 'vite' {
         _isDev?: boolean;
         _vikeVitePluginOptions?: unknown;
         _root?: string;
+        _baseViteOriginal?: string;
         _viteConfigEnhanced?: InlineConfig;
         vike?: {
             global: VikeConfigObject['global'];
             prerenderContext?: PrerenderContextPublic;
         };
-        _vikeConfigGlobal?: VikeConfigObject['vikeConfigGlobal'];
     }
 }
 declare function commonConfig(vikeVitePluginOptions: unknown): Plugin[];

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

@@ -12,6 +12,7 @@ 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';
+import { resolvePrerenderConfig } from '../../prerender/resolvePrerenderConfig.js';
 const pluginName = 'vike:commonConfig';
 function commonConfig(vikeVitePluginOptions) {
     return [
@@ -31,10 +32,10 @@ function commonConfig(vikeVitePluginOptions) {
                         _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 })
+                        configVikePromise: Promise.resolve({
+                            prerender: !!resolvePrerenderConfig(vikeConfig.global.config.prerender)
+                        })
                     };
                 }
             }

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

@@ -43,7 +43,8 @@ function extractAssetsPlugin() {
                     assertV1Design(vikeConfig.pageConfigs, true);
                     assert(false);
                 }
-                assert(vikeConfig.vikeConfigGlobal.includeAssetsImportedByServer);
+                // TODO/now: add meta.default
+                assert(vikeConfig.global.config.includeAssetsImportedByServer ?? true);
                 assert(!viteIsSSR_options(options));
                 const importStatements = await getImportStatements(src);
                 const moduleNames = getImportedModules(importStatements);
@@ -76,7 +77,8 @@ function extractAssetsPlugin() {
                 if (!extractAssetsRE.test(importer)) {
                     return;
                 }
-                assert(vikeConfig.vikeConfigGlobal.includeAssetsImportedByServer);
+                // TODO/now: add meta.default
+                assert(vikeConfig.global.config.includeAssetsImportedByServer ?? true);
                 let resolution = null;
                 try {
                     resolution = await this.resolve(source, importer, { skipSelf: true, ...options });

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.js';
+import type { VikeConfigObject } from './v1-design/getVikeConfig.js';
 declare function getVirtualFileImportUserCode(id: string, options: {
     ssr?: boolean;
-} | undefined, vikeConfigGlobal: VikeConfigGlobal, config: ResolvedConfig, isDev: boolean): Promise<string>;
+} | undefined, vikeConfig: VikeConfigObject, config: ResolvedConfig, isDev: boolean): Promise<string>;

package/dist/esm/node/plugin/plugins/importUserCode/getVirtualFileImportUserCode.js

@@ -6,16 +6,17 @@ import { fileTypes } from '../../../../shared/getPageFiles/fileTypes.js';
 import path from 'path';
 import { getVirtualFilePageConfigs } from './v1-design/getVirtualFilePageConfigs.js';
 import { isV1Design as isV1Design_ } from './v1-design/getVikeConfig.js';
-async function getVirtualFileImportUserCode(id, options, vikeConfigGlobal, config, isDev) {
+import { resolvePrerenderConfig } from '../../../prerender/resolvePrerenderConfig.js';
+async function getVirtualFileImportUserCode(id, options, vikeConfig, config, isDev) {
     const idParsed = isVirtualFileIdImportUserCode(id);
     assert(idParsed);
     const { isForClientSide, isClientRouting } = idParsed;
     assert(isForClientSide === !viteIsSSR_options(options));
-    const isPrerendering = !!vikeConfigGlobal.prerender;
-    const code = await getCode(config, vikeConfigGlobal, isForClientSide, isClientRouting, isPrerendering, isDev, id);
+    const isPrerendering = !!resolvePrerenderConfig(vikeConfig.global.config.prerender);
+    const code = await getCode(config, vikeConfig, isForClientSide, isClientRouting, isPrerendering, isDev, id);
     return code;
 }
-async function getCode(config, vikeConfigGlobal, isForClientSide, isClientRouting, isPrerendering, isDev, id) {
+async function getCode(config, vikeConfig, isForClientSide, isClientRouting, isPrerendering, isDev, id) {
     const { command } = config;
     assert(command === 'serve' || command === 'build');
     const isBuild = command === 'build';
@@ -24,7 +25,7 @@ async function getCode(config, vikeConfigGlobal, isForClientSide, isClientRoutin
     {
         const globRoots = getGlobRoots(config);
         debugGlob('Glob roots: ', globRoots);
-        content += await generateGlobImports(globRoots, isBuild, isForClientSide, isClientRouting, vikeConfigGlobal, isPrerendering, config, isDev, id);
+        content += await generateGlobImports(globRoots, isBuild, isForClientSide, isClientRouting, vikeConfig, isPrerendering, config, isDev, id);
     }
     debugGlob(`Glob imports for ${isForClientSide ? 'client' : 'server'}:\n`, content);
     return content;
@@ -54,7 +55,7 @@ function determineInjection({ fileType, isForClientSide, isClientRouting, isPrer
         }
     }
 }
-async function generateGlobImports(globRoots, isBuild, isForClientSide, isClientRouting, vikeConfigGlobal, isPrerendering, config, isDev, id) {
+async function generateGlobImports(globRoots, isBuild, isForClientSide, isClientRouting, vikeConfig, isPrerendering, config, isDev, id) {
     let fileContent = `// Generated by https://github.com/vikejs/vike/blob/main/vike/node/plugin/plugins/importUserCode/getVirtualFileImportUserCode.ts
 
 export const pageFilesLazy = {};
@@ -86,7 +87,9 @@ ${await getVirtualFilePageConfigs(isForClientSide, isDev, id, isClientRouting, c
             fileContent += getGlobs(globRoots, isBuild, fileType, 'extractExportNames', isV1Design);
         }
     });
-    if (vikeConfigGlobal.includeAssetsImportedByServer && isForClientSide) {
+    // TODO/now: add meta.default
+    const includeAssetsImportedByServer = vikeConfig.global.config.includeAssetsImportedByServer ?? true;
+    if (includeAssetsImportedByServer && isForClientSide) {
         fileContent += getGlobs(globRoots, isBuild, '.page.server', 'extractAssets', isV1Design);
     }
     return fileContent;

package/dist/esm/node/plugin/plugins/importUserCode/index.js

@@ -12,12 +12,11 @@ import { logConfigInfo } from '../../shared/loggerNotProd.js';
 import { getModuleFilePathAbsolute } from '../../shared/getFilePath.js';
 function importUserCode() {
     let config;
-    let vikeConfigGlobal;
+    let vikeConfig;
     return {
         name: 'vike:importUserCode',
         async configResolved(config_) {
-            const vikeConfig = await getVikeConfig(config_);
-            vikeConfigGlobal = vikeConfig.vikeConfigGlobal;
+            vikeConfig = await getVikeConfig(config_);
             config = config_;
             // TODO/v1-release: remove
             {
@@ -52,7 +51,7 @@ function importUserCode() {
                 return code;
             }
             if (isVirtualFileIdImportUserCode(id)) {
-                const code = await getVirtualFileImportUserCode(id, options, vikeConfigGlobal, config, isDev);
+                const code = await getVirtualFileImportUserCode(id, options, vikeConfig, config, isDev);
                 return code;
             }
         },

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

@@ -1,5 +1,6 @@
 export { assertExtensionsConventions };
-export { assertExtensionsPeerDependencies };
+export { assertExtensionsRequire };
 import { type InterfaceFile } from './getVikeConfig.js';
+import { PageConfigBuildTime } from '../../../../../shared/page-configs/PageConfig.js';
 declare function assertExtensionsConventions(interfaceFile: InterfaceFile): void;
-declare function assertExtensionsPeerDependencies(interfaceFilesRelevantList: InterfaceFile[]): void;
+declare function assertExtensionsRequire(pageConfig: PageConfigBuildTime): void;

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

@@ -1,5 +1,5 @@
 export { assertExtensionsConventions };
-export { assertExtensionsPeerDependencies };
+export { assertExtensionsRequire };
 import pc from '@brillout/picocolors';
 import { isObjectOfStrings } from '../../../../../utils/isObjectOfStrings.js';
 import { PROJECT_VERSION, assert, assertUsage, assertWarning, findPackageJson } from '../../../utils.js';
@@ -18,32 +18,33 @@ function assertConfigExportPath(interfaceFile) {
         assert(!p.includes('node_modules'));
         return;
     }
-    const name = getConfigNameValue(interfaceFile);
+    const name = getNameValue(interfaceFile);
     assert(name); // already asserted in assertExtensionName()
     const importPathAbsoluteExpected = `${name}/config`;
     assertWarning(importPathAbsolute === importPathAbsoluteExpected, `The Vike configuration of ${pc.bold(name)} is exported at ${pc.bold(importPathAbsolute)}, but it should be exported at ${pc.bold(importPathAbsoluteExpected)} instead.`, { onlyOnce: true });
 }
 function assertExtensionName(interfaceFile) {
     const filePathToShowToUser = getFilePathToShowToUser(interfaceFile);
-    const name = getConfigNameValue(interfaceFile);
+    const name = getNameValue(interfaceFile);
     assertUsage(name, `Vike extension name missing: the config ${filePathToShowToUser} must define the setting ${pc.cyan('name')}`);
 }
-function assertExtensionsPeerDependencies(interfaceFilesRelevantList) {
-    // Get installed extensions
+function assertExtensionsRequire(pageConfig) {
+    const interfaceFilesRelevantList = Object.values(pageConfig.interfaceFiles).flat(1);
+    // Collect extensions
     const extensions = {};
     interfaceFilesRelevantList.forEach((interfaceFile) => {
-        const name = getConfigNameValue(interfaceFile);
+        const name = getNameValue(interfaceFile);
         if (name) {
             const version = getExtensionVersion(name, interfaceFile);
             extensions[name] = version;
         }
     });
-    // Enforce peer dependencies
+    // Enforce `require`
     interfaceFilesRelevantList.forEach((interfaceFile) => {
         const require = getConfigRequireValue(interfaceFile);
         if (!require)
             return;
-        const name = getConfigNameValue(interfaceFile);
+        const name = getNameValue(interfaceFile);
         const filePathToShowToUser = getFilePathToShowToUser(interfaceFile);
         assertUsage(name, `Setting ${pc.bold('name')} is required for being able to use setting ${pc.bold('require')} in ${filePathToShowToUser}.`);
         Object.entries(require).forEach(([reqName, reqVersion]) => {
@@ -67,7 +68,7 @@ function getConfigRequireValue(interfaceFile) {
     assertUsage(isObjectOfStrings(require), `The setting ${pc.bold('require')} defined at ${filePathToShowToUserResolved} should be an object with string values (${pc.bold('Record<string, string>')}).`);
     return require;
 }
-function getConfigNameValue(interfaceFile) {
+function getNameValue(interfaceFile) {
     const name = getConfigValueInterfaceFile(interfaceFile, 'name');
     if (!name)
         return null;

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

@@ -139,7 +139,12 @@ const configDefinitionsBuiltInAll = {
         eager: true,
         global: true
     },
-    prerender: { env: { config: true }, global: (value) => typeof value !== 'object', type: ['boolean', 'object'] },
+    prerender: {
+        env: { config: true },
+        global: (value) => typeof value === 'object',
+        type: ['boolean', 'object'],
+        cumulative: true
+    },
     vite: { env: { config: true }, global: true, cumulative: true, type: 'object' },
     disableAutoFullBuild: {
         env: { config: true },
@@ -151,8 +156,8 @@ const configDefinitionsBuiltInAll = {
         ]
     },
     includeAssetsImportedByServer: { env: { config: true }, global: true, type: 'boolean' },
-    baseAssets: { env: { config: true }, global: true, type: 'string' },
-    baseServer: { env: { config: true }, global: true, type: 'string' },
+    baseAssets: { env: { config: true, server: true }, global: true, type: 'string' },
+    baseServer: { env: { config: true, server: 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' }

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

@@ -8,8 +8,7 @@ export { getConfigValueInterfaceFile };
 export type { VikeConfigObject };
 export type { InterfaceValueFile };
 export type { InterfaceFile };
-export type { VikeConfigGlobal };
-export type { VikeVitePluginOptions };
+export type { InterfaceFilesByLocationId };
 import type { PageConfigGlobalBuildTime, PageConfigBuildTime } from '../../../../../shared/page-configs/PageConfig.js';
 import { type LocationId } from './getVikeConfig/filesystemRouting.js';
 import type { ResolvedConfig } from 'vite';
@@ -35,10 +34,10 @@ type InterfaceValueFile = InterfaceFileCommons & {
     configName: string;
 };
 type ConfigName = string;
+type InterfaceFilesByLocationId = Record<LocationId, InterfaceFile[]>;
 type VikeConfigObject = {
     pageConfigs: PageConfigBuildTime[];
     pageConfigGlobal: PageConfigGlobalBuildTime;
-    vikeConfigGlobal: VikeConfigGlobal;
     global: ReturnType<typeof getPageConfigUserFriendlyNew>;
 };
 declare const vikeConfigDependencies: Set<string>;
@@ -50,95 +49,3 @@ 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;
-};