vike 0.4.143-commit-f03b42d → 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/getFilePathToShowToUser.js

@@ -2,6 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getFilePathToShowToUser = void 0;
 const utils_js_1 = require("../../../utils.js");
+/*
+const f: FilePath = 1 as any
+if (f.filePathRelativeToUserRootDir === null) {
+  f.importPathAbsolute
+}
+//*/
 function getFilePathToShowToUser(filePath) {
     const filePathToShowToUser = filePath.filePathRelativeToUserRootDir ?? filePath.filePathAbsolute;
     (0, utils_js_1.assert)(filePathToShowToUser);

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

@@ -89,7 +89,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);
@@ -108,7 +109,8 @@ async function loadInterfaceFiles(userRootDir, isDev, extensions) {
         const interfaceFile = {
             filePath: {
                 filePathRelativeToUserRootDir,
-                filePathAbsolute
+                filePathAbsolute,
+                importPathAbsolute: null
             },
             configMap: {
                 [configName]: {}
@@ -343,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;
         }
     });
@@ -426,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;
     }
@@ -476,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;
         }
@@ -494,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) {
@@ -559,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:
         // ```
@@ -567,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);
@@ -675,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);
@@ -802,7 +807,7 @@ function assertNoUnexpectedPlusSign(filePath, fileName) {
     (0, utils_js_1.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 (0, transpileAndExecuteFile_js_1.transpileAndExecuteFile)(configFilePath, false, userRootDir);
     const { extendsConfigs, extendsFilePaths } = await loadExtendsConfigs(fileExports, configFilePath, userRootDir, [
@@ -811,10 +816,7 @@ async function loadConfigFile(configFilePath, userRootDir, visited) {
     ]);
     const configFile = {
         fileExports,
-        filePath: {
-            filePathRelativeToUserRootDir,
-            filePathAbsolute
-        },
+        filePath: configFilePath,
         extendsFilePaths
     };
     return { configFile, extendsConfigs };
@@ -837,11 +839,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 = [];
@@ -1004,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 };
@@ -1054,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
                 };
             }
         }
@@ -1065,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))
+                }
             };
         }
     });
@@ -1077,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.)`);
@@ -1085,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';
@@ -1095,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;
@@ -1126,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/html/injectAssets/getHtmlTags.js

@@ -111,7 +111,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()`