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

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/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/getPageFiles/getExports.d.ts

@@ -9,13 +9,12 @@ import type { PageFile } from './getPageFileObject.js';
 type ExportsAll = Record<string, {
     exportValue: unknown;
     exportSource: string;
+    filePath: string | null;
     /** @deprecated */
     _fileType: FileType | null;
     /** @deprecated */
     _isFromDefaultExport: boolean | null;
     /** @deprecated */
-    filePath: string | null;
-    /** @deprecated */
     _filePath: string | null;
 }[]>;
 /** All the config's values (including overriden ones) and where they come from.

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

@@ -3,7 +3,7 @@ export { getExports };
 import { isScriptFile, isTemplateFile } from '../../utils/isScriptFile.js';
 import { assert, hasProp, isObject, assertWarning, assertUsage, makeLast, isBrowser } from '../utils.js';
 import { assertDefaultExports, forbiddenDefaultExports } from './assert_exports_old_design.js';
-import { getConfigDefinedAtString } from '../page-configs/utils.js';
+import { getConfigDefinedAtString, getConfigValueFilePathToShowToUser } from '../page-configs/utils.js';
 import pc from '@brillout/picocolors';
 function getExports(pageFiles, pageConfig) {
     const configEntries = {};
@@ -29,11 +29,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 = getConfigValueFilePathToShowToUser(configValue);
             const configDefinedAt = getConfigDefinedAtString(configName, configValue, true);
             config[configName] = config[configName] ?? value;
             configEntries[configName] = configEntries[configName] ?? [];

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

@@ -2,6 +2,7 @@ export { parsePageConfigsSerialized };
 import { parse } from '@brillout/json-serializer/parse';
 import { parseConfigValuesImported } from '../page-configs/parseConfigValuesImported.js';
 import { assert, assertUsage, isCallable } from '../utils.js';
+import { getConfigDefinedAtString } from '../page-configs/utils.js';
 function parsePageConfigsSerialized(pageConfigsSerialized, pageConfigGlobalSerialized) {
     const pageConfigs = pageConfigsSerialized.map((pageConfigSerialized) => {
         const configValues = {};
@@ -9,12 +10,12 @@ function parsePageConfigsSerialized(pageConfigsSerialized, pageConfigGlobalSeria
             const { configValuesSerialized } = pageConfigSerialized;
             Object.entries(configValuesSerialized).forEach(([configName, configValueSeriliazed]) => {
                 {
-                    const { valueSerialized, definedAtInfo } = configValueSeriliazed;
+                    const { valueSerialized, definedAt } = configValueSeriliazed;
                     assert(valueSerialized);
                     assert(!configValues[configName]);
                     configValues[configName] = {
                         value: parse(valueSerialized),
-                        definedAtInfo
+                        definedAt
                     };
                 }
             });
@@ -42,12 +43,14 @@ function parsePageConfigsSerialized(pageConfigsSerialized, pageConfigGlobalSeria
     return { pageConfigs, pageConfigGlobal };
 }
 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;
-    assert(definedAtInfo);
-    assertUsage(configValueType === 'string' || 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 = getConfigDefinedAtString(configName, configValue, true);
+    assertUsage(configValueType === 'string' || 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/esm/shared/hooks/getHook.js

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

package/dist/esm/shared/page-configs/PageConfig.d.ts

@@ -14,8 +14,10 @@ export type { ConfigValueImported };
 export type { ConfigValues };
 export type { ConfigValueSource };
 export type { ConfigValueSources };
-export type { DefinedAtInfo };
+export type { DefinedAt };
+export type { DefinedAtInfoNew };
 export type { DefinedAtInfoFull };
+export type { DefinedAtInfoFull as DefinedAtInfo };
 type PageConfigBase = {
     pageId: string;
     isErrorPage?: true;
@@ -70,7 +72,7 @@ type ConfigValueSource = {
     valueIsFilePath?: true;
 } & ({
     isComputed: false;
-    definedAtInfo: DefinedAtInfo;
+    definedAtInfo: DefinedAtInfoFull;
 } | {
     isComputed: true;
     definedAtInfo: null;
@@ -79,21 +81,43 @@ type ConfigValueSource = {
 type ConfigValueSources = Record<string, ConfigValueSource[]>;
 type ConfigValue = {
     value: unknown;
-    definedAtInfo: null | DefinedAtInfo;
+    definedAt: DefinedAt;
 };
 type ConfigValueSerialized = {
     valueSerialized: string;
-    definedAtInfo: null | DefinedAtInfo;
+    definedAt: DefinedAt;
 };
 type ConfigValues = Record<string, ConfigValue>;
-type DefinedAtInfo = {
-    filePath: string;
-    fileExportPath: string[];
+type DefinedAt = {
+    source: DefinedAtInfoNew;
+    isEffect?: true;
+    isComputed?: undefined;
+    isCumulative?: undefined;
+} | {
+    isCumulative: true;
+    sources: DefinedAtInfoNew[];
+    isEffect?: undefined;
+    isComputed?: undefined;
+} | {
+    isComputed: true;
+    isEffect?: undefined;
+    isCumulative?: undefined;
 };
-type DefinedAtInfoFull = {
-    filePathRelativeToUserRootDir?: string;
+type DefinedAtInfoNew = {
+    filePathToShowToUser: string;
+    fileExportPath: null | string[];
+};
+type DefinedAtInfoFull = ({
+    filePathRelativeToUserRootDir: string;
     filePathAbsolute: string;
-    fileExportPath: string[];
+    importPathAbsolute: null;
+} | {
+    filePathRelativeToUserRootDir: null;
+    filePathAbsolute: string | null;
+    importPathAbsolute: string;
+}) & {
+    exportName?: string;
+    fileExportPath: null | string[];
 };
 type ConfigSource = {
     configSourceFile: string;

package/dist/esm/shared/page-configs/getExportPath.d.ts

@@ -1,2 +1,2 @@
 export { getExportPath };
-declare function getExportPath(fileExportPath: string[]): null | string;
+declare function getExportPath(fileExportPath: null | string[]): null | string;

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

@@ -1,8 +1,8 @@
 export { getExportPath };
 import { assert } from '../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/esm/shared/page-configs/parseConfigValuesImported.js

@@ -4,15 +4,18 @@ import { assertExportsOfValueFile } from './assertExports.js';
 import pc from '@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/esm/shared/page-configs/utils.d.ts

@@ -1,29 +1,35 @@
 export { getConfigValue };
 export { getPageConfig };
 export { getConfigDefinedAtString };
-export { getConfigDefinedAtInfo };
 export { getDefinedAtString };
-import type { DefinedAtInfo, PageConfigRuntime, PageConfigBuildTime } from './PageConfig.js';
+export { getConfigValueFilePathToShowToUser };
+export { getHookFilePathToShowToUser };
+import type { PageConfigRuntime, PageConfigBuildTime, ConfigValue, DefinedAt } from './PageConfig.js';
 import type { ConfigNameBuiltIn } from './Config.js';
 type PageConfigCommon = PageConfigRuntime | PageConfigBuildTime;
 type ConfigName = ConfigNameBuiltIn;
-declare function getConfigValue(pageConfig: PageConfigCommon, configName: ConfigName, type: 'string'): null | {
+declare function getConfigValue(pageConfig: PageConfigCommon, configName: ConfigName, type: 'string'): null | ConfigValue & {
     value: string;
 };
-declare function getConfigValue(pageConfig: PageConfigCommon, configName: ConfigName, type: 'boolean'): null | {
+declare function getConfigValue(pageConfig: PageConfigCommon, configName: ConfigName, type: 'boolean'): null | ConfigValue & {
     value: boolean;
 };
-declare function getConfigValue(pageConfig: PageConfigCommon, configName: ConfigName): null | {
+declare function getConfigValue(pageConfig: PageConfigCommon, configName: ConfigName): null | ConfigValue & {
     value: unknown;
 };
-declare function getConfigDefinedAtInfo(pageConfig: PageConfigCommon, configName: ConfigName): DefinedAtInfo;
 declare function getPageConfig(pageId: string, pageConfigs: PageConfigRuntime[]): PageConfigRuntime;
-type ConfigDefinedAtUppercase<ConfigName extends string> = `Config ${ConfigName}${string}`;
-type ConfigDefinedAtLowercase<ConfigName extends string> = `config ${ConfigName}${string}`;
-declare function getConfigDefinedAtString<ConfigName extends string>(configName: ConfigName, { definedAtInfo }: {
-    definedAtInfo: null | DefinedAtInfo;
+type ConfigDefinedAtUppercase<ConfigName extends string> = `Config ${ConfigName} defined ${string}`;
+type ConfigDefinedAtLowercase<ConfigName extends string> = `config ${ConfigName} defined ${string}`;
+declare function getConfigDefinedAtString<ConfigName extends string>(configName: ConfigName, { definedAt }: {
+    definedAt: DefinedAt;
 }, sentenceBegin: true, append?: 'effect'): ConfigDefinedAtUppercase<ConfigName>;
-declare function getConfigDefinedAtString<ConfigName extends string>(configName: ConfigName, { definedAtInfo }: {
-    definedAtInfo: null | DefinedAtInfo;
+declare function getConfigDefinedAtString<ConfigName extends string>(configName: ConfigName, { definedAt }: {
+    definedAt: DefinedAt;
 }, sentenceBegin: false, append?: 'effect'): ConfigDefinedAtLowercase<ConfigName>;
-declare function getDefinedAtString(definedAtInfo: DefinedAtInfo, append?: 'effect'): string;
+declare function getDefinedAtString(configValue: ConfigValue): string;
+declare function getConfigValueFilePathToShowToUser({ definedAt }: {
+    definedAt: DefinedAt;
+}): null | string;
+declare function getHookFilePathToShowToUser({ definedAt }: {
+    definedAt: DefinedAt;
+}): string;

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

@@ -1,8 +1,9 @@
 export { getConfigValue };
 export { getPageConfig };
 export { getConfigDefinedAtString };
-export { getConfigDefinedAtInfo };
 export { getDefinedAtString };
+export { getConfigValueFilePathToShowToUser };
+export { getHookFilePathToShowToUser };
 import { assert, assertUsage, getValuePrintable } from '../utils.js';
 import pc from '@brillout/picocolors';
 import { getExportPath } from './getExportPath.js';
@@ -11,31 +12,29 @@ 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;
 }
-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()
-    assert(configValue);
-    const { definedAtInfo } = configValue;
-    // definedAtInfo is available only for config values that aren't:
-    //  - computed, nor
-    //  - cumulative
-    assert(definedAtInfo);
-    return definedAtInfo;
+function assertConfigValueType(value, type, configName, definedAt) {
+    assert(value !== null);
+    const typeActual = typeof value;
+    if (typeActual === type)
+        return;
+    const valuePrintable = getValuePrintable(value);
+    const problem = valuePrintable !== null ? `value ${pc.cyan(valuePrintable)}` : `type ${pc.cyan(typeActual)}`;
+    const configDefinedAt = getConfigDefinedAtString(configName, { definedAt }, true);
+    assertUsage(false, `${configDefinedAt} has an invalid ${problem}: it should be a ${pc.cyan(type)} instead`);
 }
 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);
@@ -43,32 +42,57 @@ function getPageConfig(pageId, pageConfigs) {
     assert(pageConfig);
     return pageConfig;
 }
-function assertConfigValueType(value, type, configName, definedAtInfo) {
-    assert(value !== null);
-    const typeActual = typeof value;
-    if (typeActual === type)
-        return;
-    const valuePrintable = getValuePrintable(value);
-    const problem = valuePrintable !== null ? `value ${pc.cyan(valuePrintable)}` : `type ${pc.cyan(typeActual)}`;
-    const configDefinedAt = getConfigDefinedAtString(configName, { definedAtInfo }, true);
-    assertUsage(false, `${configDefinedAt} has an invalid ${problem}: it should be a ${pc.cyan(type)} instead`);
-}
-function getConfigDefinedAtString(configName, { definedAtInfo }, sentenceBegin, append) {
-    let configDefinedAt = `${sentenceBegin ? `Config` : `config`} ${pc.cyan(configName)}`;
-    if (definedAtInfo !== null) {
-        configDefinedAt = `${configDefinedAt} defined at ${getDefinedAtString(definedAtInfo, append)}`;
-    }
+function getConfigDefinedAtString(configName, { definedAt }, sentenceBegin) {
+    const configDefinedAt = `${sentenceBegin ? `Config` : `config`} ${pc.cyan(configName)} defined ${getSourceString(definedAt)}`;
     return configDefinedAt;
 }
-function getDefinedAtString(definedAtInfo, append) {
-    const { filePath, fileExportPath } = definedAtInfo;
-    let definedAt = filePath;
-    const exportPath = getExportPath(fileExportPath);
-    if (exportPath) {
-        definedAt = `${definedAt} > ${pc.cyan(exportPath)}`;
+function getSourceString(definedAt) {
+    if (definedAt.isComputed) {
+        return 'internally';
     }
-    if (append) {
-        definedAt = `${definedAt} > (${pc.blue(append)})`;
+    let sources;
+    if (definedAt.isCumulative) {
+        sources = definedAt.sources;
     }
-    return definedAt;
+    else {
+        sources = [definedAt.source];
+    }
+    assert(sources.length >= 1);
+    const sourceString = sources
+        .map((source) => {
+        const { filePathToShowToUser, fileExportPath } = source;
+        let s = filePathToShowToUser;
+        const exportPath = getExportPath(fileExportPath);
+        if (exportPath) {
+            s = `${s} > ${pc.cyan(exportPath)}`;
+        }
+        if (definedAt.isEffect) {
+            s = `${s} > (${pc.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;
+}
+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;
+    assert(filePathToShowToUser);
+    return filePathToShowToUser;
+}
+function getHookFilePathToShowToUser({ definedAt }) {
+    const filePathToShowToUser = getConfigValueFilePathToShowToUser({ definedAt });
+    assert(filePathToShowToUser);
+    return filePathToShowToUser;
 }

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

@@ -3,7 +3,7 @@ import { isErrorPageId } from '../error-page.js';
 import { assert, assertUsage, hasProp, slice } from './utils.js';
 import { deduceRouteStringFromFilesystemPath } from './deduceRouteStringFromFilesystemPath.js';
 import { isCallable } from '../utils.js';
-import { getConfigDefinedAtInfo, getConfigValue, getDefinedAtString } from '../page-configs/utils.js';
+import { getConfigValue, getDefinedAtString, getHookFilePathToShowToUser } from '../page-configs/utils.js';
 import { warnDeprecatedAllowKey } from './resolveRouteFunction.js';
 async function loadPageRoutes(
 // TODO: remove all arguments and use GlobalContext instead
@@ -30,9 +30,8 @@ function getPageRoutes(filesystemRoots, pageFilesAll, pageConfigs, allPageIds) {
                 const configName = 'route';
                 const configValue = getConfigValue(pageConfig, configName);
                 if (configValue) {
-                    const definedAtInfo = getConfigDefinedAtInfo(pageConfig, configName);
                     const route = configValue.value;
-                    const definedAt = getDefinedAtString(definedAtInfo);
+                    const definedAt = getDefinedAtString(configValue);
                     if (typeof route === 'string') {
                         pageRoute = {
                             pageId,
@@ -138,10 +137,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
-            assert(definedAtInfo);
-            const hookFilePath = definedAtInfo.filePath;
+            const configValue = pageConfigGlobal.configValues.onBeforeRoute;
+            const { value: hookFn } = configValue;
+            const hookFilePath = getHookFilePathToShowToUser(configValue);
+            // TODO: use getConfigDefinedAtString()
             assertUsage(isCallable(hookFn), `The hook onBeforeRoute() defined by ${hookFilePath} should be a function.`);
             const onBeforeRouteHook = {
                 hookFilePath: hookFilePath,