vike 0.4.144-commit-6aef8a6 → 0.4.144-commit-f7ab002

package/dist/cjs/shared/page-configs/helpers/getConfigValue.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConfigValue = void 0;
+const utils_js_1 = require("../../utils.js");
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+const getConfigDefinedAtString_js_1 = require("./getConfigDefinedAtString.js");
+// prettier-ignore
+function getConfigValue(pageConfig, configName, type) {
+    const configValue = getConfigValueEntry(pageConfig, configName);
+    if (configValue === null)
+        return null;
+    const { value, definedAt } = configValue;
+    if (type)
+        assertConfigValueType(value, type, configName, definedAt);
+    return configValue;
+}
+exports.getConfigValue = getConfigValue;
+function assertConfigValueType(value, type, configName, definedAt) {
+    (0, utils_js_1.assert)(value !== null);
+    const typeActual = typeof value;
+    if (typeActual === type)
+        return;
+    const valuePrintable = (0, utils_js_1.getValuePrintable)(value);
+    const problem = valuePrintable !== null
+        ? `value ${picocolors_1.default.cyan(valuePrintable)}`
+        : `type ${picocolors_1.default.cyan(typeActual)}`;
+    const configDefinedAt = (0, getConfigDefinedAtString_js_1.getConfigDefinedAtString)('Config', configName, {
+        definedAt
+    });
+    const errMsg = `${configDefinedAt} has an invalid ${problem}: it should be a ${picocolors_1.default.cyan(type)} instead`;
+    (0, utils_js_1.assertUsage)(false, errMsg);
+}
+function getConfigValueEntry(pageConfig, configName) {
+    const configValue = pageConfig.configValues[configName];
+    if (!configValue)
+        return null;
+    // Enable users to suppress global config values by setting the local config value to null
+    if (configValue.value === null)
+        return null;
+    return configValue;
+}

package/dist/cjs/shared/page-configs/helpers.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConfigValue = exports.getDefinedAtString = exports.getConfigDefinedAtString = exports.getHookFilePathToShowToUser = exports.getConfigValueFilePathToShowToUser = exports.getPageConfig = void 0;
+var getConfigDefinedAtString_js_1 = require("./helpers/getConfigDefinedAtString.js");
+Object.defineProperty(exports, "getConfigDefinedAtString", { enumerable: true, get: function () { return getConfigDefinedAtString_js_1.getConfigDefinedAtString; } });
+Object.defineProperty(exports, "getDefinedAtString", { enumerable: true, get: function () { return getConfigDefinedAtString_js_1.getDefinedAtString; } });
+var getConfigValue_js_1 = require("./helpers/getConfigValue.js");
+Object.defineProperty(exports, "getConfigValue", { enumerable: true, get: function () { return getConfigValue_js_1.getConfigValue; } });
+const utils_js_1 = require("../utils.js");
+function getPageConfig(pageId, pageConfigs) {
+    const pageConfig = pageConfigs.find((p) => p.pageId === pageId);
+    (0, utils_js_1.assert)(pageConfigs.length > 0);
+    (0, utils_js_1.assert)(pageConfig);
+    return pageConfig;
+}
+exports.getPageConfig = getPageConfig;
+function getConfigValueFilePathToShowToUser({ definedAt }) {
+    // A unique file path only exists if the config value isn't cumulative nor computed:
+    //  - cumulative config values have multiple file paths
+    //  - computed values don't have any file path
+    if ('isComputed' in definedAt || 'files' in definedAt)
+        return null;
+    const { filePathToShowToUser } = definedAt;
+    (0, utils_js_1.assert)(filePathToShowToUser);
+    return filePathToShowToUser;
+}
+exports.getConfigValueFilePathToShowToUser = getConfigValueFilePathToShowToUser;
+function getHookFilePathToShowToUser({ definedAt }) {
+    const filePathToShowToUser = getConfigValueFilePathToShowToUser({ definedAt });
+    (0, utils_js_1.assert)(filePathToShowToUser);
+    return filePathToShowToUser;
+}
+exports.getHookFilePathToShowToUser = getHookFilePathToShowToUser;

package/dist/cjs/shared/page-configs/serialize/parseConfigValuesImported.js

@@ -13,14 +13,12 @@ function parseConfigValuesImported(configValuesImported) {
         configValues[configName] = {
             value,
             definedAt: {
-                file: {
-                    // importPath cannot be relative to the current file, since the current file is a virtual file
-                    filePathToShowToUser: importPath,
-                    fileExportPathToShowToUser: [configName, 'default'].includes(exportName)
-                        ? []
-                        : // Side-effect config
-                            [exportName]
-                }
+                // importPath cannot be relative to the current file, since the current file is a virtual file
+                filePathToShowToUser: importPath,
+                fileExportPathToShowToUser: [configName, 'default'].includes(exportName)
+                    ? []
+                    : // Side-effect config
+                        [exportName]
             }
         };
         assertIsNotNull(value, configName, importPath);

package/dist/cjs/shared/page-configs/serialize/parsePageConfigs.js

@@ -4,7 +4,7 @@ exports.parsePageConfigs = void 0;
 const parse_1 = require("@brillout/json-serializer/parse");
 const parseConfigValuesImported_js_1 = require("./parseConfigValuesImported.js");
 const utils_js_1 = require("../../utils.js");
-const utils_js_2 = require("../utils.js");
+const helpers_js_1 = require("../helpers.js");
 function parsePageConfigs(pageConfigsSerialized, pageConfigGlobalSerialized) {
     const pageConfigs = pageConfigsSerialized.map((pageConfigSerialized) => {
         const configValues = {};
@@ -52,7 +52,7 @@ function assertRouteConfigValue(configValues) {
         return;
     const { value } = configValue;
     const configValueType = typeof value;
-    const configDefinedAt = (0, utils_js_2.getConfigDefinedAtString)(configName, configValue, true);
+    const configDefinedAt = (0, helpers_js_1.getConfigDefinedAtString)('Config', configName, configValue);
     (0, utils_js_1.assertUsage)(configValueType === 'string' || (0, utils_js_1.isCallable)(value), `${configDefinedAt} has an invalid type '${configValueType}': it should be a string or a function instead, see https://vike.dev/route`);
     /* We don't use assertRouteString() in order to avoid unnecessarily bloating the client-side bundle when using Server Routing:
     * - When using Server Routing, this file is loaded => loading assertRouteString() would bloat the client bundle.

package/dist/cjs/shared/page-configs/serialize/serializeConfigValue.js

@@ -28,9 +28,9 @@ exports.serializeConfigValue = serializeConfigValue;
 function serializeConfigValueImported(configValueSource, configName, whitespace, varCounterContainer, importStatements) {
     (0, utils_js_1.assert)(!configValueSource.valueIsFilePath);
     (0, utils_js_1.assert)(whitespace.replaceAll(' ', '').length === 0);
-    const { valueIsImportedAtRuntime, definedAtInfo } = configValueSource;
+    const { valueIsImportedAtRuntime, definedAt } = configValueSource;
     (0, utils_js_1.assert)(valueIsImportedAtRuntime);
-    const { filePathAbsoluteVite, fileExportName } = definedAtInfo;
+    const { filePathAbsoluteVite, fileExportName } = definedAt;
     (0, utils_js_1.assertPosixPath)(filePathAbsoluteVite);
     const fileName = path_1.default.posix.basename(filePathAbsoluteVite);
     const isValueFile = fileName.startsWith('+');

package/dist/cjs/shared/route/loadPageRoutes.js

@@ -5,10 +5,10 @@ const error_page_js_1 = require("../error-page.js");
 const utils_js_1 = require("./utils.js");
 const deduceRouteStringFromFilesystemPath_js_1 = require("./deduceRouteStringFromFilesystemPath.js");
 const utils_js_2 = require("../utils.js");
-const utils_js_3 = require("../page-configs/utils.js");
+const helpers_js_1 = require("../page-configs/helpers.js");
 const resolveRouteFunction_js_1 = require("./resolveRouteFunction.js");
 async function loadPageRoutes(
-// TODO: remove all arguments and use GlobalContext instead
+// Remove all arguments and use GlobalContext instead?
 pageFilesAll, pageConfigs, pageConfigGlobal, allPageIds) {
     await Promise.all(pageFilesAll.filter((p) => p.fileType === '.page.route').map((p) => p.loadFile?.()));
     const { onBeforeRouteHook, filesystemRoots } = getGlobalHooks(pageFilesAll, pageConfigs, pageConfigGlobal);
@@ -31,10 +31,10 @@ function getPageRoutes(filesystemRoots, pageFilesAll, pageConfigs, allPageIds) {
             let pageRoute = null;
             {
                 const configName = 'route';
-                const configValue = (0, utils_js_3.getConfigValue)(pageConfig, configName);
+                const configValue = (0, helpers_js_1.getConfigValue)(pageConfig, configName);
                 if (configValue) {
                     const route = configValue.value;
-                    const definedAt = (0, utils_js_3.getDefinedAtString)(configValue.definedAt, configName);
+                    const definedAt = (0, helpers_js_1.getDefinedAtString)(configValue.definedAt, configName);
                     if (typeof route === 'string') {
                         pageRoute = {
                             pageId,
@@ -46,7 +46,7 @@ function getPageRoutes(filesystemRoots, pageFilesAll, pageConfigs, allPageIds) {
                     }
                     else {
                         (0, utils_js_1.assert)((0, utils_js_2.isCallable)(route));
-                        if ((0, utils_js_3.getConfigValue)(pageConfig, 'iKnowThePerformanceRisksOfAsyncRouteFunctions', 'boolean'))
+                        if ((0, helpers_js_1.getConfigValue)(pageConfig, 'iKnowThePerformanceRisksOfAsyncRouteFunctions', 'boolean'))
                             (0, resolveRouteFunction_js_1.warnDeprecatedAllowKey)();
                         pageRoute = {
                             pageId,
@@ -139,12 +139,13 @@ function getPageRoutes(filesystemRoots, pageFilesAll, pageConfigs, allPageIds) {
 function getGlobalHooks(pageFilesAll, pageConfigs, pageConfigGlobal) {
     // V1 Design
     if (pageConfigs.length > 0) {
-        if (pageConfigGlobal.configValues.onBeforeRoute?.value) {
-            const configValue = pageConfigGlobal.configValues.onBeforeRoute;
+        const hookName = 'onBeforeRoute';
+        if (pageConfigGlobal.configValues[hookName]?.value) {
+            const configValue = pageConfigGlobal.configValues[hookName];
             const { value: hookFn } = configValue;
-            const hookFilePath = (0, utils_js_3.getHookFilePathToShowToUser)(configValue);
-            // TODO: use getConfigDefinedAtString()
-            (0, utils_js_1.assertUsage)((0, utils_js_2.isCallable)(hookFn), `The hook onBeforeRoute() defined by ${hookFilePath} should be a function.`);
+            const hookFilePath = (0, helpers_js_1.getHookFilePathToShowToUser)(configValue);
+            const hookDefinedAt = (0, helpers_js_1.getConfigDefinedAtString)('Hook', hookName, configValue);
+            (0, utils_js_1.assertUsage)((0, utils_js_2.isCallable)(hookFn), `${hookDefinedAt} should be a function.`);
             const onBeforeRouteHook = {
                 hookFilePath: hookFilePath,
                 onBeforeRoute: hookFn

package/dist/cjs/utils/projectInfo.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.projectInfo = void 0;
 const assertSingleInstance_js_1 = require("./assertSingleInstance.js");
-const PROJECT_VERSION = '0.4.144-commit-6aef8a6';
+const PROJECT_VERSION = '0.4.144-commit-f7ab002';
 const projectInfo = {
     projectName: 'Vike',
     projectVersion: PROJECT_VERSION,

package/dist/esm/client/client-routing-runtime/getPageContext.js

@@ -14,7 +14,7 @@ import { preparePageContextForUserConsumptionClientSide } from '../shared/prepar
 import { loadPageFilesClientSide } from '../shared/loadPageFilesClientSide.js';
 import { removeBuiltInOverrides } from './getPageContext/removeBuiltInOverrides.js';
 import { getPageContextRequestUrl } from '../../shared/getPageContextRequestUrl.js';
-import { getConfigValue, getPageConfig } from '../../shared/page-configs/utils.js';
+import { getConfigValue, getPageConfig } from '../../shared/page-configs/helpers.js';
 import { assertOnBeforeRenderHookReturn } from '../../shared/assertOnBeforeRenderHookReturn.js';
 import { executeGuardHook } from '../../shared/route/executeGuardHook.js';
 import { AbortRender, isAbortPageContext } from '../../shared/route/abort.js';

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

@@ -4,7 +4,7 @@ export { analyzeClientEntries };
 import { assert, resolveOutDir, isObject, viteIsSSR, getFilePathAbsolute, addOnBeforeLogHook, removeFileExtention, unique, assertPosixPath, assertUsage, getOutDirs } from '../utils.js';
 import { virtualFileIdImportUserCodeServer } from '../../shared/virtual-files/virtualFileImportUserCode.js';
 import { getVikeConfig } from './importUserCode/v1-design/getVikeConfig.js';
-import { getConfigValue } from '../../../shared/page-configs/utils.js';
+import { getConfigValue } from '../../../shared/page-configs/helpers.js';
 import { findPageFiles } from '../shared/findPageFiles.js';
 import { getConfigVike } from '../../shared/getConfigVike.js';
 import { getVirtualFileIdPageConfigValuesAll } from '../../shared/virtual-files/virtualFilePageConfigValuesAll.js';

package/dist/esm/node/plugin/plugins/devConfig/determineOptimizeDeps.js

@@ -34,18 +34,18 @@ async function getPageDeps(config, pageConfigs, isDev) {
             configValueSourcesRelevant.forEach((configValueSource) => {
                 if (!configValueSource.valueIsImportedAtRuntime)
                     return;
-                const { definedAtInfo, configEnv } = configValueSource;
+                const { definedAt, configEnv } = configValueSource;
                 if (configEnv !== 'client-only' && configEnv !== 'server-and-client')
                     return;
-                if (definedAtInfo.filePathRelativeToUserRootDir !== null) {
-                    const { filePathAbsoluteFilesystem } = definedAtInfo;
+                if (definedAt.filePathRelativeToUserRootDir !== null) {
+                    const { filePathAbsoluteFilesystem } = definedAt;
                     assert(filePathAbsoluteFilesystem);
                     // Surprisingly Vite expects entries to be absolute paths
                     entries.push(filePathAbsoluteFilesystem);
                 }
                 else {
-                    // Adding definedAtInfo.filePathAbsoluteFilesystem doesn't work for npm packages, I guess because of Vite's config.server.fs.allow
-                    const { importPathAbsolute } = definedAtInfo;
+                    // Adding definedAt.filePathAbsoluteFilesystem doesn't work for npm packages, I guess because of Vite's config.server.fs.allow
+                    const { importPathAbsolute } = definedAt;
                     assert(importPathAbsolute);
                     // We need to differentiate between npm package imports and path aliases.
                     // There are path aliases that cannot be distinguished from npm package names.

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

@@ -4,7 +4,7 @@ export type { ConfigDefinition };
 export type { ConfigDefinitionInternal };
 export type { ConfigNameGlobal };
 export type { ConfigEffect };
-import type { ConfigEnvInternal, ConfigEnv, ConfigValueSources, DefinedAtFileInfo } from '../../../../../../shared/page-configs/PageConfig.js';
+import type { ConfigEnvInternal, ConfigEnv, ConfigValueSources, DefinedAtFileFullInfo } from '../../../../../../shared/page-configs/PageConfig.js';
 import type { Config, ConfigNameBuiltIn } from '../../../../../../shared/page-configs/Config.js';
 /** The meta definition of a config.
  *
@@ -46,7 +46,7 @@ type ConfigEffect = (config: {
 type ConfigDefinitionInternal = Omit<ConfigDefinition, 'env'> & {
     _computed?: (configValueSources: ConfigValueSources) => unknown;
     _valueIsFilePath?: true;
-    _userEffectDefinedAt?: DefinedAtFileInfo;
+    _userEffectDefinedAt?: DefinedAtFileFullInfo;
     env: ConfigEnvInternal;
 };
 type ConfigDefinitionsBuiltIn = Record<ConfigNameBuiltIn, ConfigDefinitionInternal>;

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

@@ -48,16 +48,17 @@ const configDefinitionsBuiltIn = {
         _valueIsFilePath: true
     },
     clientRouting: {
-        env: 'server-and-client' // TODO: config-only instead?
+        // We could make it 'server-only' (we don't yet because of some legacy V0.4 design code)
+        env: 'server-and-client'
     },
     prerender: {
         env: 'server-only'
     },
     hydrationCanBeAborted: {
-        env: 'client-only' // TODO: config-only instead?
+        env: 'client-only'
     },
     prefetchStaticAssets: {
-        env: 'client-only' // TODO: config-only instead?
+        env: 'client-only'
     },
     extends: {
         env: 'config-only'

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

@@ -14,7 +14,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 { getConfigDefinedAtString } from '../../../../../shared/page-configs/utils.js';
+import { getConfigDefinedAtString } from '../../../../../shared/page-configs/helpers.js';
 import { assertExportsOfConfigFile, assertExportsOfValueFile } from '../../../../../shared/page-configs/assertExports.js';
 import { getConfigValueSerialized } from './getVirtualFilePageConfigs.js';
 assertIsNotProductionRuntime();
@@ -329,7 +329,7 @@ function getGlobalConfigs(interfaceFilesByLocationId, userRootDir) {
             assert('value' in configValueSource);
             if (configName === 'prerender' && typeof configValueSource.value === 'boolean')
                 return;
-            const { filePathToShowToUser } = configValueSource.definedAtInfo;
+            const { filePathToShowToUser } = configValueSource.definedAt;
             assertWarning(false, `Being able to define config ${pc.cyan(configName)} in ${filePathToShowToUser} is experimental and will likely be removed. Define the config ${pc.cyan(configName)} in Vike's Vite plugin options instead.`, { onlyOnce: true });
             globalVikeConfig[configName] = configValueSource.value;
         }
@@ -411,9 +411,14 @@ function makeOrderDeterministic(interfaceFile1, interfaceFile2) {
 }
 function warnOverridenConfigValues(interfaceFileWinner, interfaceFilesOverriden, configName, configDef, userRootDir) {
     interfaceFilesOverriden.forEach((interfaceFileLoser) => {
+        const configValueSourceLoser_ = getConfigValueSource(configName, interfaceFileLoser, configDef, userRootDir);
         const configValueSourceWinner = getConfigValueSource(configName, interfaceFileWinner, configDef, userRootDir);
-        const configValueSourceLoser = getConfigValueSource(configName, interfaceFileLoser, configDef, userRootDir);
-        assertWarning(false, `${getConfigSourceDefinedAtString(configName, configValueSourceLoser, true)} overriden by another ${getConfigSourceDefinedAtString(configName, configValueSourceWinner, false)}, remove one of the two`, { onlyOnce: false });
+        // prettier-ignore
+        const configLoser_DefinedAt = getConfigDefinedAtString('Config', configName, configValueSourceLoser_);
+        // prettier-ignore
+        const configWinnerDefinedAt = getConfigDefinedAtString('config', configName, configValueSourceWinner);
+        const errMsg = `${configLoser_DefinedAt} is overriden by another ${configWinnerDefinedAt}, remove one of the two`;
+        assertWarning(false, errMsg, { onlyOnce: false });
     });
 }
 function isInterfaceFileUserLand(interfaceFile) {
@@ -428,20 +433,20 @@ function getConfigValueSource(configName, interfaceFile, configDef, userRootDir)
         fileExportPathToShowToUser: ['default', configName]
     };
     if (configDef._valueIsFilePath) {
-        let definedAtInfo;
+        let definedAt;
         let valueFilePath;
         if (interfaceFile.isConfigFile) {
             const { configValue } = conf;
             const import_ = resolveImport(configValue, interfaceFile.filePath, userRootDir, configEnv, configName);
-            const configDefinedAt = getConfigSourceDefinedAtString(configName, { definedAtInfo: definedAtConfigFile });
+            const configDefinedAt = getConfigDefinedAtString('Config', configName, { definedAt: definedAtConfigFile });
             assertUsage(import_, `${configDefinedAt} should be an import`);
             valueFilePath = import_.filePathAbsoluteVite;
-            definedAtInfo = import_;
+            definedAt = import_;
         }
         else {
             assert(interfaceFile.isValueFile);
             valueFilePath = interfaceFile.filePath.filePathAbsoluteVite;
-            definedAtInfo = {
+            definedAt = {
                 ...interfaceFile.filePath,
                 fileExportPathToShowToUser: []
             };
@@ -451,7 +456,7 @@ function getConfigValueSource(configName, interfaceFile, configDef, userRootDir)
             valueIsFilePath: true,
             configEnv,
             valueIsImportedAtRuntime: true,
-            definedAtInfo
+            definedAt
         };
         return configValueSource;
     }
@@ -463,7 +468,7 @@ function getConfigValueSource(configName, interfaceFile, configDef, userRootDir)
             const configValueSource = {
                 configEnv,
                 valueIsImportedAtRuntime: true,
-                definedAtInfo: import_
+                definedAt: import_
             };
             return configValueSource;
         }
@@ -472,7 +477,7 @@ function getConfigValueSource(configName, interfaceFile, configDef, userRootDir)
                 value: configValue,
                 configEnv,
                 valueIsImportedAtRuntime: false,
-                definedAtInfo: definedAtConfigFile
+                definedAt: definedAtConfigFile
             };
             return configValueSource;
         }
@@ -482,7 +487,7 @@ function getConfigValueSource(configName, interfaceFile, configDef, userRootDir)
         const configValueSource = {
             configEnv,
             valueIsImportedAtRuntime: !valueAlreadyLoaded,
-            definedAtInfo: {
+            definedAt: {
                 ...interfaceFile.filePath,
                 fileExportPathToShowToUser: configName === interfaceFile.configName
                     ? []
@@ -615,9 +620,7 @@ function getConfigDefinitions(interfaceFilesRelevant) {
             if (!configMeta)
                 return;
             const meta = configMeta.configValue;
-            assertMetaValue(meta, 
-            // TODO: Maybe we should use the getConfigDefinedAtString() helper?
-            `Config ${pc.cyan('meta')} defined at ${interfaceFile.filePath.filePathToShowToUser}`);
+            assertMetaValue(meta, `Config ${pc.cyan('meta')} defined at ${interfaceFile.filePath.filePathToShowToUser}`);
             // Set configDef._userEffectDefinedAt
             Object.entries(meta).forEach(([configName, configDef]) => {
                 if (!configDef.effect)
@@ -705,7 +708,7 @@ function applyEffectsAll(configValueSources, configDefinitionsRelevant) {
         // Call effect
         const configModFromEffect = configDef.effect({
             configValue: source.value,
-            configDefinedAt: getConfigSourceDefinedAtString(configName, source)
+            configDefinedAt: getConfigDefinedAtString('Config', configName, source)
         });
         if (!configModFromEffect)
             return;
@@ -719,8 +722,8 @@ function applyEffect(configModFromEffect, configValueSources, configDefEffect) {
         if (configName === 'meta') {
             let configDefinedAtString;
             if (configDefEffect._userEffectDefinedAt) {
-                configDefinedAtString = getConfigSourceDefinedAtString(configName, {
-                    definedAtInfo: configDefEffect._userEffectDefinedAt
+                configDefinedAtString = getConfigDefinedAtString('Config', configName, {
+                    definedAt: configDefEffect._userEffectDefinedAt
                 });
             }
             else {
@@ -744,7 +747,7 @@ function applyEffect(configModFromEffect, configValueSources, configDefEffect) {
         else {
             assertUsage(false, notSupported);
             // If we do end implementing being able to set the value of a config:
-            //  - For setting definedAtInfo: we could take the definedAtInfo of the effect config while appending '(effect)' to definedAtInfo.fileExportPathToShowToUser
+            //  - For setting definedAt: we could take the definedAt of the effect config while appending '(effect)' to definedAt.fileExportPathToShowToUser
         }
     });
 }
@@ -874,8 +877,6 @@ async function loadExtendsConfigs(configFileExports, configFilePath, userRootDir
     const extendsConfigFiles = [];
     extendsImportData.map((importData) => {
         const { importPath: importPath } = importData;
-        // TODO
-        //  - validate extends configs
         const filePathAbsoluteFilesystem = resolveImportPath(importData, configFilePath);
         assertImportPath(filePathAbsoluteFilesystem, importData, configFilePath);
         assertExtendsImportPath(importPath, filePathAbsoluteFilesystem, configFilePath);
@@ -1019,10 +1020,10 @@ function getFilesystemRoutingRootEffect(configFilesystemRoutingRoot, configName)
     // Eagerly loaded since it's config-only
     assert('value' in configFilesystemRoutingRoot);
     const { value } = configFilesystemRoutingRoot;
-    const configDefinedAt = getConfigSourceDefinedAtString(configName, configFilesystemRoutingRoot);
+    const configDefinedAt = getConfigDefinedAtString('Config', configName, configFilesystemRoutingRoot);
     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 { filePathRelativeToUserRootDir } = configFilesystemRoutingRoot.definedAtInfo;
+    const { filePathRelativeToUserRootDir } = configFilesystemRoutingRoot.definedAt;
     assert(filePathRelativeToUserRootDir);
     const before = getFilesystemRouteString(getLocationId(filePathRelativeToUserRootDir));
     const after = value;
@@ -1086,7 +1087,6 @@ function getConfigValues(configValueSources, configValuesComputed, configDefinit
             configValues[configName] = {
                 value,
                 definedAt: {
-                    isCumulative: true,
                     files: sources.map((source) => getDefinedAtFile(source))
                 }
             };
@@ -1096,21 +1096,19 @@ function getConfigValues(configValueSources, configValuesComputed, configDefinit
 }
 function getDefinedAtFile(configValueSource) {
     return {
-        filePathToShowToUser: configValueSource.definedAtInfo.filePathToShowToUser,
-        fileExportPathToShowToUser: configValueSource.definedAtInfo.fileExportPathToShowToUser
+        filePathToShowToUser: configValueSource.definedAt.filePathToShowToUser,
+        fileExportPathToShowToUser: configValueSource.definedAt.fileExportPathToShowToUser
     };
 }
 function getDefinedAt(configValueSource) {
-    return {
-        file: getDefinedAtFile(configValueSource)
-    };
+    return getDefinedAtFile(configValueSource);
 }
 function mergeCumulative(configName, configValueSources) {
     const valuesArr = [];
     const valuesSet = [];
     let configValueSourcePrevious = null;
     configValueSources.forEach((configValueSource) => {
-        const configDefinedAt = getConfigSourceDefinedAtString(configName, configValueSource);
+        const configDefinedAt = getConfigDefinedAtString('Config', configName, configValueSource);
         const configNameColored = pc.cyan(configName);
         // We could, in principle, also support cumulative values to be defined in +${configName}.js but it ins't completely trivial to implement
         assertUsage('value' in configValueSource, `${configDefinedAt} is only allowed to be defined in a +config.h.js file. (Because the values of ${configNameColored} are cumulative.)`);
@@ -1128,7 +1126,7 @@ function mergeCumulative(configName, configValueSources) {
             if (vals2.length === 0)
                 return;
             assert(configValueSourcePrevious);
-            const configPreviousDefinedAt = getConfigSourceDefinedAtString(configName, configValueSourcePrevious, false);
+            const configPreviousDefinedAt = getConfigDefinedAtString('Config', configName, configValueSourcePrevious);
             assertUsage(false, `${configDefinedAt} sets ${t1} but another ${configPreviousDefinedAt} sets ${t2} which is forbidden: the values must be all arrays or all sets (you cannot mix).`);
         };
         const { value } = configValueSource;
@@ -1159,14 +1157,3 @@ function mergeCumulative(configName, configValueSources) {
     }
     assert(false);
 }
-// TODO: rename and/or refactor
-function getConfigSourceDefinedAtString(configName, { definedAtInfo }, sentenceBegin = true) {
-    return getConfigDefinedAtString(configName, {
-        definedAt: {
-            file: {
-                filePathToShowToUser: definedAtInfo.filePathToShowToUser,
-                fileExportPathToShowToUser: definedAtInfo.fileExportPathToShowToUser
-            }
-        }
-    }, sentenceBegin);
-}

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

@@ -4,7 +4,7 @@ import { getVirtualFileIdPageConfigValuesAll, isVirtualFileIdPageConfigValuesAll
 import { getVikeConfig } from './getVikeConfig.js';
 import { extractAssetsAddQuery } from '../../../../shared/extractAssetsQuery.js';
 import { debug } from './debug.js';
-import { getConfigValue } from '../../../../../shared/page-configs/utils.js';
+import { getConfigValue } from '../../../../../shared/page-configs/helpers.js';
 import { getConfigValueSourcesRelevant } from '../../../shared/getConfigValueSourcesRelevant.js';
 import { isRuntimeEnvMatch } from './isRuntimeEnvMatch.js';
 import { serializeConfigValueImported } from '../../../../../shared/page-configs/serialize/serializeConfigValue.js';

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

@@ -1,14 +1,14 @@
 export { getVirtualFilePageConfigs };
 export { getConfigValueSerialized };
-import { assert, assertUsage, getPropAccessNotation, hasProp, objectEntries } from '../../../utils.js';
+import { assert, assertUsage, getPropAccessNotation, objectEntries } from '../../../utils.js';
 import { getVirtualFileIdPageConfigValuesAll } from '../../../../shared/virtual-files/virtualFilePageConfigValuesAll.js';
 import { debug } from './debug.js';
-import { stringify } from '@brillout/json-serializer/stringify';
+import { isJsonSerializerError, stringify } from '@brillout/json-serializer/stringify';
 import { getConfigEnv } from './helpers.js';
 import pc from '@brillout/picocolors';
 import { getVikeConfig } from './getVikeConfig.js';
 import { isRuntimeEnvMatch } from './isRuntimeEnvMatch.js';
-import { getConfigValueFilePathToShowToUser } from '../../../../../shared/page-configs/utils.js';
+import { getConfigValueFilePathToShowToUser } from '../../../../../shared/page-configs/helpers.js';
 import { serializeConfigValue, serializeConfigValueImported } from '../../../../../shared/page-configs/serialize/serializeConfigValue.js';
 async function getVirtualFilePageConfigs(userRootDir, outDirRoot, isForClientSide, isDev, id, configVike, isClientRouting) {
     const { pageConfigs, pageConfigGlobal } = await getVikeConfig(userRootDir, outDirRoot, isDev, configVike.extensions, true);
@@ -105,15 +105,23 @@ function getConfigValueSerialized(value, configName, definedAt) {
     const valueName = `config${getPropAccessNotation(configName)}`;
     let configValueSerialized;
     try {
-        configValueSerialized = stringify(value, { valueName });
+        configValueSerialized = stringify(value, { valueName, forbidReactElements: true });
     }
     catch (err) {
-        assert(hasProp(err, 'messageCore', 'string'));
+        let serializationErrMsg = '';
+        if (isJsonSerializerError(err)) {
+            serializationErrMsg = err.messageCore;
+        }
+        else {
+            console.error('Serialization error:');
+            console.error(err);
+            serializationErrMsg = 'see serialization error printed above';
+        }
         const configValueFilePathToShowToUser = getConfigValueFilePathToShowToUser({ definedAt });
         assert(configValueFilePathToShowToUser);
         assertUsage(false, [
             `The value of the config ${pc.cyan(configName)} cannot be defined inside the file ${configValueFilePathToShowToUser}:`,
-            `its value must be defined in an another file and then imported by ${configValueFilePathToShowToUser}. (Because the value isn't serializable: ${err.messageCore}.)`,
+            `its value must be defined in an another file and then imported by ${configValueFilePathToShowToUser}. (Because its value isn't serializable: ${serializationErrMsg}.)`,
             `Only serializable config values can be defined inside +config.h.js files, see https://vike.dev/header-file.`
         ].join(' '));
     }

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

@@ -6,20 +6,7 @@ function getConfigEnv(configValueSources, configName) {
     const configValueSource = getConfigValueSource(configValueSources, configName);
     if (!configValueSource)
         return null;
-    if (configValueSource) {
-        return configValueSource.configEnv;
-    }
-    else {
-        // In case of effect/computed config values, there isn't any configValueSource
-        // TODO: make it work for custom config definitions
-        //  - Ideally set configValueSource also for effect/computed config values?
-        assert(false, 'TODO');
-        /*
-        const configDef = configDefinitionsBuiltIn[configName as keyof typeof configDefinitionsBuiltIn]
-        if (!configDef) return null
-        return configDef.env
-        */
-    }
+    return configValueSource.configEnv;
 }
 function isConfigSet(configValueSources, configName) {
     const configValueSource = getConfigValueSource(configValueSources, configName);

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

@@ -26,9 +26,13 @@ function previewConfig() {
             markEnvAsPreview();
             return () => {
                 assertDist();
-                if (!configVike.prerender) {
-                    addSsrMiddleware(server.middlewares);
+                /* 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 (!configVike.prerender || configVike.prerender.partial) {
+                  addSsrMiddleware(server.middlewares)
                 }
+                /*/
+                addSsrMiddleware(server.middlewares);
+                //*/
                 addStatic404Middleware(server.middlewares);
             };
         }

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

@@ -16,7 +16,7 @@ import { getConfigVike } from '../shared/getConfigVike.js';
 import { getPageFilesServerSide } from '../../shared/getPageFiles.js';
 import { getPageContextRequestUrl } from '../../shared/getPageContextRequestUrl.js';
 import { getUrlFromRouteString } from '../../shared/route/resolveRouteString.js';
-import { getConfigValue, getConfigValueFilePathToShowToUser, getHookFilePathToShowToUser } from '../../shared/page-configs/utils.js';
+import { getConfigValue, getConfigValueFilePathToShowToUser, getHookFilePathToShowToUser } from '../../shared/page-configs/helpers.js';
 import { loadConfigValues } from '../../shared/page-configs/loadConfigValues.js';
 import { isErrorPage } from '../../shared/error-page.js';
 import { addUrlComputedProps } from '../../shared/addUrlComputedProps.js';
@@ -285,7 +285,7 @@ async function callOnPrerenderStartHook(prerenderContext, renderContext) {
         const configValue = pageConfigGlobal.configValues.onPrerenderStart;
         if (configValue?.value) {
             const { value: hookFn } = configValue;
-            // config.onPrerenderStart isn't a computed nor a cumulative config => definedAtInfo should always be defined
+            // config.onPrerenderStart isn't a computed nor a cumulative config => definedAt should always be defined
             const hookFilePath = getHookFilePathToShowToUser(configValue);
             assert(hookFilePath);
             onPrerenderStartHook = {