vike 0.4.225 → 0.4.226-commit-8f5c172

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

@@ -1,12 +1,13 @@
 export { getVikeConfig };
+export { getVikeConfigOptional };
 export { getVikeConfig2 };
 export { reloadVikeConfig };
-export { vikeConfigDependencies };
 export { isV1Design };
 export { getConfVal };
 export { getConfigDefinitionOptional };
+export { getVikeConfigFromCliOrEnv };
 export { isOverriden };
-import { assertPosixPath, assert, isObject, assertUsage, assertWarning, objectEntries, hasProp, includes, assertIsNotProductionRuntime, getMostSimilar, joinEnglish, assertKeys, objectKeys, objectFromEntries, unique, isCallable, makeFirst, lowerFirst, makeLast } from '../../../utils.js';
+import { assertPosixPath, assert, isObject, assertUsage, assertWarning, objectEntries, hasProp, includes, assertIsNotProductionRuntime, getMostSimilar, joinEnglish, assertKeys, objectKeys, objectFromEntries, unique, isCallable, makeFirst, lowerFirst, makeLast, assertIsSingleModuleInstance } from '../../../utils.js';
 import { configDefinitionsBuiltIn } from './getVikeConfig/configDefinitionsBuiltIn.js';
 import { getLocationId, getFilesystemRouteString, getFilesystemRouteDefinedBy, isInherited, sortAfterInheritanceOrder, applyFilesystemRoutingRootEffect } from './getVikeConfig/filesystemRouting.js';
 import { isVikeConfigInvalid, isVikeConfigInvalid_set } from '../../../../runtime/renderPage/isVikeConfigInvalid.js';
@@ -14,7 +15,7 @@ import { getViteDevServer } from '../../../../runtime/globalContext.js';
 import { logConfigError, logConfigErrorRecover } from '../../../shared/loggerNotProd.js';
 import { removeSuperfluousViteLog_enable, removeSuperfluousViteLog_disable } from '../../../shared/loggerVite/removeSuperfluousViteLog.js';
 import pc from '@brillout/picocolors';
-import { getConfigDefinedAt } from '../../../../../shared/page-configs/getConfigDefinedAt.js';
+import { getConfigDefinedAt, getDefinedByString } from '../../../../../shared/page-configs/getConfigDefinedAt.js';
 import { loadPointerImport, loadValueFile } from './getVikeConfig/loadFileAtConfigTime.js';
 import { resolvePointerImport } from './getVikeConfig/resolvePointerImport.js';
 import { getFilePathResolved } from '../../../shared/getFilePath.js';
@@ -27,16 +28,14 @@ import { getEnvVarObject } from '../../../shared/getEnvVarObject.js';
 import { getApiOperation } from '../../../../api/context.js';
 import { getCliOptions } from '../../../../cli/context.js';
 assertIsNotProductionRuntime();
+assertIsSingleModuleInstance('v1-design/getVikeConfig.ts');
 let restartVite = false;
 let wasConfigInvalid = null;
 let vikeConfigPromise = null;
-const vikeConfigDependencies = new Set();
 function reloadVikeConfig(config) {
     const userRootDir = config.root;
     const vikeVitePluginOptions = config._vikeVitePluginOptions;
     assert(vikeVitePluginOptions);
-    // TODO/now: unify with esbuildCache
-    vikeConfigDependencies.clear();
     vikeConfigPromise = loadVikeConfig_withErrorHandling(userRootDir, true, vikeVitePluginOptions);
     handleReloadSideEffects();
 }
@@ -90,6 +89,11 @@ async function getVikeConfigEntry(userRootDir, isDev, vikeVitePluginOptions, doN
     }
     return await vikeConfigPromise;
 }
+async function getVikeConfigOptional() {
+    if (!vikeConfigPromise)
+        return null;
+    return await vikeConfigPromise;
+}
 function isV1Design(config) {
     const vikeConfig = config._vikeConfigObject;
     assert(vikeConfig);
@@ -134,22 +138,24 @@ async function loadVikeConfig_withErrorHandling(userRootDir, isDev, vikeVitePlug
                     configValueSources: {}
                 },
                 global: getPageConfigGlobalUserFriendly({ pageConfigGlobalValues: {} }),
-                pages: {}
+                pages: {},
+                vikeConfigDependencies: new Set()
             };
             return dummyData;
         }
     }
 }
 async function loadVikeConfig(userRootDir, vikeVitePluginOptions) {
-    const esbuildCache = {};
+    const esbuildCache = {
+        transpileCache: {},
+        vikeConfigDependencies: new Set()
+    };
     const plusFilesAll = await getPlusFilesAll(userRootDir, esbuildCache);
     const configDefinitionsResolved = await resolveConfigDefinitions(plusFilesAll, userRootDir, esbuildCache);
-    assertKnownConfigs(configDefinitionsResolved, plusFilesAll);
     const { pageConfigGlobal, pageConfigs } = getPageConfigsBuildTime(configDefinitionsResolved, plusFilesAll, userRootDir);
     // Backwards compatibility for vike(options) in vite.config.js
     temp_interopVikeVitePlugin(pageConfigGlobal, vikeVitePluginOptions, userRootDir);
-    // TODO/now: add validation
-    setCliAndApiOptions(pageConfigGlobal);
+    setCliAndApiOptions(pageConfigGlobal, configDefinitionsResolved);
     // global
     const pageConfigGlobalValues = getConfigValues(pageConfigGlobal);
     const global = getPageConfigGlobalUserFriendly({ pageConfigGlobalValues });
@@ -158,7 +164,7 @@ async function loadVikeConfig(userRootDir, vikeVitePluginOptions) {
         const pageConfigValues = getConfigValues(pageConfig, true);
         return getPageConfigUserFriendly(pageConfigGlobalValues, pageConfig, pageConfigValues);
     }));
-    return { pageConfigs, pageConfigGlobal, global, pages };
+    return { pageConfigs, pageConfigGlobal, global, pages, vikeConfigDependencies: esbuildCache.vikeConfigDependencies };
 }
 async function resolveConfigDefinitions(plusFilesAll, userRootDir, esbuildCache) {
     const plusFilesAllOrdered = Object.values(plusFilesAll)
@@ -168,6 +174,10 @@ async function resolveConfigDefinitions(plusFilesAll, userRootDir, esbuildCache)
     // We use `plusFilesAll` in order to allow local Vike extensions to create global configs, and to set the value of global configs such as `+vite` (enabling Vike extensions to add Vite plugins).
     plusFilesAllOrdered, (configDef) => !!configDef.global);
     await loadCustomConfigBuildTimeFiles(plusFilesAll, configDefinitionsGlobal, userRootDir, esbuildCache);
+    const configDefinitionsAll = getConfigDefinitions(Object.values(plusFilesAll).flat());
+    const configNamesKnownAll = Object.keys(configDefinitionsAll);
+    const configNamesKnownGlobal = Object.keys(configDefinitionsGlobal);
+    assert(configNamesKnownGlobal.every((configName) => configNamesKnownAll.includes(configName)));
     const configDefinitionsLocal = {};
     await Promise.all(objectEntries(plusFilesAll).map(async ([locationIdPage, plusFiles]) => {
         const plusFilesRelevant = objectEntries(plusFilesAll)
@@ -177,12 +187,23 @@ async function resolveConfigDefinitions(plusFilesAll, userRootDir, esbuildCache)
             .sort((plusFile1, plusFile2) => sortAfterInheritanceOrderPage(plusFile1, plusFile2, locationIdPage, null));
         const configDefinitions = getConfigDefinitions(plusFilesRelevant, (configDef) => configDef.global !== true);
         await loadCustomConfigBuildTimeFiles(plusFiles, configDefinitions, userRootDir, esbuildCache);
-        configDefinitionsLocal[locationIdPage] = { configDefinitions, plusFiles, plusFilesRelevant };
+        const configNamesKnownLocal = unique([...Object.keys(configDefinitions), ...configNamesKnownGlobal]);
+        assert(configNamesKnownLocal.every((configName) => configNamesKnownAll.includes(configName)));
+        configDefinitionsLocal[locationIdPage] = {
+            configDefinitions,
+            plusFiles,
+            plusFilesRelevant,
+            configNamesKnownLocal
+        };
     }));
     const configDefinitionsResolved = {
         configDefinitionsGlobal,
-        configDefinitionsLocal
+        configDefinitionsLocal,
+        configDefinitionsAll,
+        configNamesKnownAll,
+        configNamesKnownGlobal
     };
+    assertKnownConfigs(configDefinitionsResolved);
     return configDefinitionsResolved;
 }
 // Load value files (with `env.config===true`) of *custom* configs.
@@ -285,7 +306,7 @@ function assertGlobalConfigLocation(configName, sources, plusFilesAll, configDef
                 : 'to a value that is global';
             const what = isConditionallyGlobal ? 'global values' : pc.cyan(configName);
             const errEnd = configFilePathsGlobal.length > 0
-                ? `define ${what} at a global config file such as ${joinEnglish(configFilePathsGlobal, 'or')} instead`
+                ? `define ${what} at a global config file such as ${joinEnglish(configFilePathsGlobal.map(pc.bold), 'or')} instead`
                 : `create a global config file (e.g. /pages/+config.js) and define ${what} there instead`;
             // When updating this error message => also update error message at https://vike.dev/warning/global-config
             const errMsg = `${errBeg} ${errMid}: ${errEnd} (https://vike.dev/warning/global-config).`;
@@ -354,56 +375,55 @@ function temp_interopVikeVitePlugin(pageConfigGlobal, vikeVitePluginOptions, use
     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(configDefinitionsBuiltIn), configName));
-        const configDef = configDefinitionsBuiltIn[configName];
         const sources = ((_a = pageConfigGlobal.configValueSources)[configName] ?? (_a[configName] = []));
-        // TODO/now: use getSourceNonConfigFile()
-        sources.push({
-            valueIsLoaded: true,
-            value,
-            configEnv: configDef.env,
-            definedAtFilePath: {
-                ...getFilePathResolved({
-                    userRootDir,
-                    filePathAbsoluteUserRootDir: '/vite.config.js'
-                }),
-                fileExportPathToShowToUser: null
-            },
-            locationId: '/',
-            plusFile: null,
-            valueIsLoadedWithImport: false,
-            valueIsDefinedByPlusValueFile: false
-        });
+        sources.push(getSourceNonConfigFile(configName, value, {
+            ...getFilePathResolved({
+                userRootDir,
+                filePathAbsoluteUserRootDir: '/vite.config.js'
+            }),
+            fileExportPathToShowToUser: null
+        }));
     });
 }
-function setCliAndApiOptions(pageConfigGlobal) {
-    // VIKE_CONFIG
-    const configFromEnv = getEnvVarObject('VIKE_CONFIG');
-    if (configFromEnv) {
-        add(configFromEnv, { definedBy: 'env' });
-    }
-    // Vike API — passed options
+function setCliAndApiOptions(pageConfigGlobal, configDefinitionsResolved) {
+    // Vike API — passed options [lowest precedence]
     const apiOperation = getApiOperation();
     if (apiOperation?.options.vikeConfig) {
-        add(apiOperation.options.vikeConfig, {
-            definedBy: 'api',
-            operation: apiOperation.operation
-        });
+        addSources(apiOperation.options.vikeConfig, { definedBy: 'api', operation: apiOperation.operation }, false);
     }
+    const { configFromCliOptions, configFromEnvVar } = getVikeConfigFromCliOrEnv();
     // Vike CLI options
-    const cliOptions = getCliOptions();
-    if (cliOptions) {
-        add(cliOptions, { definedBy: 'cli' });
+    if (configFromCliOptions) {
+        addSources(configFromCliOptions, { definedBy: 'cli' }, true);
+    }
+    // VIKE_CONFIG [highest precedence]
+    if (configFromEnvVar) {
+        addSources(configFromEnvVar, { definedBy: 'env' }, false);
     }
     return;
-    function add(configValues, definedBy) {
+    function addSources(configValues, definedBy, exitOnError) {
         Object.entries(configValues).forEach(([configName, value]) => {
             var _a;
+            const sourceName = `The ${getDefinedByString(definedBy, configName)}`;
+            assertKnownConfig(configName, configDefinitionsResolved.configNamesKnownGlobal, configDefinitionsResolved, '/', sourceName, exitOnError);
             const sources = ((_a = pageConfigGlobal.configValueSources)[configName] ?? (_a[configName] = []));
             sources.unshift(getSourceNonConfigFile(configName, value, definedBy));
         });
     }
 }
+function getVikeConfigFromCliOrEnv() {
+    const configFromCliOptions = getCliOptions();
+    const configFromEnvVar = getEnvVarObject('VIKE_CONFIG');
+    const vikeConfigFromCliOrEnv = {
+        ...configFromCliOptions, // Lower precedence
+        ...configFromEnvVar // Higher precedence
+    };
+    return {
+        vikeConfigFromCliOrEnv,
+        configFromCliOptions,
+        configFromEnvVar
+    };
+}
 function getSourceNonConfigFile(configName, value, definedAt) {
     assert(includes(objectKeys(configDefinitionsBuiltIn), configName));
     const configDef = configDefinitionsBuiltIn[configName];
@@ -411,7 +431,7 @@ function getSourceNonConfigFile(configName, value, definedAt) {
         valueIsLoaded: true,
         value,
         configEnv: configDef.env,
-        definedAtFilePath: definedAt,
+        definedAt,
         locationId: '/',
         plusFile: null,
         valueIsLoadedWithImport: false,
@@ -527,7 +547,7 @@ function resolveConfigValueSources(configName, configDef, plusFilesRelevant, use
     return sources;
 }
 function isDefiningConfig(plusFile, configName) {
-    return getDefiningConfigNames(plusFile).includes(configName);
+    return getConfigNamesSetByPlusFile(plusFile).includes(configName);
 }
 function getConfigValueSource(configName, plusFile, configDef, userRootDir) {
     const confVal = getConfVal(plusFile, configName);
@@ -570,7 +590,7 @@ function getConfigValueSource(configName, plusFile, configDef, userRootDir) {
             configEnv: configDef.env,
             valueIsLoadedWithImport: false,
             valueIsDefinedByPlusValueFile: false,
-            definedAtFilePath
+            definedAt: definedAtFilePath
         };
         return configValueSource;
     }
@@ -594,7 +614,7 @@ function getConfigValueSource(configName, plusFile, configDef, userRootDir) {
                 configEnv: resolveConfigEnv(configDef.env, pointerImport.fileExportPath),
                 valueIsLoadedWithImport: true,
                 valueIsDefinedByPlusValueFile: false,
-                definedAtFilePath: pointerImport.fileExportPath
+                definedAt: pointerImport.fileExportPath
             };
             return configValueSource;
         }
@@ -606,7 +626,7 @@ function getConfigValueSource(configName, plusFile, configDef, userRootDir) {
             configEnv: configDef.env,
             valueIsLoadedWithImport: false,
             valueIsDefinedByPlusValueFile: false,
-            definedAtFilePath: definedAtFilePath_
+            definedAt: definedAtFilePath_
         };
         return configValueSource;
     }
@@ -620,7 +640,7 @@ function getConfigValueSource(configName, plusFile, configDef, userRootDir) {
             configEnv: configEnvResolved,
             valueIsLoadedWithImport: !confVal.valueIsLoaded || !isJsonValue(confVal.value),
             valueIsDefinedByPlusValueFile: true,
-            definedAtFilePath: {
+            definedAt: {
                 ...plusFile.filePath,
                 fileExportPathToShowToUser: configName === plusFile.configName
                     ? []
@@ -634,7 +654,7 @@ function getConfigValueSource(configName, plusFile, configDef, userRootDir) {
 }
 function isDefiningPage(plusFiles) {
     for (const plusFile of plusFiles) {
-        const configNames = getDefiningConfigNames(plusFile);
+        const configNames = getConfigNamesSetByPlusFile(plusFile);
         if (configNames.some((configName) => isDefiningPageConfig(configName))) {
             return true;
         }
@@ -656,7 +676,7 @@ function resolveIsGlobalValue(configDefGlobal, source, plusFilesAll) {
     assert(typeof isGlobal === 'boolean');
     return isGlobal;
 }
-function getDefiningConfigNames(plusFile) {
+function getConfigNamesSetByPlusFile(plusFile) {
     let configNames = [];
     if (!plusFile.isConfigFile) {
         configNames.push(plusFile.configName);
@@ -776,7 +796,7 @@ function runEffect(configName, configDef, source) {
     // Call effect
     const configModFromEffect = configDef.effect({
         configValue: source.value,
-        configDefinedAt: getConfigDefinedAt('Config', configName, source.definedAtFilePath)
+        configDefinedAt: getConfigDefinedAt('Config', configName, source.definedAt)
     });
     if (!configModFromEffect)
         return null;
@@ -790,7 +810,7 @@ function applyEffectConfVal(configModFromEffect, sourceEffect, configValueSource
         assert(configDef);
         assert(configDefEffect._userEffectDefinedAtFilePath);
         const configValueSource = {
-            definedAtFilePath: configDefEffect._userEffectDefinedAtFilePath,
+            definedAt: configDefEffect._userEffectDefinedAtFilePath,
             plusFile: sourceEffect.plusFile,
             locationId: sourceEffect.locationId,
             configEnv: configDef.env,
@@ -853,33 +873,30 @@ function getComputed(configValueSources, configDefinitions) {
     return configValuesComputed;
 }
 // Show error message upon unknown config
-function assertKnownConfigs(configDefinitionsResolved, plusFilesAll) {
-    const configDefinitionsAll = getConfigDefinitions(Object.values(plusFilesAll).flat());
-    const configNamesKnownAll = Object.keys(configDefinitionsAll);
-    const configNamesGlobal = Object.keys(configDefinitionsResolved.configDefinitionsGlobal);
-    objectEntries(configDefinitionsResolved.configDefinitionsLocal).forEach(([_locationId, { configDefinitions, plusFiles }]) => {
-        const configDefinitionsLocal = configDefinitions;
-        const configNamesKnownLocal = [...Object.keys(configDefinitionsLocal), ...configNamesGlobal];
+function assertKnownConfigs(configDefinitionsResolved) {
+    objectEntries(configDefinitionsResolved.configDefinitionsLocal).forEach(([_locationId, { configNamesKnownLocal, plusFiles }]) => {
         plusFiles.forEach((plusFile) => {
-            const configNames = getDefiningConfigNames(plusFile);
+            const configNames = getConfigNamesSetByPlusFile(plusFile);
             configNames.forEach((configName) => {
-                assertKnownConfig(configName, configNamesKnownAll, configNamesKnownLocal, plusFile);
-                assert(configNamesKnownLocal.includes(configName));
-                assert(configNamesKnownAll.includes(configName));
+                const { locationId } = plusFile;
+                const sourceName = plusFile.filePath.filePathToShowToUser;
+                assertKnownConfig(configName, configNamesKnownLocal, configDefinitionsResolved, locationId, sourceName, false);
             });
         });
     });
 }
-function assertKnownConfig(configName, configNamesKnownAll, configNamesKnownLocal, plusFile) {
-    if (configNamesKnownLocal.includes(configName))
+function assertKnownConfig(configName, configNamesKnownRelevant, configDefinitionsResolved, locationId, sourceName, exitOnError) {
+    const { configNamesKnownAll } = configDefinitionsResolved;
+    if (configNamesKnownRelevant.includes(configName)) {
+        assert(configNamesKnownAll.includes(configName));
         return;
+    }
     const configNameColored = pc.cyan(configName);
-    const { locationId, filePath: { filePathToShowToUser } } = plusFile;
-    const errMsg = `${filePathToShowToUser} sets an unknown config ${configNameColored}`;
     // Inheritance issue: config is known but isn't defined at `locationId`
     if (configNamesKnownAll.includes(configName)) {
-        assertUsage(false, `${filePathToShowToUser} sets the value of the config ${configNameColored} which is a custom config that is defined with ${pc.underline('https://vike.dev/meta')} at a path that doesn't apply to ${locationId} — see ${pc.underline('https://vike.dev/config#inheritance')}`);
+        assertUsage(false, `${sourceName} sets the value of the config ${configNameColored} which is a custom config that is defined with ${pc.underline('https://vike.dev/meta')} at a path that doesn't apply to ${locationId} — see ${pc.underline('https://vike.dev/config#inheritance')}`, { exitOnError });
     }
+    const errMsg = `${sourceName} sets an unknown config ${configNameColored}`;
     // Missing vike-{react,vue,solid} installation
     {
         const ui = ['vike-react', 'vike-vue', 'vike-solid'];
@@ -895,11 +912,9 @@ function assertKnownConfig(configName, configNamesKnownAll, configNamesKnownLoca
             Wrapper: ui
         };
         if (configName in knownVikeExntensionConfigs) {
-            const requiredVikeExtension = knownVikeExntensionConfigs[configName]
-                .map((e) => pc.bold(e))
-                .join('/');
+            const requiredVikeExtension = joinEnglish(knownVikeExntensionConfigs[configName].map((e) => pc.bold(e)), 'or');
             const errMsgEnhanced = `${errMsg}. If you want to use the configuration ${configNameColored} documented at ${pc.underline(`https://vike.dev/${configName}`)} then make sure to install ${requiredVikeExtension}. (Alternatively, you can define ${configNameColored} yourself by using ${pc.cyan('meta')}, see ${pc.underline('https://vike.dev/meta')} for more information.)`;
-            assertUsage(false, errMsgEnhanced);
+            assertUsage(false, errMsgEnhanced, { exitOnError });
         }
     }
     // Similarity hint
@@ -916,9 +931,9 @@ function assertKnownConfig(configName, configNamesKnownAll, configNamesKnownLoca
         if (configName === 'page') {
             errMsgEnhanced += ` (The name of the config ${pc.cyan('Page')} starts with a capital letter ${pc.cyan('P')} because it defines a UI component: a ubiquitous JavaScript convention is that the name of UI components start with a capital letter.)`;
         }
-        assertUsage(false, errMsgEnhanced);
+        assertUsage(false, errMsgEnhanced, { exitOnError });
     }
-    assertUsage(false, errMsg);
+    assertUsage(false, errMsg, { exitOnError });
 }
 function determineRouteFilesystem(locationId, configValueSources) {
     const configName = 'filesystemRoutingRoot';
@@ -950,12 +965,12 @@ function getFilesystemRoutingRootEffect(configFilesystemRoutingRoot, configName)
     // Eagerly loaded since it's config-only
     assert(configFilesystemRoutingRoot.valueIsLoaded);
     const { value } = configFilesystemRoutingRoot;
-    const configDefinedAt = getConfigDefinedAt('Config', configName, configFilesystemRoutingRoot.definedAtFilePath);
+    const configDefinedAt = getConfigDefinedAt('Config', configName, configFilesystemRoutingRoot.definedAt);
     assertUsage(typeof value === 'string', `${configDefinedAt} should be a string`);
     assertUsage(value.startsWith('/'), `${configDefinedAt} is ${pc.cyan(value)} but it should start with a leading slash ${pc.cyan('/')}`);
-    const { definedAtFilePath } = configFilesystemRoutingRoot;
-    assert(!definedAtFilePath.definedBy);
-    const { filePathAbsoluteUserRootDir } = definedAtFilePath;
+    const { definedAt } = configFilesystemRoutingRoot;
+    assert(!definedAt.definedBy);
+    const { filePathAbsoluteUserRootDir } = definedAt;
     assert(filePathAbsoluteUserRootDir);
     const before = getFilesystemRouteString(getLocationId(filePathAbsoluteUserRootDir));
     const after = value;
@@ -1006,7 +1021,7 @@ function getConfigDefinitionOptional(configDefinitions, configName) {
     return configDefinitions[configName] ?? null;
 }
 function getConfVal(plusFile, configName) {
-    const configNames = getDefiningConfigNames(plusFile);
+    const configNames = getConfigNamesSetByPlusFile(plusFile);
     if (!configNames.includes(configName))
         return null;
     if (plusFile.isNotLoaded)

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

@@ -1,15 +1,23 @@
 export { setGlobalContext };
 import { setGlobalContext_viteDevServer, setGlobalContext_viteConfig, setGlobalContext_isProduction } from '../../runtime/globalContext.js';
-import { assertFilePathAbsoluteFilesystem, isDevCheck, markSetup_isViteDev, markSetup_viteDevServer, markSetup_vitePreviewServer } from '../utils.js';
+import { assert, assertFilePathAbsoluteFilesystem, isDevCheck, markSetup_isViteDev, markSetup_viteDevServer, markSetup_vitePreviewServer } from '../utils.js';
 import { getOutDirs } from '../shared/getOutDirs.js';
+import { reloadVikeConfig } from './importUserCode/v1-design/getVikeConfig.js';
 function setGlobalContext() {
+    let isServerReload = false;
+    let config;
     return [
         {
             name: 'vike:setGlobalContext:pre',
             enforce: 'pre',
+            // This hook is called not only at server start but also at server restart (a new `viteDevServer` instance is created)
             configureServer: {
                 order: 'pre',
                 handler(viteDevServer) {
+                    assert(config);
+                    if (isServerReload)
+                        reloadVikeConfig(config);
+                    isServerReload = true;
                     setGlobalContext_viteDevServer(viteDevServer);
                     markSetup_viteDevServer();
                 }
@@ -31,7 +39,8 @@ function setGlobalContext() {
             enforce: 'post',
             configResolved: {
                 order: 'post',
-                async handler(config) {
+                async handler(config_) {
+                    config = config_;
                     const { outDirRoot } = getOutDirs(config);
                     assertFilePathAbsoluteFilesystem(outDirRoot); // Needed for `importServerProductionEntry({ outDir })` of @brillout/vite-plugin-server-entry
                     setGlobalContext_viteConfig(config, outDirRoot);

package/dist/esm/node/plugin/shared/getEnvVarObject.js

@@ -18,8 +18,15 @@ function parseJson5(valueStr, what) {
         value = JSON5.parse(valueStr);
     }
     catch (err) {
+        if (isNotJavaScriptLike(valueStr)) {
+            // Interpret as string
+            return valueStr;
+        }
         console.error(err);
         assertUsage(false, `Cannot parse ${pc.cyan(what)} (see error above) because it's set to the following which isn't a valid JSON5 string: ${pc.bold(valueStr)}`);
     }
     return value;
 }
+function isNotJavaScriptLike(valueStr) {
+    return ![':', ',', '{', '}', '(', ')'].some((c) => valueStr.includes(c));
+}

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

@@ -15,8 +15,8 @@ function resolvePrerenderConfigGlobal(vikeConfig) {
     };
     let defaultLocalValue = false;
     {
-        const valueFirst = prerenderConfigs.filter((p) => !isObject(p) || p.value !== null)[0];
-        if (valueFirst === true || (isObject(valueFirst) && (valueFirst.value ?? defaultValueForObject))) {
+        const valueFirst = prerenderConfigs.filter((p) => !isObject(p) || p.enable !== null)[0];
+        if (valueFirst === true || (isObject(valueFirst) && (valueFirst.enable ?? defaultValueForObject))) {
             defaultLocalValue = true;
         }
     }
@@ -47,7 +47,7 @@ function resolvePrerenderConfigLocal(pageConfig) {
     const values = configValue.value;
     assert(isArray(values));
     const value = values[0];
-    // TODO/now I believe this assert() can fail
+    // If it's set to an object in a local config then Vike considers it a global config and it's skipped from local inheritance, thus we can assume the value to be a boolean.
     assert(typeof value === 'boolean');
     assert(isArray(configValue.definedAtData));
     const prerenderConfigLocal = { value };

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

@@ -46,7 +46,7 @@ declare function runPrerenderFromAPI(options?: PrerenderOptions): Promise<{
     viteConfig: ResolvedConfig;
 }>;
 declare function runPrerenderFromCLIPrerenderCommand(): Promise<void>;
-declare function runPrerenderFromAutoRun(viteConfig: InlineConfig | undefined, config: ResolvedConfig): Promise<{
+declare function runPrerenderFromAutoRun(viteConfig: InlineConfig | undefined): Promise<{
     forceExit: boolean;
 }>;
 declare function runPrerender_forceExit(): void;

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

@@ -38,8 +38,8 @@ async function runPrerenderFromAPI(options = {}) {
 }
 async function runPrerenderFromCLIPrerenderCommand() {
     try {
-        const { viteConfigEnhanced } = await prepareViteApiCall({}, 'prerender');
-        await runPrerender({ viteConfig: viteConfigEnhanced }, '$ vike prerender');
+        const { viteConfigFromUserEnhanced } = await prepareViteApiCall({}, 'prerender');
+        await runPrerender({ viteConfig: viteConfigFromUserEnhanced }, '$ vike prerender');
     }
     catch (err) {
         console.error(err);
@@ -50,11 +50,9 @@ async function runPrerenderFromCLIPrerenderCommand() {
     runPrerender_forceExit();
     assert(false);
 }
-async function runPrerenderFromAutoRun(viteConfig, config) {
-    let prerenderContextPublic;
+async function runPrerenderFromAutoRun(viteConfig) {
     try {
-        const ret = await runPrerender({ viteConfig });
-        prerenderContextPublic = ret.prerenderContextPublic;
+        await runPrerender({ viteConfig });
     }
     catch (err) {
         // Avoid Rollup prefixing the error with [vike:build:pluginAutoFullBuild], see for example https://github.com/vikejs/vike/issues/472#issuecomment-1276274203
@@ -62,8 +60,6 @@ async function runPrerenderFromAutoRun(viteConfig, config) {
         logErrorHint(err);
         process.exit(1);
     }
-    const vike = getVikeConfigPublic(config);
-    vike.prerenderContext = prerenderContextPublic;
     const forceExit = isVikeCli() || isViteCliCall();
     return { forceExit };
 }
@@ -80,6 +76,8 @@ async function runPrerender(options = {}, standaloneTrigger) {
     await disableReactStreaming();
     const viteConfig = await resolveConfig(options.viteConfig || {}, 'build', 'production');
     const vikeConfig = await getVikeConfig(viteConfig);
+    const vike = getVikeConfigPublic(viteConfig);
+    assert(vike.prerenderContext.isPrerenderingEnabled);
     const { outDirClient } = getOutDirs(viteConfig);
     const { root } = viteConfig;
     const prerenderConfigGlobal = resolvePrerenderConfigGlobal(vikeConfig);
@@ -123,7 +121,8 @@ async function runPrerender(options = {}, standaloneTrigger) {
     }
     await warnMissingPages(prerenderContext.prerenderedPageContexts, globalContext, doNotPrerenderList, partial);
     const prerenderContextPublic = makePublic(prerenderContext);
-    return { viteConfig, prerenderContextPublic };
+    objectAssign(vike.prerenderContext, prerenderContextPublic);
+    return { viteConfig };
 }
 async function collectDoNoPrerenderList(pageConfigs, doNotPrerenderList, defaultLocalValue, concurrencyLimit, globalContext) {
     // V1 design
@@ -304,20 +303,16 @@ async function handlePagesWithStaticRoutes(prerenderContext, globalContext, doNo
     })));
 }
 async function createPageContext(urlOriginal, prerenderContext, globalContext) {
-    const pageContext = {
+    const pageContextInit = { urlOriginal };
+    objectAssign(pageContextInit, prerenderContext.pageContextInit);
+    const pageContext = await getPageContextInitEnhanced(pageContextInit, globalContext, true, {});
+    assert(pageContext.isPrerendering === true);
+    objectAssign(pageContext, {
         _urlHandler: null,
         _urlRewrite: null,
         _noExtraDir: prerenderContext.noExtraDir,
         _prerenderContext: prerenderContext
-    };
-    const pageContextInit = {
-        urlOriginal
-    };
-    objectAssign(pageContextInit, prerenderContext.pageContextInit);
-    {
-        const pageContextInitEnhanced = await getPageContextInitEnhanced(pageContextInit, globalContext);
-        objectAssign(pageContext, pageContextInitEnhanced);
-    }
+    });
     return pageContext;
 }
 async function callOnPrerenderStartHook(prerenderContext, globalContext) {
@@ -596,6 +591,12 @@ async function write(urlOriginal, pageContext, fileType, fileContent, root, outD
     assertPosixPath(outDirClient);
     assertPosixPath(filePathRelative);
     const filePath = path.posix.join(outDirClient, filePathRelative);
+    objectAssign(pageContext, {
+        _prerenderResult: {
+            filePath,
+            fileContent
+        }
+    });
     output.push({
         filePath,
         fileType,
@@ -603,15 +604,7 @@ async function write(urlOriginal, pageContext, fileType, fileContent, root, outD
         pageContext
     });
     if (onPagePrerender) {
-        const prerenderPageContext = {};
-        objectAssign(prerenderPageContext, pageContext);
-        objectAssign(prerenderPageContext, {
-            _prerenderResult: {
-                filePath,
-                fileContent
-            }
-        });
-        await onPagePrerender(prerenderPageContext);
+        await onPagePrerender(pageContext);
     }
     else {
         const { promises } = await import('fs');

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

@@ -15,4 +15,4 @@ export * from '../../utils/isArray.js';
 export * from '../../utils/isObject.js';
 export * from '../../utils/changeEnumerable.js';
 export * from '../../utils/makePublicCopy.js';
-export * from '../../utils/isNotNullish.js';
+export * from '../../utils/isNullish.js';

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

@@ -17,4 +17,4 @@ export * from '../../utils/isArray.js';
 export * from '../../utils/isObject.js';
 export * from '../../utils/changeEnumerable.js';
 export * from '../../utils/makePublicCopy.js';
-export * from '../../utils/isNotNullish.js';
+export * from '../../utils/isNullish.js';

package/dist/esm/node/runtime/globalContext.d.ts

@@ -21,7 +21,6 @@ export type { GlobalContextPublic };
 import type { ViteManifest } from '../shared/ViteManifest.js';
 import type { ResolvedConfig, ViteDevServer } from 'vite';
 import type { PageConfigUserFriendly, PageConfigsUserFriendly } from '../../shared/page-configs/getPageConfigUserFriendly.js';
-import type { ConfigVitePluginServerEntry } from '@brillout/vite-plugin-server-entry/plugin';
 import { type BaseUrlsResolved } from '../shared/resolveBase.js';
 type PageRuntimeInfo = Awaited<ReturnType<typeof getUserFiles>>;
 type GlobalContextInternal = GlobalContext & {
@@ -84,11 +83,11 @@ type BuildInfo = {
     viteConfigRuntime: {
         _baseViteOriginal: string;
         vitePluginServerEntry: {
-            inject?: NonNullable<ConfigVitePluginServerEntry['vitePluginServerEntry']>['inject'];
+            inject?: boolean;
         };
     };
 };
 declare function assertBuildInfo(buildInfo: unknown): asserts buildInfo is BuildInfo;
-declare function getViteConfigRuntime(viteConfig: ResolvedConfig & ConfigVitePluginServerEntry): BuildInfo['viteConfigRuntime'];
+declare function getViteConfigRuntime(viteConfig: ResolvedConfig): BuildInfo['viteConfigRuntime'];
 declare function updateUserFiles(): Promise<void>;
 declare function clearGlobalContext(): void;