vike 0.4.219 → 0.4.220-commit-9a798ce

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

@@ -22,7 +22,7 @@ import { loadConfigFile, loadImportedFile, loadValueFile } from './getVikeConfig
 import { clearFilesEnvMap, resolveConfigEnvWithFileName, resolvePointerImportOfConfig } from './getVikeConfig/resolvePointerImport.js';
 import { getFilePathResolved } from '../../../shared/getFilePath.js';
 import { getConfigValueBuildTime } from '../../../../../shared/page-configs/getConfigValueBuildTime.js';
-import { assertExtensionsPeerDependencies, assertExtensionsConventions } from './assertExtensions.js';
+import { assertExtensionsRequire, assertExtensionsConventions } from './assertExtensions.js';
 import { getPageConfigUserFriendlyNew } from '../../../../../shared/page-configs/getPageConfigUserFriendly.js';
 import { getConfigValuesBase } from '../../../../../shared/page-configs/serialize/serializeConfigValues.js';
 const configDefinitionsBuiltIn = getConfigDefinitionsBuiltIn();
@@ -108,7 +108,7 @@ async function loadInterfaceFiles(userRootDir) {
             valueFiles.push(f);
         }
     });
-    let interfaceFilesByLocationId = {};
+    let interfaceFilesAll = {};
     await Promise.all([
         // Config files
         ...configFiles.map(async (filePath) => {
@@ -118,8 +118,8 @@ async function loadInterfaceFiles(userRootDir) {
             assert(filePath.filePathAbsoluteUserRootDir);
             const locationId = getLocationId(filePathAbsoluteUserRootDir);
             const interfaceFile = getInterfaceFileFromConfigFile(configFile, false, locationId);
-            interfaceFilesByLocationId[locationId] = interfaceFilesByLocationId[locationId] ?? [];
-            interfaceFilesByLocationId[locationId].push(interfaceFile);
+            interfaceFilesAll[locationId] = interfaceFilesAll[locationId] ?? [];
+            interfaceFilesAll[locationId].push(interfaceFile);
             extendsConfigs.forEach((extendsConfig) => {
                 /* We purposely use the same locationId because the Vike extension's config should only apply to where it's being extended from, for example:
                 ```js
@@ -139,7 +139,7 @@ async function loadInterfaceFiles(userRootDir) {
                 */
                 const interfaceFile = getInterfaceFileFromConfigFile(extendsConfig, true, locationId);
                 assertExtensionsConventions(interfaceFile);
-                interfaceFilesByLocationId[locationId].push(interfaceFile);
+                interfaceFilesAll[locationId].push(interfaceFile);
             });
         }),
         // Value files
@@ -164,18 +164,18 @@ async function loadInterfaceFiles(userRootDir) {
                 //  - If `configDef` is `undefined` => we load the file +{configName}.js later.
                 //  - We already need to load +meta.js here (to get the custom config definitions defined by the user)
                 const configDef = getConfigDefinitionOptional(configDefinitionsBuiltIn, configName);
-                if (configDef && isLoadableAtBuildTime(configDef)) {
+                if (configDef && shouldBeLoadableAtBuildTime(configDef)) {
                     await loadValueFile(interfaceFile, configName, userRootDir);
                 }
             }
             {
-                interfaceFilesByLocationId[locationId] = interfaceFilesByLocationId[locationId] ?? [];
-                interfaceFilesByLocationId[locationId].push(interfaceFile);
+                interfaceFilesAll[locationId] = interfaceFilesAll[locationId] ?? [];
+                interfaceFilesAll[locationId].push(interfaceFile);
             }
         })
     ]);
-    assertAllConfigsAreKnown(interfaceFilesByLocationId);
-    return interfaceFilesByLocationId;
+    assertAllConfigsAreKnown(interfaceFilesAll);
+    return interfaceFilesAll;
 }
 function getInterfaceFileFromConfigFile(configFile, isConfigExtend, locationId) {
     const { fileExports, filePath, extendsFilePaths } = configFile;
@@ -195,9 +195,9 @@ function getInterfaceFileFromConfigFile(configFile, isConfigExtend, locationId)
     return interfaceFile;
 }
 /** Show error message upon unknown config */
-function assertAllConfigsAreKnown(interfaceFilesByLocationId) {
-    objectEntries(interfaceFilesByLocationId).forEach(([locationId, interfaceFiles]) => {
-        const interfaceFilesRelevant = getInterfaceFilesRelevant(interfaceFilesByLocationId, locationId);
+function assertAllConfigsAreKnown(interfaceFilesAll) {
+    objectEntries(interfaceFilesAll).forEach(([locationId, interfaceFiles]) => {
+        const interfaceFilesRelevant = getInterfaceFilesRelevant(interfaceFilesAll, locationId);
         const configDefinitions = getConfigDefinitions(interfaceFilesRelevant);
         interfaceFiles.forEach((interfaceFile) => {
             Object.keys(interfaceFile.fileExportsByConfigName).forEach((configName) => {
@@ -240,9 +240,9 @@ async function loadVikeConfig_withErrorHandling(userRootDir, isDev, vikeVitePlug
                 pageConfigs: [],
                 pageConfigGlobal: {
                     configDefinitions: {},
+                    interfaceFiles: {},
                     configValueSources: {}
                 },
-                vikeConfigGlobal: resolveVikeConfigGlobal({}, {}),
                 global: getPageConfigUserFriendlyNew({ configValues: {} })
             };
             return dummyData;
@@ -250,49 +250,86 @@ async function loadVikeConfig_withErrorHandling(userRootDir, isDev, vikeVitePlug
     }
 }
 async function loadVikeConfig(userRootDir, vikeVitePluginOptions) {
-    const interfaceFilesByLocationId = await loadInterfaceFiles(userRootDir);
+    const interfaceFilesAll = await loadInterfaceFiles(userRootDir);
     const importedFilesLoaded = {};
-    const [globalConfigs, pageConfigs] = await Promise.all([
-        getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importedFilesLoaded, vikeVitePluginOptions),
-        getPageConfigs(interfaceFilesByLocationId, userRootDir, importedFilesLoaded)
-    ]);
-    return { pageConfigs, ...globalConfigs };
+    const { pageConfigGlobal, pageConfigs } = await getPageConfigs(interfaceFilesAll, userRootDir, importedFilesLoaded);
+    // interop vike(options) in vite.config.js
+    temp_interopVikeVitePlugin(pageConfigGlobal, vikeVitePluginOptions, userRootDir);
+    // global
+    const configValues = getConfigValues(pageConfigGlobal);
+    const global = getPageConfigUserFriendlyNew({ configValues });
+    return { pageConfigs, pageConfigGlobal, global };
 }
-async function getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importedFilesLoaded, vikeVitePluginOptions) {
-    const locationIds = objectKeys(interfaceFilesByLocationId);
-    const interfaceFilesGlobal = objectFromEntries(objectEntries(interfaceFilesByLocationId).filter(([locationId]) => {
-        return isGlobalLocation(locationId, locationIds);
-    }));
+async function getGlobalConfigs(interfaceFilesAll, userRootDir, importedFilesLoaded) {
+    /* TODO/now: dedupe
     // 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 interfaceFilesGlobalPaths: string[] = []
+      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(interfaceFilesAll).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 = {};
+    //*/
+}
+function temp_interopVikeVitePlugin(pageConfigGlobal, vikeVitePluginOptions, userRootDir) {
+    assert(isObject(vikeVitePluginOptions));
+    assertWarning(Object.keys(vikeVitePluginOptions).length === 0, `Define Vike settings in +config.js instead of vite.config.js ${pc.underline('https://vike.dev/migration/settings')}`, { onlyOnce: true });
+    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: '/',
+            interfaceFile: null,
+            isOverriden: configDef.cumulative ? false : sources.length > 0,
+            valueIsImportedAtRuntime: false,
+            valueIsDefinedByPlusFile: false
+        });
+    });
+}
+async function getPageConfigs(interfaceFilesAll, userRootDir, importedFilesLoaded) {
+    const locationIds = objectKeys(interfaceFilesAll);
+    const interfaceFilesGlobal = objectFromEntries(objectEntries(interfaceFilesAll).filter(([locationId]) => {
+        return isGlobalLocation(locationId, locationIds);
+    }));
     const pageConfigGlobal = {
         configDefinitions: configDefinitionsBuiltInGlobal,
+        interfaceFiles: interfaceFilesGlobal,
         configValueSources: {}
     };
     await Promise.all(objectEntries(configDefinitionsBuiltInGlobal).map(async ([configName, configDef]) => {
@@ -301,56 +338,15 @@ async function getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importe
         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))
+    const pageConfigs = [];
+    await Promise.all(objectEntries(interfaceFilesAll)
+        .filter(([_locationId, interfaceFiles]) => isDefiningPage(interfaceFiles))
         .map(async ([locationId]) => {
-        const interfaceFilesRelevant = getInterfaceFilesRelevant(interfaceFilesByLocationId, locationId);
+        const interfaceFilesRelevant = getInterfaceFilesRelevant(interfaceFilesAll, locationId);
         const interfaceFilesRelevantList = Object.values(interfaceFilesRelevant).flat(1);
-        assertExtensionsPeerDependencies(interfaceFilesRelevantList);
         const configDefinitions = getConfigDefinitions(interfaceFilesRelevant);
-        // Load value files of custom config-only configs
+        // Load value files of `env.config===true` custom configs
         await Promise.all(interfaceFilesRelevantList.map(async (interfaceFile) => {
             if (!interfaceFile.isValueFile)
                 return;
@@ -358,7 +354,7 @@ async function getPageConfigs(interfaceFilesByLocationId, userRootDir, importedF
             if (isGlobalConfig(configName))
                 return;
             const configDef = getConfigDefinition(configDefinitions, configName, interfaceFile.filePath.filePathToShowToUser);
-            if (!isLoadableAtBuildTime(configDef))
+            if (!shouldBeLoadableAtBuildTime(configDef))
                 return;
             const isAlreadyLoaded = interfacefileIsAlreaydLoaded(interfaceFile);
             if (isAlreadyLoaded)
@@ -380,53 +376,34 @@ async function getPageConfigs(interfaceFilesByLocationId, userRootDir, importedF
         const { routeFilesystem, isErrorPage } = determineRouteFilesystem(locationId, configValueSources);
         applyEffectsAll(configValueSources, configDefinitions);
         const configValuesComputed = getComputed(configValueSources, configDefinitions);
-        assertUsageGlobalConfigs(interfaceFilesRelevantList, configDefinitions, interfaceFilesByLocationId);
         const pageConfig = {
             pageId: locationId,
             isErrorPage,
             routeFilesystem,
             configDefinitions,
+            interfaceFiles: interfaceFilesRelevant,
             configValueSources,
             configValuesComputed
         };
-        return pageConfig;
+        pageConfigs.push(pageConfig);
     }));
-    assertPageConfigs(pageConfigs);
-    return pageConfigs;
+    assertPageConfigs(pageConfigs, interfaceFilesAll);
+    return { pageConfigs, pageConfigGlobal };
 }
-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 };
-        }
+function assertPageConfigs(pageConfigs, interfaceFilesAll) {
+    pageConfigs.forEach((pageConfig) => {
+        assertGlobalConfigs(pageConfig, interfaceFilesAll);
+        assertExtensionsRequire(pageConfig);
+        assertOnBeforeRenderEnv(pageConfig);
     });
-    return configValues;
 }
 // TODO/now: refactor
-//  - Dedupe: most of the assertUsageGlobalConfigs() code below is a copy-paste of the assertUsage() logic inside getGlobalConfigs()
+//  - Dedupe: most of the assertGlobalConfigs() 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
-function assertUsageGlobalConfigs(interfaceFilesRelevantList, configDefinitions, interfaceFilesByLocationId) {
+function assertGlobalConfigs(pageConfig, interfaceFilesAll) {
+    const interfaceFilesRelevantList = Object.values(pageConfig.interfaceFiles).flat(1);
+    const { configDefinitions } = pageConfig;
     interfaceFilesRelevantList.forEach((interfaceFile) => {
         const configNames = [];
         if (interfaceFile.isValueFile) {
@@ -440,9 +417,9 @@ function assertUsageGlobalConfigs(interfaceFilesRelevantList, configDefinitions,
                 return;
             const configDef = getConfigDefinition(configDefinitions, configName, interfaceFile.filePath.filePathToShowToUser);
             if (configDef.global === true) {
-                const locationIds = objectKeys(interfaceFilesByLocationId);
+                const locationIds = objectKeys(interfaceFilesAll);
                 if (!isGlobalLocation(interfaceFile.locationId, locationIds)) {
-                    const interfaceFilesGlobal = objectFromEntries(objectEntries(interfaceFilesByLocationId).filter(([locationId]) => {
+                    const interfaceFilesGlobal = objectFromEntries(objectEntries(interfaceFilesAll).filter(([locationId]) => {
                         return isGlobalLocation(locationId, locationIds);
                     }));
                     const configFilesGlobal = [];
@@ -468,11 +445,6 @@ function assertUsageGlobalConfigs(interfaceFilesRelevantList, configDefinitions,
         });
     });
 }
-function assertPageConfigs(pageConfigs) {
-    pageConfigs.forEach((pageConfig) => {
-        assertOnBeforeRenderEnv(pageConfig);
-    });
-}
 function assertOnBeforeRenderEnv(pageConfig) {
     const onBeforeRenderConfig = pageConfig.configValueSources.onBeforeRender?.[0];
     if (!onBeforeRenderConfig)
@@ -482,6 +454,34 @@ function assertOnBeforeRenderEnv(pageConfig) {
     // When using Server Routing, loading a onBeforeRender() hook on the client-side hasn't any effect (the Server Routing's client runtime never calls it); it unnecessarily bloats client bundle sizes
     assertUsage(!(onBeforeRenderEnv.client && !isClientRouting), `Page ${pageConfig.pageId} has an onBeforeRender() hook with env ${pc.cyan(JSON.stringify(onBeforeRenderEnv))} which doesn't make sense because the page is using Server Routing: onBeforeRender() can be run in the client only when using Client Routing.`);
 }
+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;
+}
 function interfacefileIsAlreaydLoaded(interfaceFile) {
     const configMapValues = Object.values(interfaceFile.fileExportsByConfigName);
     const isAlreadyLoaded = configMapValues.some((conf) => 'configValue' in conf);
@@ -490,8 +490,8 @@ function interfacefileIsAlreaydLoaded(interfaceFile) {
     }
     return isAlreadyLoaded;
 }
-function getInterfaceFilesRelevant(interfaceFilesByLocationId, locationIdPage) {
-    const interfaceFilesRelevant = Object.fromEntries(objectEntries(interfaceFilesByLocationId)
+function getInterfaceFilesRelevant(interfaceFilesAll, locationIdPage) {
+    const interfaceFilesRelevant = Object.fromEntries(objectEntries(interfaceFilesAll)
         .filter(([locationId]) => {
         return isInherited(locationId, locationIdPage);
     })
@@ -591,7 +591,10 @@ function isInterfaceFileUserLand(interfaceFile) {
 async function getConfigValueSource(configName, interfaceFile, configDef, userRootDir, importedFilesLoaded, isHighestInheritancePrecedence) {
     const conf = interfaceFile.fileExportsByConfigName[configName];
     assert(conf);
-    const { locationId } = interfaceFile;
+    const configValueSourceCommon = {
+        locationId: interfaceFile.locationId,
+        interfaceFile
+    };
     const definedAtFilePath_ = {
         ...interfaceFile.filePath,
         fileExportPathToShowToUser: ['default', configName]
@@ -619,7 +622,7 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
             };
         }
         const configValueSource = {
-            locationId,
+            ...configValueSourceCommon,
             value: valueFilePath,
             valueIsFilePath: true,
             configEnv: configDef.env,
@@ -638,7 +641,7 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
         const resolved = resolvePointerImportOfConfig(configValue, interfaceFile.filePath, userRootDir, configDef.env, configName);
         if (resolved) {
             const configValueSource = {
-                locationId,
+                ...configValueSourceCommon,
                 configEnv: resolved.configEnvResolved,
                 valueIsImportedAtRuntime: true,
                 valueIsDefinedByPlusFile: false,
@@ -646,7 +649,7 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
                 definedAtFilePath: resolved.pointerImport
             };
             // Load pointer import
-            if (isLoadableAtBuildTime(configDef) &&
+            if (shouldBeLoadableAtBuildTime(configDef) &&
                 // The value of `extends` was already loaded and already used: we don't need the value of `extends` anymore
                 configName !== 'extends') {
                 if (resolved.pointerImport.filePathAbsoluteFilesystem) {
@@ -662,7 +665,7 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
         }
         // Defined inside +config.js
         const configValueSource = {
-            locationId,
+            ...configValueSourceCommon,
             value: configValue,
             configEnv: configDef.env,
             valueIsImportedAtRuntime: false,
@@ -678,7 +681,7 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
         const valueAlreadyLoaded = 'configValue' in conf;
         assert(valueAlreadyLoaded === !!configEnvResolved.config);
         const configValueSource = {
-            locationId,
+            ...configValueSourceCommon,
             configEnv: configEnvResolved,
             valueIsImportedAtRuntime: !valueAlreadyLoaded,
             valueIsDefinedByPlusFile: true,
@@ -1036,7 +1039,7 @@ function getConfigDefinition(configDefinitions, configName, filePathToShowToUser
 function getConfigDefinitionOptional(configDefinitions, configName) {
     return configDefinitions[configName] ?? null;
 }
-function isLoadableAtBuildTime(configDef) {
+function shouldBeLoadableAtBuildTime(configDef) {
     return !!configDef.env.config && !configDef._valueIsFilePath;
 }
 function isGlobalConfig(configName) {
@@ -1046,6 +1049,17 @@ function isGlobalConfig(configName) {
     const configNamesGlobal = getConfigNamesGlobal();
     return includes(configNamesGlobal, configName);
 }
+/*
+// TODO/now
+function isGlobalConfig(configName: string, configDefinitions: ConfigDefinitions): configName is ConfigNameGlobal {
+  const configSpec = configDefinitions[configName]
+  assert(configSpec)
+  const globalValue = configSpec.global
+  if (!globalValue) return false
+  if (globalValue === true ) return true
+  return globalValue(value)
+}
+*/
 function getConfigNamesGlobal() {
     return Object.keys(configDefinitionsBuiltInGlobal);
 }
@@ -1081,35 +1095,3 @@ 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

@@ -22,7 +22,9 @@ async function getVirtualFilePageConfigValuesAll(id, isDev, config) {
     const { pageConfigs } = vikeConfig;
     const pageConfig = pageConfigs.find((pageConfig) => pageConfig.pageId === pageId);
     assert(pageConfig, { id, pageId });
-    const code = getLoadConfigValuesAll(pageConfig, isForClientSide, pageId, vikeConfig.vikeConfigGlobal.includeAssetsImportedByServer, isDev);
+    const code = getLoadConfigValuesAll(pageConfig, isForClientSide, pageId, 
+    // TODO/now: add meta.default
+    vikeConfig.global.config.includeAssetsImportedByServer ?? true, isDev);
     debug(id, isForClientSide ? 'CLIENT-SIDE' : 'SERVER-SIDE', code);
     return code;
 }

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

@@ -26,12 +26,13 @@ function getCodePageConfigsSerialized(pageConfigs, isForClientSide, isClientRout
     const lines = [];
     pageConfigs.forEach((pageConfig) => {
         const { pageId, routeFilesystem, isErrorPage } = pageConfig;
-        const virtualFileIdPageConfigValuesAll = getVirtualFileIdPageConfigValuesAll(pageId, isForClientSide);
         lines.push(`  {`);
         lines.push(`    pageId: ${JSON.stringify(pageId)},`);
         lines.push(`    isErrorPage: ${JSON.stringify(isErrorPage)},`);
         lines.push(`    routeFilesystem: ${JSON.stringify(routeFilesystem)},`);
-        lines.push(`    loadConfigValuesAll: () => import(${JSON.stringify(virtualFileIdPageConfigValuesAll)}),`);
+        const virtualFileId = JSON.stringify(getVirtualFileIdPageConfigValuesAll(pageId, isForClientSide));
+        const load = `() => ({ moduleId: ${virtualFileId}, moduleExports: import(${virtualFileId}) })`;
+        lines.push(`    loadConfigValuesAll: ${load},`);
         lines.push(`    configValuesSerialized: {`);
         lines.push(...serializeConfigValues(pageConfig, importStatements, (configEnv) => isRuntimeEnvMatch(configEnv, { isForClientSide, isClientRouting, isDev }), '    ', true));
         lines.push(`    },`);

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

@@ -7,7 +7,7 @@ import pc from '@brillout/picocolors';
 import { logDockerHint } from './devConfig/index.js';
 function previewConfig() {
     let config;
-    // let vikeConfigGlobal: VikeConfigGlobal
+    // let vikeConfig: VikeConfigObject
     return {
         name: 'vike:previewConfig',
         apply: applyPreview,
@@ -22,8 +22,7 @@ function previewConfig() {
         async configResolved(config_) {
             config = config_;
             logDockerHint(config.preview.host);
-            // const vikeConfig = await getVikeConfig(config)
-            // vikeConfigGlobal = vikeConfig.vikeConfigGlobal
+            // vikeConfig = await getVikeConfig(config)
         },
         configurePreviewServer(server) {
             /* - Couldn't make `appType: 'mpa'` work as of npm:@brillout/vite@5.0.0-beta.14.0426910c
@@ -33,7 +32,7 @@ function previewConfig() {
             return () => {
                 assertDist();
                 /* We don't use this condition (we wrongfully always use the SSR middleware) because of the regression introduced by https://github.com/vitejs/vite/pull/14756 which stops servering .html files when `appType: 'custom'`.
-                if (!vikeConfigGlobal.prerender || vikeConfigGlobal.prerender.partial) {
+                if (!vikeConfig.global.config.prerender || vikeConfig.global.config.prerender.partial) {
                   addSsrMiddleware(server.middlewares, config, true)
                 }
                 /*/

package/dist/esm/node/plugin/utils.js

@@ -2,7 +2,7 @@
 // We call onLoad() here so that it's called even when only a subset of the plugin is loaded. (Making the assert() calls inside onLoad() a lot stronger.)
 import { onLoad } from './onLoad.js';
 onLoad();
-// We tolerate the fact that we load all of the runtime utils even though some of it isn't needed
+// It's common practice for Vike's Vite plugin to import from Vike's sever runtime
 export * from '../runtime/utils.js';
 // Utils only needed by `plugin/*`
 export * from '../../utils/viteIsSSR.js';

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

@@ -0,0 +1,9 @@
+export { isPrerenderAutoRunEnabled };
+export { temp_disablePrerenderAutoRun };
+export { isPrerendering };
+export { setContextIsPrerendering };
+import type { VikeConfigObject } from '../plugin/plugins/importUserCode/v1-design/getVikeConfig.js';
+declare function isPrerenderAutoRunEnabled(vikeConfig: VikeConfigObject): boolean;
+declare function temp_disablePrerenderAutoRun(): void;
+declare function isPrerendering(): boolean;
+declare function setContextIsPrerendering(): void;

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

@@ -0,0 +1,24 @@
+export { isPrerenderAutoRunEnabled };
+export { temp_disablePrerenderAutoRun };
+export { isPrerendering };
+export { setContextIsPrerendering };
+import { getGlobalObject } from '../../utils/getGlobalObject.js';
+import { resolvePrerenderConfig } from './resolvePrerenderConfig.js';
+const globalObject = getGlobalObject('prerender/context.ts', {});
+function isPrerenderAutoRunEnabled(vikeConfig) {
+    const prerenderConfig = resolvePrerenderConfig(vikeConfig.global.config.prerender);
+    return (prerenderConfig &&
+        !prerenderConfig.disableAutoRun &&
+        !globalObject.isDisabled &&
+        vikeConfig.global.config.disableAutoFullBuild !== 'prerender');
+}
+// TODO/v1-release: remove
+function temp_disablePrerenderAutoRun() {
+    globalObject.isDisabled = true;
+}
+function isPrerendering() {
+    return !!globalObject.isPrerendering;
+}
+function setContextIsPrerendering() {
+    globalObject.isPrerendering = true;
+}

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

@@ -0,0 +1,5 @@
+export { resolvePrerenderConfig };
+import type { ConfigResolved } from '../../shared/page-configs/Config/PageContextConfig.js';
+type PrerenderConfigSemiResolved = ConfigResolved['prerender'];
+type PrerenderConfig = false | Exclude<Required<NonNullable<PrerenderConfigSemiResolved>[number]>, boolean>;
+declare function resolvePrerenderConfig(prerenderConfigs: PrerenderConfigSemiResolved): PrerenderConfig;