vike 0.4.219 → 0.4.220-commit-9a798ce

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

@@ -114,7 +114,7 @@ async function loadInterfaceFiles(userRootDir) {
             valueFiles.push(f);
         }
     });
-    let interfaceFilesByLocationId = {};
+    let interfaceFilesAll = {};
     await Promise.all([
         // Config files
         ...configFiles.map(async (filePath) => {
@@ -124,8 +124,8 @@ async function loadInterfaceFiles(userRootDir) {
             (0, utils_js_1.assert)(filePath.filePathAbsoluteUserRootDir);
             const locationId = (0, filesystemRouting_js_1.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
@@ -145,7 +145,7 @@ async function loadInterfaceFiles(userRootDir) {
                 */
                 const interfaceFile = getInterfaceFileFromConfigFile(extendsConfig, true, locationId);
                 (0, assertExtensions_js_1.assertExtensionsConventions)(interfaceFile);
-                interfaceFilesByLocationId[locationId].push(interfaceFile);
+                interfaceFilesAll[locationId].push(interfaceFile);
             });
         }),
         // Value files
@@ -170,18 +170,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 (0, loadFileAtConfigTime_js_1.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;
@@ -201,9 +201,9 @@ function getInterfaceFileFromConfigFile(configFile, isConfigExtend, locationId)
     return interfaceFile;
 }
 /** Show error message upon unknown config */
-function assertAllConfigsAreKnown(interfaceFilesByLocationId) {
-    (0, utils_js_1.objectEntries)(interfaceFilesByLocationId).forEach(([locationId, interfaceFiles]) => {
-        const interfaceFilesRelevant = getInterfaceFilesRelevant(interfaceFilesByLocationId, locationId);
+function assertAllConfigsAreKnown(interfaceFilesAll) {
+    (0, utils_js_1.objectEntries)(interfaceFilesAll).forEach(([locationId, interfaceFiles]) => {
+        const interfaceFilesRelevant = getInterfaceFilesRelevant(interfaceFilesAll, locationId);
         const configDefinitions = getConfigDefinitions(interfaceFilesRelevant);
         interfaceFiles.forEach((interfaceFile) => {
             Object.keys(interfaceFile.fileExportsByConfigName).forEach((configName) => {
@@ -246,9 +246,9 @@ async function loadVikeConfig_withErrorHandling(userRootDir, isDev, vikeVitePlug
                 pageConfigs: [],
                 pageConfigGlobal: {
                     configDefinitions: {},
+                    interfaceFiles: {},
                     configValueSources: {}
                 },
-                vikeConfigGlobal: resolveVikeConfigGlobal({}, {}),
                 global: (0, getPageConfigUserFriendly_js_1.getPageConfigUserFriendlyNew)({ configValues: {} })
             };
             return dummyData;
@@ -256,49 +256,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 = (0, getPageConfigUserFriendly_js_1.getPageConfigUserFriendlyNew)({ configValues });
+    return { pageConfigs, pageConfigGlobal, global };
 }
-async function getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importedFilesLoaded, vikeVitePluginOptions) {
-    const locationIds = (0, utils_js_1.objectKeys)(interfaceFilesByLocationId);
-    const interfaceFilesGlobal = (0, utils_js_1.objectFromEntries)((0, utils_js_1.objectEntries)(interfaceFilesByLocationId).filter(([locationId]) => {
-        return (0, filesystemRouting_js_1.isGlobalLocation)(locationId, locationIds);
-    }));
+async function getGlobalConfigs(interfaceFilesAll, userRootDir, importedFilesLoaded) {
+    /* TODO/now: dedupe
     // Validate that global configs live in global interface files
     {
-        const interfaceFilesGlobalPaths = [];
-        (0, utils_js_1.objectEntries)(interfaceFilesGlobal).forEach(([locationId, interfaceFiles]) => {
-            (0, utils_js_1.assert)((0, filesystemRouting_js_1.isGlobalLocation)(locationId, locationIds));
-            interfaceFiles.forEach(({ filePath: { filePathAbsoluteUserRootDir } }) => {
-                if (filePathAbsoluteUserRootDir) {
-                    interfaceFilesGlobalPaths.push(filePathAbsoluteUserRootDir);
-                }
-            });
-        });
-        const globalPaths = Array.from(new Set(interfaceFilesGlobalPaths.map((p) => path_1.default.posix.dirname(p))));
-        (0, utils_js_1.objectEntries)(interfaceFilesByLocationId).forEach(([locationId, interfaceFiles]) => {
-            interfaceFiles.forEach((interfaceFile) => {
-                Object.keys(interfaceFile.fileExportsByConfigName).forEach((configName) => {
-                    if (!(0, filesystemRouting_js_1.isGlobalLocation)(locationId, locationIds) && isGlobalConfig(configName)) {
-                        (0, utils_js_1.assertUsage)(false, [
-                            `${interfaceFile.filePath.filePathToShowToUser} defines the config ${picocolors_1.default.cyan(configName)} which is global:`,
-                            globalPaths.length
-                                ? `define ${picocolors_1.default.cyan(configName)} in ${(0, utils_js_1.joinEnglish)(globalPaths, 'or')} instead`
-                                : `create a global config (e.g. /pages/+config.js) and define ${picocolors_1.default.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) {
+    (0, utils_js_1.assert)((0, utils_js_1.isObject)(vikeVitePluginOptions));
+    (0, utils_js_1.assertWarning)(Object.keys(vikeVitePluginOptions).length === 0, `Define Vike settings in +config.js instead of vite.config.js ${picocolors_1.default.underline('https://vike.dev/migration/settings')}`, { onlyOnce: true });
+    Object.entries(vikeVitePluginOptions).forEach(([configName, value]) => {
+        var _a;
+        (0, utils_js_1.assert)((0, utils_js_1.includes)((0, utils_js_1.objectKeys)(configDefinitionsBuiltInGlobal), configName));
+        const configDef = configDefinitionsBuiltInGlobal[configName];
+        const sources = ((_a = pageConfigGlobal.configValueSources)[configName] ?? (_a[configName] = []));
+        sources.push({
+            value,
+            configEnv: configDef.env,
+            definedAtFilePath: {
+                ...(0, getFilePath_js_1.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 = (0, utils_js_1.objectKeys)(interfaceFilesAll);
+    const interfaceFilesGlobal = (0, utils_js_1.objectFromEntries)((0, utils_js_1.objectEntries)(interfaceFilesAll).filter(([locationId]) => {
+        return (0, filesystemRouting_js_1.isGlobalLocation)(locationId, locationIds);
+    }));
     const pageConfigGlobal = {
         configDefinitions: configDefinitionsBuiltInGlobal,
+        interfaceFiles: interfaceFilesGlobal,
         configValueSources: {}
     };
     await Promise.all((0, utils_js_1.objectEntries)(configDefinitionsBuiltInGlobal).map(async ([configName, configDef]) => {
@@ -307,56 +344,15 @@ async function getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importe
         if (!configValueSource)
             return;
         pageConfigGlobal.configValueSources[configName] = sources;
-        // TODO/now
-        if (configName === 'onBeforeRoute' || configName === 'onPrerenderStart') {
-            (0, utils_js_1.assert)(!('value' in configValueSource));
-        }
-        else {
-            (0, utils_js_1.assert)('value' in configValueSource);
-            // TODO/now
-            if (configName === 'prerender' && typeof configValueSource.value === 'boolean')
-                return;
-            pageConfigGlobalValues[configName] = configValueSource.value;
-        }
     }));
-    const vikeConfigGlobal = resolveVikeConfigGlobal(vikeVitePluginOptions, pageConfigGlobalValues);
-    {
-        (0, utils_js_1.assert)((0, utils_js_1.isObject)(vikeVitePluginOptions));
-        Object.entries(vikeVitePluginOptions).forEach(([configName, value]) => {
-            var _a;
-            (0, utils_js_1.assert)((0, utils_js_1.includes)((0, utils_js_1.objectKeys)(configDefinitionsBuiltInGlobal), configName));
-            const configDef = configDefinitionsBuiltInGlobal[configName];
-            const sources = ((_a = pageConfigGlobal.configValueSources)[configName] ?? (_a[configName] = []));
-            sources.push({
-                value,
-                configEnv: configDef.env,
-                definedAtFilePath: {
-                    ...(0, getFilePath_js_1.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 = (0, getPageConfigUserFriendly_js_1.getPageConfigUserFriendlyNew)({ configValues });
-    return { pageConfigGlobal, vikeConfigGlobal, global };
-}
-async function getPageConfigs(interfaceFilesByLocationId, userRootDir, importedFilesLoaded) {
-    const pageConfigs = await Promise.all((0, utils_js_1.objectEntries)(interfaceFilesByLocationId)
-        .filter(([_pageId, interfaceFiles]) => isDefiningPage(interfaceFiles))
+    const pageConfigs = [];
+    await Promise.all((0, utils_js_1.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);
-        (0, assertExtensions_js_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;
@@ -364,7 +360,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)
@@ -386,53 +382,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 = {};
-    (0, serializeConfigValues_js_1.getConfigValuesBase)(pageConfig, (configEnv) => !!configEnv.config, null).forEach((entry) => {
-        if (entry.configValueBase.type === 'computed') {
-            (0, utils_js_1.assert)('value' in entry); // Help TS
-            const { configValueBase, value, configName } = entry;
-            configValues[configName] = { ...configValueBase, value };
-        }
-        if (entry.configValueBase.type === 'standard') {
-            (0, utils_js_1.assert)('sourceRelevant' in entry); // Help TS
-            const { configValueBase, sourceRelevant, configName } = entry;
-            (0, utils_js_1.assert)('value' in sourceRelevant);
-            const { value } = sourceRelevant;
-            configValues[configName] = { ...configValueBase, value };
-        }
-        if (entry.configValueBase.type === 'cumulative') {
-            (0, utils_js_1.assert)('sourcesRelevant' in entry); // Help TS
-            const { configValueBase, sourcesRelevant, configName } = entry;
-            const values = [];
-            sourcesRelevant.forEach((source) => {
-                (0, utils_js_1.assert)('value' in source);
-                values.push(source.value);
-            });
-            configValues[configName] = { ...configValueBase, value: values };
-        }
+function assertPageConfigs(pageConfigs, interfaceFilesAll) {
+    pageConfigs.forEach((pageConfig) => {
+        assertGlobalConfigs(pageConfig, interfaceFilesAll);
+        (0, assertExtensions_js_1.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) {
@@ -446,9 +423,9 @@ function assertUsageGlobalConfigs(interfaceFilesRelevantList, configDefinitions,
                 return;
             const configDef = getConfigDefinition(configDefinitions, configName, interfaceFile.filePath.filePathToShowToUser);
             if (configDef.global === true) {
-                const locationIds = (0, utils_js_1.objectKeys)(interfaceFilesByLocationId);
+                const locationIds = (0, utils_js_1.objectKeys)(interfaceFilesAll);
                 if (!(0, filesystemRouting_js_1.isGlobalLocation)(interfaceFile.locationId, locationIds)) {
-                    const interfaceFilesGlobal = (0, utils_js_1.objectFromEntries)((0, utils_js_1.objectEntries)(interfaceFilesByLocationId).filter(([locationId]) => {
+                    const interfaceFilesGlobal = (0, utils_js_1.objectFromEntries)((0, utils_js_1.objectEntries)(interfaceFilesAll).filter(([locationId]) => {
                         return (0, filesystemRouting_js_1.isGlobalLocation)(locationId, locationIds);
                     }));
                     const configFilesGlobal = [];
@@ -474,11 +451,6 @@ function assertUsageGlobalConfigs(interfaceFilesRelevantList, configDefinitions,
         });
     });
 }
-function assertPageConfigs(pageConfigs) {
-    pageConfigs.forEach((pageConfig) => {
-        assertOnBeforeRenderEnv(pageConfig);
-    });
-}
 function assertOnBeforeRenderEnv(pageConfig) {
     const onBeforeRenderConfig = pageConfig.configValueSources.onBeforeRender?.[0];
     if (!onBeforeRenderConfig)
@@ -488,6 +460,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
     (0, utils_js_1.assertUsage)(!(onBeforeRenderEnv.client && !isClientRouting), `Page ${pageConfig.pageId} has an onBeforeRender() hook with env ${picocolors_1.default.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 = {};
+    (0, serializeConfigValues_js_1.getConfigValuesBase)(pageConfig, (configEnv) => !!configEnv.config, null).forEach((entry) => {
+        if (entry.configValueBase.type === 'computed') {
+            (0, utils_js_1.assert)('value' in entry); // Help TS
+            const { configValueBase, value, configName } = entry;
+            configValues[configName] = { ...configValueBase, value };
+        }
+        if (entry.configValueBase.type === 'standard') {
+            (0, utils_js_1.assert)('sourceRelevant' in entry); // Help TS
+            const { configValueBase, sourceRelevant, configName } = entry;
+            (0, utils_js_1.assert)('value' in sourceRelevant);
+            const { value } = sourceRelevant;
+            configValues[configName] = { ...configValueBase, value };
+        }
+        if (entry.configValueBase.type === 'cumulative') {
+            (0, utils_js_1.assert)('sourcesRelevant' in entry); // Help TS
+            const { configValueBase, sourcesRelevant, configName } = entry;
+            const values = [];
+            sourcesRelevant.forEach((source) => {
+                (0, utils_js_1.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);
@@ -496,8 +496,8 @@ function interfacefileIsAlreaydLoaded(interfaceFile) {
     }
     return isAlreadyLoaded;
 }
-function getInterfaceFilesRelevant(interfaceFilesByLocationId, locationIdPage) {
-    const interfaceFilesRelevant = Object.fromEntries((0, utils_js_1.objectEntries)(interfaceFilesByLocationId)
+function getInterfaceFilesRelevant(interfaceFilesAll, locationIdPage) {
+    const interfaceFilesRelevant = Object.fromEntries((0, utils_js_1.objectEntries)(interfaceFilesAll)
         .filter(([locationId]) => {
         return (0, filesystemRouting_js_1.isInherited)(locationId, locationIdPage);
     })
@@ -597,7 +597,10 @@ function isInterfaceFileUserLand(interfaceFile) {
 async function getConfigValueSource(configName, interfaceFile, configDef, userRootDir, importedFilesLoaded, isHighestInheritancePrecedence) {
     const conf = interfaceFile.fileExportsByConfigName[configName];
     (0, utils_js_1.assert)(conf);
-    const { locationId } = interfaceFile;
+    const configValueSourceCommon = {
+        locationId: interfaceFile.locationId,
+        interfaceFile
+    };
     const definedAtFilePath_ = {
         ...interfaceFile.filePath,
         fileExportPathToShowToUser: ['default', configName]
@@ -625,7 +628,7 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
             };
         }
         const configValueSource = {
-            locationId,
+            ...configValueSourceCommon,
             value: valueFilePath,
             valueIsFilePath: true,
             configEnv: configDef.env,
@@ -644,7 +647,7 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
         const resolved = (0, resolvePointerImport_js_1.resolvePointerImportOfConfig)(configValue, interfaceFile.filePath, userRootDir, configDef.env, configName);
         if (resolved) {
             const configValueSource = {
-                locationId,
+                ...configValueSourceCommon,
                 configEnv: resolved.configEnvResolved,
                 valueIsImportedAtRuntime: true,
                 valueIsDefinedByPlusFile: false,
@@ -652,7 +655,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) {
@@ -668,7 +671,7 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
         }
         // Defined inside +config.js
         const configValueSource = {
-            locationId,
+            ...configValueSourceCommon,
             value: configValue,
             configEnv: configDef.env,
             valueIsImportedAtRuntime: false,
@@ -684,7 +687,7 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
         const valueAlreadyLoaded = 'configValue' in conf;
         (0, utils_js_1.assert)(valueAlreadyLoaded === !!configEnvResolved.config);
         const configValueSource = {
-            locationId,
+            ...configValueSourceCommon,
             configEnv: configEnvResolved,
             valueIsImportedAtRuntime: !valueAlreadyLoaded,
             valueIsDefinedByPlusFile: true,
@@ -1042,7 +1045,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) {
@@ -1052,6 +1055,17 @@ function isGlobalConfig(configName) {
     const configNamesGlobal = getConfigNamesGlobal();
     return (0, utils_js_1.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);
 }
@@ -1087,35 +1101,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/cjs/node/plugin/plugins/importUserCode/v1-design/getVirtualFilePageConfigValuesAll.js

@@ -24,7 +24,9 @@ async function getVirtualFilePageConfigValuesAll(id, isDev, config) {
     const { pageConfigs } = vikeConfig;
     const pageConfig = pageConfigs.find((pageConfig) => pageConfig.pageId === pageId);
     (0, utils_js_1.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);
     (0, debug_js_1.debug)(id, isForClientSide ? 'CLIENT-SIDE' : 'SERVER-SIDE', code);
     return code;
 }

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

@@ -28,12 +28,13 @@ function getCodePageConfigsSerialized(pageConfigs, isForClientSide, isClientRout
     const lines = [];
     pageConfigs.forEach((pageConfig) => {
         const { pageId, routeFilesystem, isErrorPage } = pageConfig;
-        const virtualFileIdPageConfigValuesAll = (0, virtualFilePageConfigValuesAll_js_1.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((0, virtualFilePageConfigValuesAll_js_1.getVirtualFileIdPageConfigValuesAll)(pageId, isForClientSide));
+        const load = `() => ({ moduleId: ${virtualFileId}, moduleExports: import(${virtualFileId}) })`;
+        lines.push(`    loadConfigValuesAll: ${load},`);
         lines.push(`    configValuesSerialized: {`);
         lines.push(...(0, serializeConfigValues_js_1.serializeConfigValues)(pageConfig, importStatements, (configEnv) => (0, isRuntimeEnvMatch_js_1.isRuntimeEnvMatch)(configEnv, { isForClientSide, isClientRouting, isDev }), '    ', true));
         lines.push(`    },`);

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

@@ -12,7 +12,7 @@ const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const index_js_1 = require("./devConfig/index.js");
 function previewConfig() {
     let config;
-    // let vikeConfigGlobal: VikeConfigGlobal
+    // let vikeConfig: VikeConfigObject
     return {
         name: 'vike:previewConfig',
         apply: utils_js_1.applyPreview,
@@ -27,8 +27,7 @@ function previewConfig() {
         async configResolved(config_) {
             config = config_;
             (0, index_js_1.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
@@ -38,7 +37,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/cjs/node/plugin/utils.js

@@ -18,7 +18,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 // 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.)
 const onLoad_js_1 = require("./onLoad.js");
 (0, onLoad_js_1.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
 __exportStar(require("../runtime/utils.js"), exports);
 // Utils only needed by `plugin/*`
 __exportStar(require("../../utils/viteIsSSR.js"), exports);

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPrerenderAutoRunEnabled = isPrerenderAutoRunEnabled;
+exports.temp_disablePrerenderAutoRun = temp_disablePrerenderAutoRun;
+exports.isPrerendering = isPrerendering;
+exports.setContextIsPrerendering = setContextIsPrerendering;
+const getGlobalObject_js_1 = require("../../utils/getGlobalObject.js");
+const resolvePrerenderConfig_js_1 = require("./resolvePrerenderConfig.js");
+const globalObject = (0, getGlobalObject_js_1.getGlobalObject)('prerender/context.ts', {});
+function isPrerenderAutoRunEnabled(vikeConfig) {
+    const prerenderConfig = (0, resolvePrerenderConfig_js_1.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/cjs/node/prerender/resolvePrerenderConfig.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolvePrerenderConfig = resolvePrerenderConfig;
+// TODO/now:
+// - prerender.value
+// - correct isPrerendering
+function resolvePrerenderConfig(prerenderConfigs) {
+    if (!prerenderConfigs || prerenderConfigs.every((configVal) => !configVal)) {
+        return false;
+    }
+    const prerenderSettings = prerenderConfigs.filter(isObject2);
+    const prerenderConfig = {
+        partial: pickFirst(prerenderSettings.map((c) => c.partial)) ?? false,
+        noExtraDir: pickFirst(prerenderSettings.map((c) => c.noExtraDir)) ?? false,
+        parallel: pickFirst(prerenderSettings.map((c) => c.parallel)) ?? true,
+        disableAutoRun: pickFirst(prerenderSettings.map((c) => c.disableAutoRun)) ?? false
+    };
+    return prerenderConfig;
+}
+function isObject2(p) {
+    return typeof p === 'object';
+}
+function pickFirst(arr) {
+    return arr.filter((v) => v !== undefined)[0];
+}