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

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

@@ -72,8 +72,8 @@ function getPagesAndRoutesInfo(pageRoutes) {
         ...entries
     ];
     const terminalWidth = (0, utils_js_1.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 }) => (0, utils_js_1.stripAnsi)(routeTypeSrc).length));
+    let width3 = Math.max(...linesContent.map(({ routeDefinedBy }) => (0, utils_js_1.stripAnsi)(routeDefinedBy).length));
     let width1 = terminalWidth - width3 - width2 - 10;
     linesContent.forEach((lineContent) => {
         let { routeStr } = lineContent;
@@ -88,9 +88,9 @@ function getPagesAndRoutesInfo(pageRoutes) {
     });
     width1 = Math.max(...linesContent.map(({ routeStr }) => (0, utils_js_1.stripAnsi)(routeStr).length));
     let lines = linesContent.map(({ routeStr, routeTypeSrc, routeDefinedBy }, i) => {
-        let cell1 = routeStr.padEnd(width1 + (routeStr.length - (0, utils_js_1.stripAnsi)(routeStr).length), ' ');
-        let cell2 = routeTypeSrc.padEnd(width2, ' ');
-        let cell3 = routeDefinedBy.padEnd(width3, ' ');
+        let cell1 = padEnd(routeStr, width1 + ((0, utils_js_1.stripAnsi)(routeStr).length - (0, utils_js_1.stripAnsi)(routeStr).length));
+        let cell2 = padEnd(routeTypeSrc, width2);
+        let cell3 = padEnd(routeDefinedBy, width3);
         const isHeader = i === 0;
         if (isHeader) {
             cell1 = picocolors_1.default.dim(cell1);
@@ -125,6 +125,11 @@ function truncateRouteFunction(routeStr, lenMax) {
     routeStr = (0, utils_js_1.truncateString)(routeStr, lenMax, (s) => picocolors_1.default.dim(s));
     return routeStr;
 }
+/** Same as String.prototype.padEnd but with stripAnsi() */
+function padEnd(str, width) {
+    const padWidth = Math.max(0, width - (0, utils_js_1.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/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

package/dist/cjs/shared/hooks/getHook.js

@@ -11,7 +11,9 @@ function getHook(pageContext, hookName) {
     (0, utils_js_1.assert)(file.exportValue === hookFn);
     if (hookFn === null)
         return null;
-    const hookFilePath = file.exportSource;
+    const hookFilePath = file.filePath;
+    (0, utils_js_1.assert)(hookFilePath);
+    (0, utils_js_1.assert)(!hookFilePath.endsWith(' '));
     assertHookFn(hookFn, { hookName, hookFilePath });
     return { hookFn, hookName, hookFilePath };
 }

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

@@ -2,9 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getExportPath = void 0;
 const utils_js_1 = require("../utils.js");
-// TODO: return null instead of 'export default'
-//  - Also return null insead of 'export *'?
 function getExportPath(fileExportPath) {
+    if (!fileExportPath)
+        return null;
     let prefix = '';
     let suffix = '';
     let [exportName, ...exportObjectPath] = fileExportPath;

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

@@ -9,15 +9,18 @@ const assertExports_js_1 = require("./assertExports.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 function parseConfigValuesImported(configValuesImported) {
     const configValues = {};
-    const addConfigValue = (configName, value, filePath, exportName) => {
+    const addConfigValue = (configName, value, importPath, exportName) => {
         configValues[configName] = {
             value,
-            definedAtInfo: {
-                filePath,
-                fileExportPath: [exportName]
+            definedAt: {
+                source: {
+                    // importPath is always relative the user's root directory (it cannot be relative to the current file since the current file is a virtual file)
+                    filePathToShowToUser: importPath,
+                    fileExportPath: [exportName]
+                }
             }
         };
-        assertIsNotNull(value, configName, filePath);
+        assertIsNotNull(value, configName, importPath);
     };
     configValuesImported.forEach((configValueLoaded) => {
         if (configValueLoaded.isValueFile) {

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

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getDefinedAtString = exports.getConfigDefinedAtInfo = exports.getConfigDefinedAtString = exports.getPageConfig = exports.getConfigValue = void 0;
+exports.getHookFilePathToShowToUser = exports.getConfigValueFilePathToShowToUser = exports.getDefinedAtString = exports.getConfigDefinedAtString = exports.getPageConfig = exports.getConfigValue = void 0;
 const utils_js_1 = require("../utils.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const getExportPath_js_1 = require("./getExportPath.js");
@@ -12,33 +12,30 @@ function getConfigValue(pageConfig, configName, type) {
     const configValue = getConfigValueEntry(pageConfig, configName);
     if (configValue === null)
         return null;
-    const { value, definedAtInfo } = configValue;
+    const { value, definedAt } = configValue;
     if (type)
-        assertConfigValueType(value, type, configName, definedAtInfo);
-    return { value };
+        assertConfigValueType(value, type, configName, definedAt);
+    return configValue;
 }
 exports.getConfigValue = getConfigValue;
-function getConfigDefinedAtInfo(pageConfig, configName) {
-    const configValue = getConfigValueEntry(pageConfig, configName);
-    // We assume the caller to have ensured that the config value exists prior to calling getConfigDefinedAtInfo()
-    (0, utils_js_1.assert)(configValue);
-    const { definedAtInfo } = configValue;
-    // definedAtInfo is available only for config values that aren't:
-    //  - computed, nor
-    //  - cumulative
-    (0, utils_js_1.assert)(definedAtInfo);
-    return definedAtInfo;
+function assertConfigValueType(value, type, configName, definedAt) {
+    (0, utils_js_1.assert)(value !== null);
+    const typeActual = typeof value;
+    if (typeActual === type)
+        return;
+    const valuePrintable = (0, utils_js_1.getValuePrintable)(value);
+    const problem = valuePrintable !== null ? `value ${picocolors_1.default.cyan(valuePrintable)}` : `type ${picocolors_1.default.cyan(typeActual)}`;
+    const configDefinedAt = getConfigDefinedAtString(configName, { definedAt }, true);
+    (0, utils_js_1.assertUsage)(false, `${configDefinedAt} has an invalid ${problem}: it should be a ${picocolors_1.default.cyan(type)} instead`);
 }
-exports.getConfigDefinedAtInfo = getConfigDefinedAtInfo;
 function getConfigValueEntry(pageConfig, configName) {
     const configValue = pageConfig.configValues[configName];
     if (!configValue)
         return null;
-    const { value, definedAtInfo } = configValue;
     // Enable users to suppress global config values by setting the local config value to null
-    if (value === null)
+    if (configValue.value === null)
         return null;
-    return { value, definedAtInfo };
+    return configValue;
 }
 function getPageConfig(pageId, pageConfigs) {
     const pageConfig = pageConfigs.find((p) => p.pageId === pageId);
@@ -47,34 +44,61 @@ function getPageConfig(pageId, pageConfigs) {
     return pageConfig;
 }
 exports.getPageConfig = getPageConfig;
-function assertConfigValueType(value, type, configName, definedAtInfo) {
-    (0, utils_js_1.assert)(value !== null);
-    const typeActual = typeof value;
-    if (typeActual === type)
-        return;
-    const valuePrintable = (0, utils_js_1.getValuePrintable)(value);
-    const problem = valuePrintable !== null ? `value ${picocolors_1.default.cyan(valuePrintable)}` : `type ${picocolors_1.default.cyan(typeActual)}`;
-    const configDefinedAt = getConfigDefinedAtString(configName, { definedAtInfo }, true);
-    (0, utils_js_1.assertUsage)(false, `${configDefinedAt} has an invalid ${problem}: it should be a ${picocolors_1.default.cyan(type)} instead`);
-}
-function getConfigDefinedAtString(configName, { definedAtInfo }, sentenceBegin, append) {
-    let configDefinedAt = `${sentenceBegin ? `Config` : `config`} ${picocolors_1.default.cyan(configName)}`;
-    if (definedAtInfo !== null) {
-        configDefinedAt = `${configDefinedAt} defined at ${getDefinedAtString(definedAtInfo, append)}`;
-    }
+function getConfigDefinedAtString(configName, { definedAt }, sentenceBegin) {
+    const configDefinedAt = `${sentenceBegin ? `Config` : `config`} ${picocolors_1.default.cyan(configName)} defined ${getSourceString(definedAt)}`;
     return configDefinedAt;
 }
 exports.getConfigDefinedAtString = getConfigDefinedAtString;
-function getDefinedAtString(definedAtInfo, append) {
-    const { filePath, fileExportPath } = definedAtInfo;
-    let definedAt = filePath;
-    const exportPath = (0, getExportPath_js_1.getExportPath)(fileExportPath);
-    if (exportPath) {
-        definedAt = `${definedAt} > ${picocolors_1.default.cyan(exportPath)}`;
+function getSourceString(definedAt) {
+    if (definedAt.isComputed) {
+        return 'internally';
     }
-    if (append) {
-        definedAt = `${definedAt} > (${picocolors_1.default.blue(append)})`;
+    let sources;
+    if (definedAt.isCumulative) {
+        sources = definedAt.sources;
     }
-    return definedAt;
+    else {
+        sources = [definedAt.source];
+    }
+    (0, utils_js_1.assert)(sources.length >= 1);
+    const sourceString = sources
+        .map((source) => {
+        const { filePathToShowToUser, fileExportPath } = source;
+        let s = filePathToShowToUser;
+        const exportPath = (0, getExportPath_js_1.getExportPath)(fileExportPath);
+        if (exportPath) {
+            s = `${s} > ${picocolors_1.default.cyan(exportPath)}`;
+        }
+        if (definedAt.isEffect) {
+            s = `${s} > (${picocolors_1.default.blue('effect')})`;
+        }
+        return s;
+    })
+        .join(' / ');
+    return `at ${sourceString}`;
+}
+function getDefinedAtString(configValue) {
+    let sourceString = getSourceString(configValue.definedAt);
+    if (sourceString.startsWith('at '))
+        sourceString = sourceString.slice('at '.length);
+    return sourceString;
 }
 exports.getDefinedAtString = getDefinedAtString;
+function getConfigValueFilePathToShowToUser({ definedAt }) {
+    // A unique file path only exists if the config value isn't cumulative nor computed:
+    //  - cumulative config values have multiple file paths
+    //  - computed values don't have any file path
+    if (definedAt.isComputed || definedAt.isCumulative)
+        return null;
+    const { source } = definedAt;
+    const { filePathToShowToUser } = source;
+    (0, utils_js_1.assert)(filePathToShowToUser);
+    return filePathToShowToUser;
+}
+exports.getConfigValueFilePathToShowToUser = getConfigValueFilePathToShowToUser;
+function getHookFilePathToShowToUser({ definedAt }) {
+    const filePathToShowToUser = getConfigValueFilePathToShowToUser({ definedAt });
+    (0, utils_js_1.assert)(filePathToShowToUser);
+    return filePathToShowToUser;
+}
+exports.getHookFilePathToShowToUser = getHookFilePathToShowToUser;

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

@@ -33,9 +33,8 @@ function getPageRoutes(filesystemRoots, pageFilesAll, pageConfigs, allPageIds) {
                 const configName = 'route';
                 const configValue = (0, utils_js_3.getConfigValue)(pageConfig, configName);
                 if (configValue) {
-                    const definedAtInfo = (0, utils_js_3.getConfigDefinedAtInfo)(pageConfig, configName);
                     const route = configValue.value;
-                    const definedAt = (0, utils_js_3.getDefinedAtString)(definedAtInfo);
+                    const definedAt = (0, utils_js_3.getDefinedAtString)(configValue);
                     if (typeof route === 'string') {
                         pageRoute = {
                             pageId,
@@ -141,10 +140,10 @@ function getGlobalHooks(pageFilesAll, pageConfigs, pageConfigGlobal) {
     // V1 Design
     if (pageConfigs.length > 0) {
         if (pageConfigGlobal.configValues.onBeforeRoute?.value) {
-            const { value: hookFn, definedAtInfo } = pageConfigGlobal.configValues.onBeforeRoute;
-            // config.onBeforeRoute isn't a computed nor a cumulative config => definedAtInfo should always be defined
-            (0, utils_js_1.assert)(definedAtInfo);
-            const hookFilePath = definedAtInfo.filePath;
+            const configValue = pageConfigGlobal.configValues.onBeforeRoute;
+            const { value: hookFn } = configValue;
+            const hookFilePath = (0, utils_js_3.getHookFilePathToShowToUser)(configValue);
+            // TODO: use getConfigDefinedAtString()
             (0, utils_js_1.assertUsage)((0, utils_js_2.isCallable)(hookFn), `The hook onBeforeRoute() defined by ${hookFilePath} should be a function.`);
             const onBeforeRouteHook = {
                 hookFilePath: hookFilePath,

package/dist/cjs/utils/projectInfo.js

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

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

@@ -22,7 +22,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);
 }
 async function getPageDeps(config, pageConfigs, isDev) {
     let entries = [];
@@ -32,37 +32,40 @@ async function getPageDeps(config, pageConfigs, isDev) {
         pageConfigs.forEach((pageConfig) => {
             const configValueSourcesRelevant = getConfigValueSourcesRelevant(pageConfig);
             configValueSourcesRelevant.forEach((configValueSource) => {
-                const { valueIsImportedAtRuntime, configEnv, definedAtInfo } = configValueSource;
-                if (!valueIsImportedAtRuntime)
+                if (!configValueSource.valueIsImportedAtRuntime)
                     return;
-                const { filePath } = definedAtInfo;
-                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(getFilePathAbsolute(filePath, config));
+                const { definedAtInfo, configEnv } = configValueSource;
+                if (configEnv !== 'client-only' && configEnv !== 'server-and-client')
                     return;
-                }
-                // getVikeConfig() resolves relative import paths
-                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 (isNpmPackageImport(filePath)) {
-                    // isNpmPackageImport() returns false for a path alias like #root/renderer/onRenderClient
-                    assert(!filePath.startsWith('#'));
-                    include.push(filePath);
+                if (definedAtInfo.filePathRelativeToUserRootDir !== null) {
+                    const { filePathAbsolute } = definedAtInfo;
+                    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;
+                    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 (isNpmPackageImport(importPathAbsolute)) {
+                        // isNpmPackageImport() returns false for a path alias like #root/renderer/onRenderClient
+                        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/esm/node/plugin/plugins/importUserCode/v1-design/getFilePathToShowToUser.d.ts

@@ -6,10 +6,19 @@ type FilePath = {
      * Example: `/home/rom/code/my-app/pages/some-page/Page.js`
      */
     filePathAbsolute: string;
+} & ({
     /** The file's path relative to the Vite's root (i.e. the user's project root directory).
      *
      * Example: `/pages/some-page/Page.js`
      */
-    filePathRelativeToUserRootDir: null | string;
-};
+    filePathRelativeToUserRootDir: string;
+    importPathAbsolute: null;
+} | {
+    filePathRelativeToUserRootDir: null;
+    /** The file's absolute import path.
+     *
+     * Example: `vike-react/config`
+     */
+    importPathAbsolute: string;
+});
 declare function getFilePathToShowToUser(filePath: FilePath): string;

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

@@ -1,5 +1,11 @@
 export { getFilePathToShowToUser };
 import { assert } from '../../../utils.js';
+/*
+const f: FilePath = 1 as any
+if (f.filePathRelativeToUserRootDir === null) {
+  f.importPathAbsolute
+}
+//*/
 function getFilePathToShowToUser(filePath) {
     const filePathToShowToUser = filePath.filePathRelativeToUserRootDir ?? filePath.filePathAbsolute;
     assert(filePathToShowToUser);

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

@@ -31,17 +31,18 @@ type ConfigDefinition = {
     effect?: ConfigEffect;
 };
 type ConfigEffect = (config: {
-    /** The resolved config value.
+    /** The config value.
      *
      * https://vike.dev/meta
      */
     configValue: unknown;
-    /** Place where the resolved config value comes from.
+    /** Where the config value is defined.
      *
      * https://vike.dev/meta
      */
     configDefinedAt: `Config ${string}`;
 }) => Config | undefined;
+/** For Vike internal use */
 type ConfigDefinitionInternal = Omit<ConfigDefinition, 'env'> & {
     _computed?: (pageConfig: PageConfigBuildTime) => unknown;
     _valueIsFilePath?: true;