vike 0.4.143-commit-f03b42d → 0.4.143-commit-fa295e1

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

@@ -84,7 +84,8 @@ async function loadInterfaceFiles(userRootDir, isDev, extensions) {
     await Promise.all(configFiles.map(async ({ filePathAbsolute, filePathRelativeToUserRootDir }) => {
         const configFilePath = {
             filePathAbsolute: filePathAbsolute,
-            filePathRelativeToUserRootDir: filePathRelativeToUserRootDir
+            filePathRelativeToUserRootDir: filePathRelativeToUserRootDir,
+            importPathAbsolute: null
         };
         const { configFile, extendsConfigs } = await loadConfigFile(configFilePath, userRootDir, []);
         const interfaceFile = getInterfaceFileFromConfigFile(configFile, false);
@@ -103,7 +104,8 @@ async function loadInterfaceFiles(userRootDir, isDev, extensions) {
         const interfaceFile = {
             filePath: {
                 filePathRelativeToUserRootDir,
-                filePathAbsolute
+                filePathAbsolute,
+                importPathAbsolute: null
             },
             configMap: {
                 [configName]: {}
@@ -338,7 +340,9 @@ function getGlobalConfigs(interfaceFilesByLocationId, userRootDir) {
             if (configName === 'prerender' && typeof configValueSource.value === 'boolean')
                 return;
             assert(!configValueSource.isComputed);
-            assertWarning(false, `Being able to define config ${pc.cyan(configName)} in ${configValueSource.definedAtInfo.filePath} is experimental and will likely be removed. Define the config ${pc.cyan(configName)} in vike's Vite plugin options instead.`, { onlyOnce: true });
+            const sourceFilePath = getFilePathToShowToUser2(configValueSource.definedAtInfo);
+            assert(sourceFilePath);
+            assertWarning(false, `Being able to define config ${pc.cyan(configName)} in ${sourceFilePath} 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;
         }
     });
@@ -421,48 +425,48 @@ function warnOverridenConfigValues(interfaceFileWinner, interfaceFilesOverriden,
     interfaceFilesOverriden.forEach((interfaceFileLoser) => {
         const configValueSourceWinner = getConfigValueSource(configName, interfaceFileWinner, configDef, userRootDir);
         const configValueSourceLoser = getConfigValueSource(configName, interfaceFileLoser, configDef, userRootDir);
-        assertWarning(false, `${getConfigDefinedAtString(configName, configValueSourceLoser, true)} overriden by another ${getConfigDefinedAtString(configName, configValueSourceWinner, false)}, remove one of the two`, { onlyOnce: false });
+        assert(!configValueSourceLoser.isComputed);
+        assert(!configValueSourceWinner.isComputed);
+        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];
     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 = getConfigDefinedAtString(configName, { definedAtInfo: definedAtInfoConfigFile }, true);
+            const configDefinedAt = getConfigSourceDefinedAtString(configName, { definedAtInfo: definedAtConfigFile });
             assertUsage(import_, `${configDefinedAt} should be an import`);
-            filePath = import_.filePathToShowToUser;
+            valueFilePath = import_.filePathRelativeToUserRootDir ?? import_.importPathAbsolute;
+            definedAtInfo = import_;
         }
         else {
             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;
     }
@@ -471,15 +475,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;
         }
@@ -489,23 +489,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) {
@@ -554,7 +552,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:
         // ```
@@ -562,22 +561,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) {
     assertPosixPath(userRootDir);
@@ -670,24 +673,26 @@ function applyEffects(pageConfig, configDefinitionsRelevant) {
             `Adding an effect to ${pc.cyan(configName)} may not work as expected because ${pc.cyan(configName)} has an ${pc.cyan('env')} that is different than ${pc.cyan('config-only')} (its env is ${pc.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;
+        assert(!source.isComputed);
         const configModFromEffect = configDef.effect({
-            configValue: configValue.value,
-            configDefinedAt: getConfigDefinedAtString(configName, configValue, true)
+            configValue: source.value,
+            configDefinedAt: getConfigSourceDefinedAtString(configName, source)
         });
         if (!configModFromEffect)
             return;
-        assert(hasProp(configValue, 'value')); // We need to assume that the config value is loaded at build-time
-        applyEffect(configModFromEffect, configValue, pageConfig.configValueSources);
+        assert(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 ${pc.cyan('env')} of a config. Reach out to a maintainer if you need more capabilities.`;
     objectEntries(configModFromEffect).forEach(([configName, configValue]) => {
         if (configName === 'meta') {
-            assertMetaValue(configValue, getConfigDefinedAtString(configName, configValueEffectSource, true, 'effect'));
+            assert(!configValueEffectSource.isComputed);
+            assertMetaValue(configValue, getConfigSourceDefinedAtString(configName, configValueEffectSource, true));
             objectEntries(configValue).forEach(([configTargetName, configTargetDef]) => {
                 {
                     const keys = Object.keys(configTargetDef);
@@ -797,7 +802,7 @@ function assertNoUnexpectedPlusSign(filePath, fileName) {
     assertUsage(!fileName.slice(1).includes('+'), `Character '+' is only allowed at the beginning of filenames: make sure ${filePath} doesn't contain any '+' in its filename other than its first letter`);
 }
 async function loadConfigFile(configFilePath, userRootDir, visited) {
-    const { filePathAbsolute, filePathRelativeToUserRootDir } = configFilePath;
+    const { filePathAbsolute } = configFilePath;
     assertNoInfiniteLoop(visited, filePathAbsolute);
     const { fileExports } = await transpileAndExecuteFile(configFilePath, false, userRootDir);
     const { extendsConfigs, extendsFilePaths } = await loadExtendsConfigs(fileExports, configFilePath, userRootDir, [
@@ -806,10 +811,7 @@ async function loadConfigFile(configFilePath, userRootDir, visited) {
     ]);
     const configFile = {
         fileExports,
-        filePath: {
-            filePathRelativeToUserRootDir,
-            filePathAbsolute
-        },
+        filePath: configFilePath,
         extendsFilePaths
     };
     return { configFile, extendsConfigs };
@@ -832,11 +834,14 @@ async function loadExtendsConfigs(configFileExports, configFilePath, userRootDir
         const filePathAbsolute = resolveImportPath(importData, configFilePath);
         assertImportPath(filePathAbsolute, importData, configFilePath);
         assertExtendsImportPath(importPath, filePathAbsolute, configFilePath);
+        // - filePathRelativeToUserRootDir has no functionality beyond nicer error messages for user
+        // - Using importPath would be visually nicer but it's ambigous => we rather pick filePathAbsolute for added clarity
+        const filePathRelativeToUserRootDir = determineFilePathRelativeToUserDir(filePathAbsolute, userRootDir);
         extendsConfigFiles.push({
             filePathAbsolute,
-            // - filePathRelativeToUserRootDir has no functionality beyond nicer error messages for user
-            // - Using importPath would be visually nicer but it's ambigous => we rather pick filePathAbsolute for added clarity
-            filePathRelativeToUserRootDir: determineFilePathRelativeToUserDir(filePathAbsolute, userRootDir)
+            // TODO: fix type cast
+            filePathRelativeToUserRootDir: filePathRelativeToUserRootDir,
+            importPathAbsolute: importPath
         });
     });
     const extendsConfigs = [];
@@ -999,11 +1004,13 @@ function getFilesystemRoutingRootEffect(configFilesystemRoutingRoot, configName)
     // Eagerly loaded since it's config-only
     assert('value' in configFilesystemRoutingRoot);
     const { value } = configFilesystemRoutingRoot;
-    const configDefinedAt = getConfigDefinedAtString(configName, configFilesystemRoutingRoot, false);
+    assert(!configFilesystemRoutingRoot.isComputed);
+    const configDefinedAt = getConfigSourceDefinedAtString(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('/')}`);
     assert(!configFilesystemRoutingRoot.isComputed);
-    const before = getFilesystemRouteString(getLocationId(configFilesystemRoutingRoot.definedAtInfo.filePath));
+    assert(configFilesystemRoutingRoot.definedAtInfo.filePathRelativeToUserRootDir);
+    const before = getFilesystemRouteString(getLocationId(configFilesystemRoutingRoot.definedAtInfo.filePathRelativeToUserRootDir));
     const after = value;
     const filesystemRoutingRootEffect = { before, after };
     return { filesystemRoutingRootEffect, filesystemRoutingRootDefinedAt: configDefinedAt };
@@ -1048,10 +1055,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
                 };
             }
         }
@@ -1059,7 +1067,10 @@ function getConfigValues(configValueSources, configDefinitionsRelevant) {
             const value = mergeCumulative(configName, sources);
             configValues[configName] = {
                 value,
-                definedAtInfo: null
+                definedAt: {
+                    isCumulative: true,
+                    sources: sources.map((source) => getSourceDefinedAt(source))
+                }
             };
         }
     });
@@ -1071,7 +1082,7 @@ function mergeCumulative(configName, configValueSources) {
     let configValueSourcePrevious = null;
     configValueSources.forEach((configValueSource) => {
         assert(!configValueSource.isComputed);
-        const configDefinedAt = getConfigDefinedAtString(configName, configValueSource, true);
+        const configDefinedAt = getConfigSourceDefinedAtString(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.)`);
@@ -1079,7 +1090,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
-        getConfigValueSerialized(configValueSource.value, configName, configValueSource.definedAtInfo);
+        getConfigValueSerialized(configValueSource.value, configName, getDefinedAt(configValueSource));
         const assertNoMixing = (isSet) => {
             const vals1 = isSet ? valuesSet : valuesArr;
             const t1 = isSet ? 'a Set' : 'an array';
@@ -1089,7 +1100,8 @@ function mergeCumulative(configName, configValueSources) {
             if (vals2.length === 0)
                 return;
             assert(configValueSourcePrevious);
-            const configPreviousDefinedAt = getConfigDefinedAtString(configName, configValueSourcePrevious, false);
+            assert(!configValueSourcePrevious.isComputed);
+            const configPreviousDefinedAt = getConfigSourceDefinedAtString(configName, configValueSourcePrevious, undefined, true);
             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;
@@ -1120,3 +1132,46 @@ function mergeCumulative(configName, configValueSources) {
     }
     assert(false);
 }
+// TODO: rename
+// TODO: refactor
+function getConfigSourceDefinedAtString(configName, { definedAtInfo }, isEffect = undefined, sentenceBegin = true) {
+    return 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) {
+    assert(!source.isComputed);
+    return {
+        filePathToShowToUser: getFilePathToShowToUser2(source.definedAtInfo),
+        fileExportPath: source.definedAtInfo.fileExportPath
+    };
+}
+function getDefinedAt(configValueSource) {
+    return {
+        source: getSourceDefinedAt(configValueSource)
+    };
+}

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

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

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

@@ -1,6 +1,6 @@
 export { getVirtualFilePageConfigs };
 export { getConfigValueSerialized };
-import type { DefinedAtInfo } from '../../../../../shared/page-configs/PageConfig.js';
+import type { DefinedAt } from '../../../../../shared/page-configs/PageConfig.js';
 import type { ConfigVikeResolved } from '../../../../../shared/ConfigVike.js';
 declare function getVirtualFilePageConfigs(userRootDir: string, isForClientSide: boolean, isDev: boolean, id: string, configVike: ConfigVikeResolved, isClientRouting: boolean): Promise<string>;
-declare function getConfigValueSerialized(value: unknown, configName: string, definedAtInfo: null | DefinedAtInfo): string;
+declare function getConfigValueSerialized(value: unknown, configName: string, definedAt: DefinedAt): string;

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

@@ -9,6 +9,7 @@ import pc from '@brillout/picocolors';
 import { getVikeConfig } from './getVikeConfig.js';
 import { isConfigEnvMatch } from './isConfigEnvMatch.js';
 import { serializeConfigValueImported } from './getVirtualFilePageConfigValuesAll.js';
+import { getConfigValueFilePathToShowToUser } from '../../../../../shared/page-configs/utils.js';
 async function getVirtualFilePageConfigs(userRootDir, isForClientSide, isDev, id, configVike, isClientRouting) {
     const { pageConfigs, pageConfigGlobal } = await getVikeConfig(userRootDir, isDev, configVike.extensions, true);
     return getContent(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, isClientRouting);
@@ -34,9 +35,9 @@ function getContent(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, i
                 assert(configEnv, configName);
                 if (!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(`    },`);
@@ -93,13 +94,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${getPropAccessNotation(configName)}`;
     try {
@@ -107,15 +108,14 @@ function getConfigValueSerialized(value, configName, definedAtInfo) {
     }
     catch (err) {
         assert(hasProp(err, 'messageCore', 'string'));
-        // definedAtInfo is null when config value is:
+        const configValueFilePathToShowToUser = 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
-        assert(definedAtInfo);
-        const configDefinedByFile = definedAtInfo.filePath;
-        assert(configDefinedByFile);
+        assert(configValueFilePathToShowToUser);
         assertUsage(false, [
-            `The value of the config ${pc.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 ${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}.)`,
             `Only serializable config values can be defined inside +config.h.js files, see https://vike.dev/header-file.`
         ].join(' '));
     }

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 { getConfigDefinedAtInfo, getConfigValue } from '../../shared/page-configs/utils.js';
+import { getConfigValue, getConfigValueFilePathToShowToUser, getHookFilePathToShowToUser } from '../../shared/page-configs/utils.js';
 import { loadConfigValues } from '../../shared/page-configs/loadConfigValues.js';
 import { isErrorPage } from '../../shared/error-page.js';
 import { addUrlComputedProps } from '../../shared/addUrlComputedProps.js';
@@ -87,12 +87,13 @@ async function collectDoNoPrerenderList(renderContext, doNotPrerenderList, concu
         const configName = 'prerender';
         const configValue = getConfigValue(pageConfig, configName, 'boolean');
         if (configValue?.value === false) {
-            const definedAtInfo = getConfigDefinedAtInfo(pageConfig, configName);
+            const filePath = getConfigValueFilePathToShowToUser(configValue);
+            assert(filePath);
             doNotPrerenderList.push({
                 pageId: pageConfig.pageId,
                 setByConfigName: 'prerender',
                 setByConfigValue: false,
-                setByConfigFile: definedAtInfo.filePath
+                setByConfigFile: filePath
             });
         }
     });
@@ -148,8 +149,7 @@ async function callOnBeforePrerenderStartHooks(prerenderContext, renderContext,
         if (!configValue)
             return;
         const hookFn = configValue.value;
-        const definedAtInfo = getConfigDefinedAtInfo(pageConfigLoaded, hookName);
-        const hookFilePath = definedAtInfo.filePath;
+        const hookFilePath = getHookFilePathToShowToUser(configValue);
         assert(hookFilePath);
         assertHookFn(hookFn, { hookName, hookFilePath });
         onBeforePrerenderStartHooks.push({
@@ -282,11 +282,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
-            assert(definedAtInfo);
-            const hookFilePath = definedAtInfo.filePath;
+            const hookFilePath = getHookFilePathToShowToUser(configValue);
+            assert(hookFilePath);
             onPrerenderStartHook = {
                 hookFn,
                 hookName: 'onPrerenderStart',

package/dist/esm/node/runtime/html/injectAssets/getHtmlTags.js

@@ -106,7 +106,7 @@ async function getHtmlTags(pageContext, injectToStream, injectFilter) {
     if (!isHtmlOnly) {
         // Don't allow the user to manipulate with injectFilter(): injecting <script type="application/json"> before the stream can break the app when:
         //  - using https://vike.dev/stream#initial-data-after-stream-end
-        //  - `pageContext` is modified during the stream, e.g. /examples/vue-pinia which uses https://vuejs.org/api/composition-api-lifecycle.html#onserverprefetch
+        //  - `pageContext` is modified during the stream, e.g. https://github.com/brillout/vike-with-pinia which uses https://vuejs.org/api/composition-api-lifecycle.html#onserverprefetch
         // The <script> tags are handled separately by vike down below.
         htmlTags.push({
             // Needs to be called after `resolvePageContextPromise()`

package/dist/esm/node/runtime/renderPage/log404/index.js

@@ -67,8 +67,8 @@ function getPagesAndRoutesInfo(pageRoutes) {
         ...entries
     ];
     const terminalWidth = getTerminalWidth() || 134;
-    let width2 = Math.max(...linesContent.map(({ routeTypeSrc }) => routeTypeSrc.length));
-    let width3 = Math.max(...linesContent.map(({ routeDefinedBy }) => routeDefinedBy.length));
+    let width2 = Math.max(...linesContent.map(({ routeTypeSrc }) => stripAnsi(routeTypeSrc).length));
+    let width3 = Math.max(...linesContent.map(({ routeDefinedBy }) => stripAnsi(routeDefinedBy).length));
     let width1 = terminalWidth - width3 - width2 - 10;
     linesContent.forEach((lineContent) => {
         let { routeStr } = lineContent;
@@ -83,9 +83,9 @@ function getPagesAndRoutesInfo(pageRoutes) {
     });
     width1 = Math.max(...linesContent.map(({ routeStr }) => stripAnsi(routeStr).length));
     let lines = linesContent.map(({ routeStr, routeTypeSrc, routeDefinedBy }, i) => {
-        let cell1 = routeStr.padEnd(width1 + (routeStr.length - stripAnsi(routeStr).length), ' ');
-        let cell2 = routeTypeSrc.padEnd(width2, ' ');
-        let cell3 = routeDefinedBy.padEnd(width3, ' ');
+        let cell1 = padEnd(routeStr, width1 + (stripAnsi(routeStr).length - stripAnsi(routeStr).length));
+        let cell2 = padEnd(routeTypeSrc, width2);
+        let cell3 = padEnd(routeDefinedBy, width3);
         const isHeader = i === 0;
         if (isHeader) {
             cell1 = pc.dim(cell1);
@@ -119,6 +119,11 @@ function truncateRouteFunction(routeStr, lenMax) {
     routeStr = truncateString(routeStr, lenMax, (s) => pc.dim(s));
     return routeStr;
 }
+/** Same as String.prototype.padEnd but with stripAnsi() */
+function padEnd(str, width) {
+    const padWidth = Math.max(0, width - stripAnsi(str).length);
+    return str + ''.padEnd(padWidth, ' ');
+}
 function removeNonAscii(str) {
     // https://stackoverflow.com/questions/20856197/remove-non-ascii-character-in-string/20856346#20856346
     return str.replace(/[^\x00-\x7F]/g, '');

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

@@ -20,6 +20,7 @@ import { preparePageContextForUserConsumptionServerSide } from './preparePageCon
 import { executeGuardHook } from '../../../shared/route/executeGuardHook.js';
 import { loadPageRoutes } from '../../../shared/route/loadPageRoutes.js';
 import pc from '@brillout/picocolors';
+import { getConfigValueFilePathToShowToUser } from '../../../shared/page-configs/utils.js';
 async function renderPageAlreadyRouted(pageContext) {
     // pageContext._pageId can either be the:
     //  - ID of the page matching the routing, or the
@@ -166,9 +167,9 @@ function assertNonMixedDesign(pageFilesAll, pageConfigs) {
     const indent = '- ';
     const v1Files = unique(pageConfigs
         .map((p) => Object.values(p.configValues)
-        .map(({ definedAtInfo }) => definedAtInfo)
+        .map(getConfigValueFilePathToShowToUser)
         .filter(isNotNullish)
-        .map((definedAtInfo) => indent + definedAtInfo.filePath))
+        .map((filePathToShowToUser) => indent + filePathToShowToUser))
         .flat(2));
     assertUsage(false, [
         'Mixing the new V1 design with the old V0.4 design is forbidden.',

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

@@ -1,15 +1,9 @@
 export { getClientEntryFilePath };
-import { getConfigDefinedAtInfo, getConfigValue } from '../../shared/page-configs/utils.js';
-import { assert } from './utils.js';
+import { getConfigValue } from '../../shared/page-configs/utils.js';
 function getClientEntryFilePath(pageConfig) {
     const configName = 'client';
     const configValue = getConfigValue(pageConfig, configName, 'string');
     if (!configValue)
         return null;
-    const definedAtInfo = getConfigDefinedAtInfo(pageConfig, configName);
-    const { value } = configValue;
-    // Users should be able to suppress client entry by setting its value to null
-    assert(value !== null);
-    const clientEntryFilePath = definedAtInfo.filePath;
-    return clientEntryFilePath;
+    return configValue.value;
 }

package/dist/esm/shared/addUrlComputedProps.d.ts

@@ -4,7 +4,8 @@ export type { PageContextUrlComputedPropsInternal };
 export type { PageContextUrlComputedPropsClient };
 export type { PageContextUrlComputedPropsServer };
 export type { PageContextUrlSources };
-type UrlParsed = {
+export type { Url };
+type Url = {
     /** The URL origin, e.g. `https://example.com` of `https://example.com/product/42?details=yes#reviews` */
     origin: null | string;
     /** The URL pathname, e.g. `/product/42` of `https://example.com/product/42?details=yes#reviews` */
@@ -34,8 +35,9 @@ type PageContextUrlComputedPropsClient = {
     /** The URL pathname, e.g. `/product/42` of `https://example.com/product/42?details=yes#reviews` */
     urlPathname: string;
     /** Parsed information about the current URL */
-    urlParsed: UrlParsed;
+    urlParsed: Url;
 };
+/** For Vike internal use */
 type PageContextUrlComputedPropsInternal = PageContextUrlComputedPropsClient & {
     _urlRewrite: string | null;
 };