vike 0.4.143-commit-dc6fea0 → 0.4.143-commit-fa295e1

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

@@ -24,7 +24,7 @@ async function determineOptimizeDeps(config, configVike, isDev) {
     */
     config.optimizeDeps.include = [...include, ...normalizeInclude(config.optimizeDeps.include)];
     config.optimizeDeps.entries = [...entries, ...normalizeEntries(config.optimizeDeps.entries)];
-    // console.log('config.optimizeDeps', config.optimizeDeps)
+    console.log('config.optimizeDeps', config.optimizeDeps);
 }
 exports.determineOptimizeDeps = determineOptimizeDeps;
 async function getPageDeps(config, pageConfigs, isDev) {
@@ -35,37 +35,40 @@ async function getPageDeps(config, pageConfigs, isDev) {
         pageConfigs.forEach((pageConfig) => {
             const configValueSourcesRelevant = (0, getConfigValueSourcesRelevant_js_1.getConfigValueSourcesRelevant)(pageConfig);
             configValueSourcesRelevant.forEach((configValueSource) => {
-                const { valueIsImportedAtRuntime, configEnv, definedAtInfo } = configValueSource;
-                if (!valueIsImportedAtRuntime)
+                if (!configValueSource.valueIsImportedAtRuntime)
                     return;
-                const { filePath } = definedAtInfo;
-                (0, utils_js_1.assert)(filePath);
-                if (configEnv !== 'client-only' && configEnv !== 'server-and-client')
+                if (configValueSource.isComputed)
                     return;
-                if (filePath.startsWith('/')) {
-                    // Is getFilePathAbsolute() really needed? This contradicts the code below that doesn't need getFilePathAbsolute().
-                    entries.push((0, utils_js_1.getFilePathAbsolute)(filePath, config));
+                const { definedAtInfo, configEnv } = configValueSource;
+                if (configEnv !== 'client-only' && configEnv !== 'server-and-client')
                     return;
-                }
-                // getVikeConfig() resolves relative import paths
-                (0, utils_js_1.assert)(!filePath.startsWith('.'));
-                // We need to differentiate between npm package imports and path aliases.
-                // There are path aliases that cannot be distinguished from npm package names.
-                // We recommend users to use the '#' prefix convention for path aliases, see https://vike.dev/path-aliases#vite and assertResolveAlias()
-                if ((0, utils_js_1.isNpmPackageImport)(filePath)) {
-                    // isNpmPackageImport() returns false for a path alias like #root/renderer/onRenderClient
-                    (0, utils_js_1.assert)(!filePath.startsWith('#'));
-                    include.push(filePath);
+                if (definedAtInfo.filePathRelativeToUserRootDir !== null) {
+                    const { filePathAbsolute } = definedAtInfo;
+                    (0, utils_js_1.assert)(filePathAbsolute);
+                    // Surpsingly Vite expects entries to be absolute paths
+                    entries.push(filePathAbsolute);
                 }
                 else {
-                    /* Path aliases, e.g.:
-                     * ```js
-                     * // /renderer/+config.js
-                     * import onRenderClient from '#root/renderer/onRenderClient'
-                     * ```
-                     * Does Vite resolve the path aliases or is getFilePathAbsolute() needed?
-                     */
-                    entries.push(filePath);
+                    // Adding definedAtInfo.filePathAbsolute doesn't work for npm packages, I guess because of Vite's config.server.fs.allow
+                    const { importPathAbsolute } = definedAtInfo;
+                    (0, utils_js_1.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.
+                    // We recommend users to use the '#' prefix convention for path aliases, see https://vike.dev/path-aliases#vite and assertResolveAlias()
+                    if ((0, utils_js_1.isNpmPackageImport)(importPathAbsolute)) {
+                        // isNpmPackageImport() returns false for a path alias like #root/renderer/onRenderClient
+                        (0, utils_js_1.assert)(!importPathAbsolute.startsWith('#'));
+                        include.push(importPathAbsolute);
+                    }
+                    else {
+                        /* Path aliases, e.g.:
+                         * ```js
+                         * // /renderer/+config.js
+                         * import onRenderClient from '#root/renderer/onRenderClient'
+                         * ```
+                         */
+                        entries.push(importPathAbsolute);
+                    }
                 }
             });
         });

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

@@ -345,7 +345,9 @@ function getGlobalConfigs(interfaceFilesByLocationId, userRootDir) {
             if (configName === 'prerender' && typeof configValueSource.value === 'boolean')
                 return;
             (0, utils_js_1.assert)(!configValueSource.isComputed);
-            (0, utils_js_1.assertWarning)(false, `Being able to define config ${picocolors_1.default.cyan(configName)} in ${configValueSource.definedAtInfo.filePath} is experimental and will likely be removed. Define the config ${picocolors_1.default.cyan(configName)} in vike's Vite plugin options instead.`, { onlyOnce: true });
+            const sourceFilePath = getFilePathToShowToUser2(configValueSource.definedAtInfo);
+            (0, utils_js_1.assert)(sourceFilePath);
+            (0, utils_js_1.assertWarning)(false, `Being able to define config ${picocolors_1.default.cyan(configName)} in ${sourceFilePath} is experimental and will likely be removed. Define the config ${picocolors_1.default.cyan(configName)} in vike's Vite plugin options instead.`, { onlyOnce: true });
             globalVikeConfig[configName] = configValueSource.value;
         }
     });
@@ -428,48 +430,48 @@ function warnOverridenConfigValues(interfaceFileWinner, interfaceFilesOverriden,
     interfaceFilesOverriden.forEach((interfaceFileLoser) => {
         const configValueSourceWinner = getConfigValueSource(configName, interfaceFileWinner, configDef, userRootDir);
         const configValueSourceLoser = getConfigValueSource(configName, interfaceFileLoser, configDef, userRootDir);
-        (0, utils_js_1.assertWarning)(false, `${(0, utils_js_2.getConfigDefinedAtString)(configName, configValueSourceLoser, true)} overriden by another ${(0, utils_js_2.getConfigDefinedAtString)(configName, configValueSourceWinner, false)}, remove one of the two`, { onlyOnce: false });
+        (0, utils_js_1.assert)(!configValueSourceLoser.isComputed);
+        (0, utils_js_1.assert)(!configValueSourceWinner.isComputed);
+        (0, utils_js_1.assertWarning)(false, `${getConfigSourceDefinedAtString(configName, configValueSourceLoser, undefined, true)} overriden by another ${getConfigSourceDefinedAtString(configName, configValueSourceWinner, undefined, false)}, remove one of the two`, { onlyOnce: false });
     });
 }
 function isInterfaceFileUserLand(interfaceFile) {
     return (interfaceFile.isConfigFile && !interfaceFile.isConfigExtend) || interfaceFile.isValueFile;
 }
 function getConfigValueSource(configName, interfaceFile, configDef, userRootDir) {
-    // TODO: rethink file paths of ConfigElement
-    const filePathToShowToUser = interfaceFile.filePath.filePathRelativeToUserRootDir ?? interfaceFile.filePath.filePathAbsolute;
     const conf = interfaceFile.configMap[configName];
     (0, utils_js_1.assert)(conf);
     const configEnv = configDef.env;
-    const definedAtInfoConfigFile = {
-        filePath: filePathToShowToUser,
+    const definedAtConfigFile = {
+        ...interfaceFile.filePath,
         fileExportPath: ['default', configName]
     };
     if (configDef._valueIsFilePath) {
-        let filePath;
+        let definedAtInfo;
+        let valueFilePath;
         if (interfaceFile.isConfigFile) {
             const { configValue } = conf;
             const import_ = resolveImport(configValue, interfaceFile.filePath, userRootDir, configEnv, configName);
-            const configDefinedAt = (0, utils_js_2.getConfigDefinedAtString)(configName, { definedAtInfo: definedAtInfoConfigFile }, true);
+            const configDefinedAt = getConfigSourceDefinedAtString(configName, { definedAtInfo: definedAtConfigFile });
             (0, utils_js_1.assertUsage)(import_, `${configDefinedAt} should be an import`);
-            filePath = import_.filePathToShowToUser;
+            valueFilePath = import_.filePathRelativeToUserRootDir ?? import_.importPathAbsolute;
+            definedAtInfo = import_;
         }
         else {
             (0, utils_js_1.assert)(interfaceFile.isValueFile);
-            filePath =
-                interfaceFile.filePath.filePathRelativeToUserRootDir ??
-                    // Experimental: is this needed? Would it work?
-                    interfaceFile.filePath.filePathAbsolute;
+            valueFilePath = interfaceFile.filePath.filePathRelativeToUserRootDir;
+            definedAtInfo = {
+                ...interfaceFile.filePath,
+                fileExportPath: []
+            };
         }
         const configValueSource = {
-            value: filePath,
+            value: valueFilePath,
             valueIsFilePath: true,
             configEnv,
             valueIsImportedAtRuntime: true,
             isComputed: false,
-            definedAtInfo: {
-                filePath,
-                fileExportPath: []
-            }
+            definedAtInfo
         };
         return configValueSource;
     }
@@ -478,15 +480,11 @@ function getConfigValueSource(configName, interfaceFile, configDef, userRootDir)
         const { configValue } = conf;
         const import_ = resolveImport(configValue, interfaceFile.filePath, userRootDir, configEnv, configName);
         if (import_) {
-            const { filePathToShowToUser, fileExportName: exportName } = import_;
             const configValueSource = {
                 configEnv,
                 valueIsImportedAtRuntime: true,
                 isComputed: false,
-                definedAtInfo: {
-                    filePath: filePathToShowToUser,
-                    fileExportPath: [exportName]
-                }
+                definedAtInfo: import_
             };
             return configValueSource;
         }
@@ -496,23 +494,21 @@ function getConfigValueSource(configName, interfaceFile, configDef, userRootDir)
                 configEnv,
                 valueIsImportedAtRuntime: false,
                 isComputed: false,
-                definedAtInfo: definedAtInfoConfigFile
+                definedAtInfo: definedAtConfigFile
             };
             return configValueSource;
         }
     }
     else if (interfaceFile.isValueFile) {
         // TODO: rethink file paths of ConfigElement
-        const importPath = interfaceFile.filePath.filePathRelativeToUserRootDir ?? interfaceFile.filePath.filePathAbsolute;
-        const exportName = configName === interfaceFile.configName ? 'default' : configName;
         const valueAlreadyLoaded = 'configValue' in conf;
         const configValueSource = {
             configEnv,
             valueIsImportedAtRuntime: !valueAlreadyLoaded,
             isComputed: false,
             definedAtInfo: {
-                filePath: importPath,
-                fileExportPath: [exportName]
+                ...interfaceFile.filePath,
+                fileExportPath: configName === interfaceFile.configName ? [] : [configName]
             }
         };
         if (valueAlreadyLoaded) {
@@ -561,7 +557,8 @@ function resolveImport(configValue, importerFilePath, userRootDir, configEnv, co
         return null;
     const { importPath, exportName } = importData;
     const filePathAbsolute = resolveImportPath(importData, importerFilePath);
-    let filePathToShowToUser;
+    assertFileEnv(filePathAbsolute ?? importPath, configEnv, configName);
+    const fileExportPath = exportName === 'default' || exportName === configName ? [] : [exportName];
     if (importPath.startsWith('.')) {
         // We need to resolve relative paths into absolute paths. Because the import paths are included in virtual files:
         // ```
@@ -569,22 +566,26 @@ function resolveImport(configValue, importerFilePath, userRootDir, configEnv, co
         // ```
         assertImportPath(filePathAbsolute, importData, importerFilePath);
         const filePathRelativeToUserRootDir = resolveImportPath_relativeToUserRootDir(filePathAbsolute, importData, importerFilePath, userRootDir);
-        filePathToShowToUser = filePathRelativeToUserRootDir;
+        return {
+            exportName,
+            fileExportPath,
+            filePathAbsolute,
+            filePathRelativeToUserRootDir,
+            importPathAbsolute: null
+        };
     }
     else {
         // importPath can be:
         //  - an npm package import
         //  - a path alias
-        filePathToShowToUser = importPath;
-    }
-    {
-        const filePathForEnvCheck = filePathAbsolute ?? importPath;
-        assertFileEnv(filePathForEnvCheck, configEnv, configName);
+        return {
+            exportName,
+            fileExportPath,
+            filePathAbsolute,
+            filePathRelativeToUserRootDir: null,
+            importPathAbsolute: importPath
+        };
     }
-    return {
-        filePathToShowToUser,
-        fileExportName: exportName
-    };
 }
 function resolveImportPath_relativeToUserRootDir(filePathAbsolute, importData, configFilePath, userRootDir) {
     (0, utils_js_1.assertPosixPath)(userRootDir);
@@ -677,24 +678,26 @@ function applyEffects(pageConfig, configDefinitionsRelevant) {
             `Adding an effect to ${picocolors_1.default.cyan(configName)} may not work as expected because ${picocolors_1.default.cyan(configName)} has an ${picocolors_1.default.cyan('env')} that is different than ${picocolors_1.default.cyan('config-only')} (its env is ${picocolors_1.default.cyan(configDef.env)}).`,
             'Reach out to a maintainer if you want to use this in production.'
         ].join(' '), { onlyOnce: true });
-        const configValue = pageConfig.configValueSources[configName]?.[0];
-        if (!configValue)
+        const source = pageConfig.configValueSources[configName]?.[0];
+        if (!source)
             return;
+        (0, utils_js_1.assert)(!source.isComputed);
         const configModFromEffect = configDef.effect({
-            configValue: configValue.value,
-            configDefinedAt: (0, utils_js_2.getConfigDefinedAtString)(configName, configValue, true)
+            configValue: source.value,
+            configDefinedAt: getConfigSourceDefinedAtString(configName, source)
         });
         if (!configModFromEffect)
             return;
-        (0, utils_js_1.assert)((0, utils_js_1.hasProp)(configValue, 'value')); // We need to assume that the config value is loaded at build-time
-        applyEffect(configModFromEffect, configValue, pageConfig.configValueSources);
+        (0, utils_js_1.assert)((0, utils_js_1.hasProp)(source, 'value')); // We need to assume that the config value is loaded at build-time
+        applyEffect(configModFromEffect, source, pageConfig.configValueSources);
     });
 }
 function applyEffect(configModFromEffect, configValueEffectSource, configValueSources) {
     const notSupported = `config.meta[configName].effect currently only supports modifying the the ${picocolors_1.default.cyan('env')} of a config. Reach out to a maintainer if you need more capabilities.`;
     (0, utils_js_1.objectEntries)(configModFromEffect).forEach(([configName, configValue]) => {
         if (configName === 'meta') {
-            assertMetaValue(configValue, (0, utils_js_2.getConfigDefinedAtString)(configName, configValueEffectSource, true, 'effect'));
+            (0, utils_js_1.assert)(!configValueEffectSource.isComputed);
+            assertMetaValue(configValue, getConfigSourceDefinedAtString(configName, configValueEffectSource, true));
             (0, utils_js_1.objectEntries)(configValue).forEach(([configTargetName, configTargetDef]) => {
                 {
                     const keys = Object.keys(configTargetDef);
@@ -1006,11 +1009,13 @@ function getFilesystemRoutingRootEffect(configFilesystemRoutingRoot, configName)
     // Eagerly loaded since it's config-only
     (0, utils_js_1.assert)('value' in configFilesystemRoutingRoot);
     const { value } = configFilesystemRoutingRoot;
-    const configDefinedAt = (0, utils_js_2.getConfigDefinedAtString)(configName, configFilesystemRoutingRoot, false);
+    (0, utils_js_1.assert)(!configFilesystemRoutingRoot.isComputed);
+    const configDefinedAt = getConfigSourceDefinedAtString(configName, configFilesystemRoutingRoot);
     (0, utils_js_1.assertUsage)(typeof value === 'string', `${configDefinedAt} should be a string`);
     (0, utils_js_1.assertUsage)(value.startsWith('/'), `${configDefinedAt} is ${picocolors_1.default.cyan(value)} but it should start with a leading slash ${picocolors_1.default.cyan('/')}`);
     (0, utils_js_1.assert)(!configFilesystemRoutingRoot.isComputed);
-    const before = (0, filesystemRouting_js_1.getFilesystemRouteString)((0, filesystemRouting_js_1.getLocationId)(configFilesystemRoutingRoot.definedAtInfo.filePath));
+    (0, utils_js_1.assert)(configFilesystemRoutingRoot.definedAtInfo.filePathRelativeToUserRootDir);
+    const before = (0, filesystemRouting_js_1.getFilesystemRouteString)((0, filesystemRouting_js_1.getLocationId)(configFilesystemRoutingRoot.definedAtInfo.filePathRelativeToUserRootDir));
     const after = value;
     const filesystemRoutingRootEffect = { before, after };
     return { filesystemRoutingRootEffect, filesystemRoutingRootDefinedAt: configDefinedAt };
@@ -1056,10 +1061,11 @@ function getConfigValues(configValueSources, configDefinitionsRelevant) {
         if (!configDef.cumulative) {
             const configValueSource = sources[0];
             if ('value' in configValueSource) {
-                const { value, definedAtInfo } = configValueSource;
+                const { value } = configValueSource;
+                const definedAt = configValueSource.isComputed ? { isComputed: true } : getDefinedAt(configValueSource);
                 configValues[configName] = {
                     value,
-                    definedAtInfo
+                    definedAt
                 };
             }
         }
@@ -1067,7 +1073,10 @@ function getConfigValues(configValueSources, configDefinitionsRelevant) {
             const value = mergeCumulative(configName, sources);
             configValues[configName] = {
                 value,
-                definedAtInfo: null
+                definedAt: {
+                    isCumulative: true,
+                    sources: sources.map((source) => getSourceDefinedAt(source))
+                }
             };
         }
     });
@@ -1079,7 +1088,7 @@ function mergeCumulative(configName, configValueSources) {
     let configValueSourcePrevious = null;
     configValueSources.forEach((configValueSource) => {
         (0, utils_js_1.assert)(!configValueSource.isComputed);
-        const configDefinedAt = (0, utils_js_2.getConfigDefinedAtString)(configName, configValueSource, true);
+        const configDefinedAt = getConfigSourceDefinedAtString(configName, configValueSource);
         const configNameColored = picocolors_1.default.cyan(configName);
         // We could, in principle, also support cumulative values to be defined in +${configName}.js but it ins't completely trivial to implement
         (0, utils_js_1.assertUsage)('value' in configValueSource, `${configDefinedAt} is only allowed to be defined in a +config.h.js file. (Because the values of ${configNameColored} are cumulative.)`);
@@ -1087,7 +1096,7 @@ function mergeCumulative(configName, configValueSources) {
         const explanation = `(Because the values of ${configNameColored} are cumulative and therefore merged together.)` as const
         */
         // Make sure configValueSource.value is serializable
-        (0, getVirtualFilePageConfigs_js_1.getConfigValueSerialized)(configValueSource.value, configName, configValueSource.definedAtInfo);
+        (0, getVirtualFilePageConfigs_js_1.getConfigValueSerialized)(configValueSource.value, configName, getDefinedAt(configValueSource));
         const assertNoMixing = (isSet) => {
             const vals1 = isSet ? valuesSet : valuesArr;
             const t1 = isSet ? 'a Set' : 'an array';
@@ -1097,7 +1106,8 @@ function mergeCumulative(configName, configValueSources) {
             if (vals2.length === 0)
                 return;
             (0, utils_js_1.assert)(configValueSourcePrevious);
-            const configPreviousDefinedAt = (0, utils_js_2.getConfigDefinedAtString)(configName, configValueSourcePrevious, false);
+            (0, utils_js_1.assert)(!configValueSourcePrevious.isComputed);
+            const configPreviousDefinedAt = getConfigSourceDefinedAtString(configName, configValueSourcePrevious, undefined, true);
             (0, utils_js_1.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;
@@ -1128,3 +1138,46 @@ function mergeCumulative(configName, configValueSources) {
     }
     (0, utils_js_1.assert)(false);
 }
+// TODO: rename
+// TODO: refactor
+function getConfigSourceDefinedAtString(configName, { definedAtInfo }, isEffect = undefined, sentenceBegin = true) {
+    return (0, utils_js_2.getConfigDefinedAtString)(configName, {
+        definedAt: {
+            isEffect,
+            source: {
+                filePathToShowToUser: getFilePathToShowToUser2(definedAtInfo),
+                fileExportPath: definedAtInfo.fileExportPath
+            }
+        }
+    }, sentenceBegin);
+}
+// TODO: rename
+function getFilePathToShowToUser2(definedAtInfo) {
+    return definedAtInfo.filePathRelativeToUserRootDir ?? definedAtInfo.importPathAbsolute;
+    /*
+    if (definedAtInfo.filePathRelativeToUserRootDir !== null) {
+      return definedAtInfo.filePathRelativeToUserRootDir
+    }
+    if (definedAtInfo.importPathAbsolute !== null) {
+      return definedAtInfo.importPathAbsolute
+    } else {
+      const filePathToShowToUser = definedAtInfo.filePathAbsolute
+      // TypeScript failes to infer that definedAtInfo.filePathAbsolute cannot be null
+      assert(filePathToShowToUser)
+      return filePathToShowToUser
+    }
+    */
+}
+// TODO: rename
+function getSourceDefinedAt(source) {
+    (0, utils_js_1.assert)(!source.isComputed);
+    return {
+        filePathToShowToUser: getFilePathToShowToUser2(source.definedAtInfo),
+        fileExportPath: source.definedAtInfo.fileExportPath
+    };
+}
+function getDefinedAt(configValueSource) {
+    return {
+        source: getSourceDefinedAt(configValueSource)
+    };
+}

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

@@ -58,30 +58,31 @@ function getLoadConfigValuesAll(pageConfig, isForClientSide, pageId, includeAsse
     return code;
 }
 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;
     (0, utils_js_1.assert)(valueIsImportedAtRuntime);
-    const { filePath, fileExportPath } = definedAtInfo;
-    (0, utils_js_1.assertPosixPath)(filePath);
-    const fileName = path_1.default.posix.basename(filePath);
+    const { filePathRelativeToUserRootDir, importPathAbsolute, exportName } = definedAtInfo;
+    const importPath = filePathRelativeToUserRootDir ?? importPathAbsolute;
+    (0, utils_js_1.assertPosixPath)(importPath);
+    const fileName = path_1.default.posix.basename(importPath);
     const isValueFile = fileName.startsWith('+');
-    const fileExportName = fileExportPath[0];
-    (0, utils_js_1.assert)(!configValueSource.valueIsFilePath);
-    (0, utils_js_1.assert)(fileExportName);
-    const { importName, importStatement } = (0, generateEagerImport_js_1.generateEagerImport)(filePath, varCounterContainer.varCounter++, isValueFile ? undefined : fileExportName);
+    if (isValueFile)
+        (0, utils_js_1.assert)(exportName === undefined);
+    const { importName, importStatement } = (0, generateEagerImport_js_1.generateEagerImport)(importPath, varCounterContainer.varCounter++, exportName);
     importStatements.push(importStatement);
     const lines = [];
     lines.push(`  {`);
     lines.push(`    configName: '${configName}',`);
-    lines.push(`    importPath: '${filePath}',`);
+    lines.push(`    importPath: '${importPath}',`);
     lines.push(`    isValueFile: ${JSON.stringify(isValueFile)},`);
     if (isValueFile) {
         lines.push(`    importFileExports: ${importName},`);
     }
     else {
         lines.push(`    importFileExportValue: ${importName},`);
-        (0, utils_js_1.assert)(fileExportName);
-        lines.push(`    exportName: ${JSON.stringify(fileExportName)},`);
+        (0, utils_js_1.assert)(exportName);
+        lines.push(`    exportName: ${JSON.stringify(exportName)},`);
     }
     lines.push(`  },`);
     return lines;

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

@@ -13,6 +13,7 @@ const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const getVikeConfig_js_1 = require("./getVikeConfig.js");
 const isConfigEnvMatch_js_1 = require("./isConfigEnvMatch.js");
 const getVirtualFilePageConfigValuesAll_js_1 = require("./getVirtualFilePageConfigValuesAll.js");
+const utils_js_2 = require("../../../../../shared/page-configs/utils.js");
 async function getVirtualFilePageConfigs(userRootDir, isForClientSide, isDev, id, configVike, isClientRouting) {
     const { pageConfigs, pageConfigGlobal } = await (0, getVikeConfig_js_1.getVikeConfig)(userRootDir, isDev, configVike.extensions, true);
     return getContent(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, isClientRouting);
@@ -39,9 +40,9 @@ function getContent(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, i
                 (0, utils_js_1.assert)(configEnv, configName);
                 if (!(0, isConfigEnvMatch_js_1.isConfigEnvMatch)(configEnv, isForClientSide, isClientRouting))
                     return;
-                const { value, definedAtInfo } = configValue;
-                const valueSerialized = getConfigValueSerialized(value, configName, definedAtInfo);
-                serializeConfigValue(lines, configName, { definedAtInfo, valueSerialized });
+                const { value, definedAt } = configValue;
+                const valueSerialized = getConfigValueSerialized(value, configName, definedAt);
+                serializeConfigValue(lines, configName, { definedAt, valueSerialized });
             }
         });
         lines.push(`    },`);
@@ -98,13 +99,13 @@ function serializeConfigValue(lines, configName, configValueSerialized) {
     lines.push(`${whitespace}['${configName}']: {`);
     whitespace += '  ';
     Object.entries(configValueSerialized).forEach(([key, val]) => {
-        const valSerialized = key === 'definedAtInfo' ? JSON.stringify(val) : val;
+        const valSerialized = key === 'definedAt' ? JSON.stringify(val) : val;
         lines.push(`${whitespace}  ${key}: ${valSerialized},`);
     });
     whitespace = whitespace.slice(2);
     lines.push(`${whitespace}},`);
 }
-function getConfigValueSerialized(value, configName, definedAtInfo) {
+function getConfigValueSerialized(value, configName, definedAt) {
     let configValueSerialized;
     const valueName = `config${(0, utils_js_1.getPropAccessNotation)(configName)}`;
     try {
@@ -112,15 +113,14 @@ function getConfigValueSerialized(value, configName, definedAtInfo) {
     }
     catch (err) {
         (0, utils_js_1.assert)((0, utils_js_1.hasProp)(err, 'messageCore', 'string'));
-        // definedAtInfo is null when config value is:
+        const configValueFilePathToShowToUser = (0, utils_js_2.getConfigValueFilePathToShowToUser)({ definedAt });
+        // definedAt is null when config value is:
         //  - computed => all computed values defined by Vike can are serializable
         //  - cumulative => the values are already ensured to be serializable
-        (0, utils_js_1.assert)(definedAtInfo);
-        const configDefinedByFile = definedAtInfo.filePath;
-        (0, utils_js_1.assert)(configDefinedByFile);
+        (0, utils_js_1.assert)(configValueFilePathToShowToUser);
         (0, utils_js_1.assertUsage)(false, [
-            `The value of the config ${picocolors_1.default.cyan(configName)} cannot be defined inside the file ${configDefinedByFile}:`,
-            `its value must be defined in an another file and then imported by ${configDefinedByFile}. (Because the value isn't serializable: ${err.messageCore}.)`,
+            `The value of the config ${picocolors_1.default.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}.)`,
             `Only serializable config values can be defined inside +config.h.js files, see https://vike.dev/header-file.`
         ].join(' '));
     }

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

@@ -115,12 +115,13 @@ async function collectDoNoPrerenderList(renderContext, doNotPrerenderList, concu
         const configName = 'prerender';
         const configValue = (0, utils_js_2.getConfigValue)(pageConfig, configName, 'boolean');
         if (configValue?.value === false) {
-            const definedAtInfo = (0, utils_js_2.getConfigDefinedAtInfo)(pageConfig, configName);
+            const filePath = (0, utils_js_2.getConfigValueFilePathToShowToUser)(configValue);
+            (0, utils_js_1.assert)(filePath);
             doNotPrerenderList.push({
                 pageId: pageConfig.pageId,
                 setByConfigName: 'prerender',
                 setByConfigValue: false,
-                setByConfigFile: definedAtInfo.filePath
+                setByConfigFile: filePath
             });
         }
     });
@@ -176,8 +177,7 @@ async function callOnBeforePrerenderStartHooks(prerenderContext, renderContext,
         if (!configValue)
             return;
         const hookFn = configValue.value;
-        const definedAtInfo = (0, utils_js_2.getConfigDefinedAtInfo)(pageConfigLoaded, hookName);
-        const hookFilePath = definedAtInfo.filePath;
+        const hookFilePath = (0, utils_js_2.getHookFilePathToShowToUser)(configValue);
         (0, utils_js_1.assert)(hookFilePath);
         (0, getHook_js_1.assertHookFn)(hookFn, { hookName, hookFilePath });
         onBeforePrerenderStartHooks.push({
@@ -310,11 +310,12 @@ async function callOnPrerenderStartHook(prerenderContext, renderContext) {
     // V1 design
     if (renderContext.pageConfigs.length > 0) {
         const { pageConfigGlobal } = renderContext;
-        if (pageConfigGlobal.configValues.onPrerenderStart?.value) {
-            const { value: hookFn, definedAtInfo } = pageConfigGlobal.configValues.onPrerenderStart;
+        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
-            (0, utils_js_1.assert)(definedAtInfo);
-            const hookFilePath = definedAtInfo.filePath;
+            const hookFilePath = (0, utils_js_2.getHookFilePathToShowToUser)(configValue);
+            (0, utils_js_1.assert)(hookFilePath);
             onPrerenderStartHook = {
                 hookFn,
                 hookName: 'onPrerenderStart',

package/dist/cjs/node/runtime/renderPage/renderPageAlreadyRouted.js

@@ -21,6 +21,7 @@ const preparePageContextForUserConsumptionServerSide_js_1 = require("./preparePa
 const executeGuardHook_js_1 = require("../../../shared/route/executeGuardHook.js");
 const loadPageRoutes_js_1 = require("../../../shared/route/loadPageRoutes.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+const utils_js_2 = require("../../../shared/page-configs/utils.js");
 async function renderPageAlreadyRouted(pageContext) {
     // pageContext._pageId can either be the:
     //  - ID of the page matching the routing, or the
@@ -172,9 +173,9 @@ function assertNonMixedDesign(pageFilesAll, pageConfigs) {
     const indent = '- ';
     const v1Files = (0, utils_js_1.unique)(pageConfigs
         .map((p) => Object.values(p.configValues)
-        .map(({ definedAtInfo }) => definedAtInfo)
+        .map(utils_js_2.getConfigValueFilePathToShowToUser)
         .filter(utils_js_1.isNotNullish)
-        .map((definedAtInfo) => indent + definedAtInfo.filePath))
+        .map((filePathToShowToUser) => indent + filePathToShowToUser))
         .flat(2));
     (0, utils_js_1.assertUsage)(false, [
         'Mixing the new V1 design with the old V0.4 design is forbidden.',

package/dist/cjs/node/shared/getClientEntryFilePath.js

@@ -2,17 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getClientEntryFilePath = void 0;
 const utils_js_1 = require("../../shared/page-configs/utils.js");
-const utils_js_2 = require("./utils.js");
 function getClientEntryFilePath(pageConfig) {
     const configName = 'client';
     const configValue = (0, utils_js_1.getConfigValue)(pageConfig, configName, 'string');
     if (!configValue)
         return null;
-    const definedAtInfo = (0, utils_js_1.getConfigDefinedAtInfo)(pageConfig, configName);
-    const { value } = configValue;
-    // Users should be able to suppress client entry by setting its value to null
-    (0, utils_js_2.assert)(value !== null);
-    const clientEntryFilePath = definedAtInfo.filePath;
-    return clientEntryFilePath;
+    return configValue.value;
 }
 exports.getClientEntryFilePath = getClientEntryFilePath;

package/dist/cjs/shared/getPageFiles/getExports.js

@@ -33,11 +33,8 @@ function getExports(pageFiles, pageConfig) {
     // V1 design
     if (pageConfig) {
         Object.entries(pageConfig.configValues).forEach(([configName, configValue]) => {
-            const { value, definedAtInfo } = configValue;
-            let filePath = null;
-            if (definedAtInfo) {
-                filePath = definedAtInfo.filePath;
-            }
+            const { value } = configValue;
+            const filePath = (0, utils_js_2.getConfigValueFilePathToShowToUser)(configValue);
             const configDefinedAt = (0, utils_js_2.getConfigDefinedAtString)(configName, configValue, true);
             config[configName] = config[configName] ?? value;
             configEntries[configName] = configEntries[configName] ?? [];

package/dist/cjs/shared/getPageFiles/parsePageConfigsSerialized.js

@@ -4,6 +4,7 @@ exports.parsePageConfigsSerialized = void 0;
 const parse_1 = require("@brillout/json-serializer/parse");
 const parseConfigValuesImported_js_1 = require("../page-configs/parseConfigValuesImported.js");
 const utils_js_1 = require("../utils.js");
+const utils_js_2 = require("../page-configs/utils.js");
 function parsePageConfigsSerialized(pageConfigsSerialized, pageConfigGlobalSerialized) {
     const pageConfigs = pageConfigsSerialized.map((pageConfigSerialized) => {
         const configValues = {};
@@ -11,12 +12,12 @@ function parsePageConfigsSerialized(pageConfigsSerialized, pageConfigGlobalSeria
             const { configValuesSerialized } = pageConfigSerialized;
             Object.entries(configValuesSerialized).forEach(([configName, configValueSeriliazed]) => {
                 {
-                    const { valueSerialized, definedAtInfo } = configValueSeriliazed;
+                    const { valueSerialized, definedAt } = configValueSeriliazed;
                     (0, utils_js_1.assert)(valueSerialized);
                     (0, utils_js_1.assert)(!configValues[configName]);
                     configValues[configName] = {
                         value: (0, parse_1.parse)(valueSerialized),
-                        definedAtInfo
+                        definedAt
                     };
                 }
             });
@@ -45,12 +46,14 @@ function parsePageConfigsSerialized(pageConfigsSerialized, pageConfigGlobalSeria
 }
 exports.parsePageConfigsSerialized = parsePageConfigsSerialized;
 function assertRouteConfigValue(configValues) {
-    if (!configValues.route)
+    const configName = 'route';
+    const configValue = configValues[configName];
+    if (!configValue)
         return;
-    const { value, definedAtInfo } = configValues.route;
+    const { value } = configValue;
     const configValueType = typeof value;
-    (0, utils_js_1.assert)(definedAtInfo);
-    (0, utils_js_1.assertUsage)(configValueType === 'string' || (0, utils_js_1.isCallable)(value), `${definedAtInfo.filePath} has an invalid type '${configValueType}': it should be a string or a function instead, see https://vike.dev/route`);
+    const configDefinedAt = (0, utils_js_2.getConfigDefinedAtString)(configName, configValue, true);
+    (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.
     * - assertRouteString() is already called on the server-side