vike 0.4.143 → 0.4.144-commit-e40e9b1

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

@@ -0,0 +1,54 @@
+export { assertExportsOfValueFile };
+export { assertExportsOfConfigFile };
+import { assert, assertUsage, assertWarning, isObject } from '../utils.js';
+import pc from '@brillout/picocolors';
+const EXPORTS_IGNORE = [
+    // vite-plugin-solid adds `export { $$registrations }`
+    '$$registrations',
+    // @vitejs/plugin-vue adds `export { _rerender_only }`
+    '_rerender_only'
+];
+// Tolerate `export { frontmatter }` in .mdx files
+const TOLERATE_SIDE_EXPORTS = ['.md', '.mdx'];
+function assertExportsOfValueFile(fileExports, filePathToShowToUser, configName) {
+    assertExports(fileExports, filePathToShowToUser, configName);
+}
+function assertExportsOfConfigFile(fileExports, filePathToShowToUser) {
+    assertExports(fileExports, filePathToShowToUser);
+    const exportDefault = fileExports.default;
+    assertUsage(isObject(exportDefault), `The ${pc.cyan('export default')} of ${filePathToShowToUser} should be an object (but it's ${pc.cyan(`typeof exportDefault === ${JSON.stringify(typeof exportDefault)}`)} instead)`);
+}
+function assertExports(fileExports, filePathToShowToUser, configName) {
+    const exportsAll = Object.keys(fileExports);
+    const exportsRelevant = exportsAll.filter((exportName) => !EXPORTS_IGNORE.includes(exportName));
+    const exportsInvalid = exportsRelevant.filter((e) => e !== 'default' &&
+        // !!configName => isValueFile
+        e !== configName);
+    if (exportsInvalid.length === 0) {
+        if (exportsRelevant.length === 1) {
+            return;
+        }
+        else {
+            assert(exportsRelevant.length === 0);
+            let errMsg = `${filePathToShowToUser} doesn't export any value, but it should have a ${pc.cyan('export default')}`;
+            if (configName)
+                errMsg += ` or ${pc.cyan(`export { ${configName} }`)}`;
+            assertUsage(false, errMsg);
+        }
+    }
+    else {
+        // !configName => isConfigFile
+        if (!configName) {
+            const exportsInvalidStr = exportsInvalid.join(', ');
+            assertUsage(false, `${filePathToShowToUser} replace ${pc.cyan(`export { ${exportsInvalidStr} }`)} with ${pc.cyan(`export default { ${exportsInvalidStr} }`)}`);
+        }
+        // !!configName => isValueFile
+        else {
+            if (TOLERATE_SIDE_EXPORTS.some((ext) => filePathToShowToUser.endsWith(ext)))
+                return;
+            exportsInvalid.forEach((exportInvalid) => {
+                assertWarning(false, `${filePathToShowToUser} should have only a single export: move ${pc.cyan(`export { ${exportInvalid} }`)} to +config.h.js or its own +${exportsInvalid}.js`, { onlyOnce: true });
+            });
+        }
+    }
+}

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

@@ -1,3 +1,3 @@
 export { findPageConfig };
-import type { PageConfig } from './PageConfig.js';
-declare function findPageConfig(pageConfigs: PageConfig[], pageId: string): null | PageConfig;
+import type { PageConfigRuntime } from './PageConfig.js';
+declare function findPageConfig(pageConfigs: PageConfigRuntime[], pageId: string): null | PageConfigRuntime;

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[], configName: string): null | string;

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

@@ -1,18 +1,17 @@
 export { getExportPath };
 import { assert } from '../utils.js';
-// TODO: return null instead of 'export default'
-//  - Also return null insead of 'export *'?
-function getExportPath(fileExportPath) {
-    let prefix = '';
-    let suffix = '';
+function getExportPath(fileExportPath, configName) {
+    if (!fileExportPath)
+        return null;
     let [exportName, ...exportObjectPath] = fileExportPath;
     if (!exportName)
         return null;
-    if (exportName === '*') {
-        assert(exportObjectPath.length === 0);
-        return 'export *';
-    }
-    else if (exportName === 'default') {
+    if (exportObjectPath.length === 0 && ['*', 'default', configName].includes(exportName))
+        return null;
+    assert(exportName !== '*');
+    let prefix = '';
+    let suffix = '';
+    if (exportName === 'default') {
         prefix = 'export default';
     }
     else {

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

@@ -0,0 +1,3 @@
+export { loadConfigValues };
+import type { PageConfigRuntime, PageConfigRuntimeLoaded } from './PageConfig.js';
+declare function loadConfigValues(pageConfig: PageConfigRuntime, isDev: boolean): Promise<PageConfigRuntimeLoaded>;

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

@@ -0,0 +1,15 @@
+export { loadConfigValues };
+import { objectAssign } from '../utils.js';
+import { parseConfigValuesImported } from './serialize/parseConfigValuesImported.js';
+async function loadConfigValues(pageConfig, isDev) {
+    if ('isLoaded' in pageConfig &&
+        // We don't need to cache in dev, since Vite already caches the virtual module
+        !isDev) {
+        return pageConfig;
+    }
+    const configValuesImported = await pageConfig.loadConfigValuesAll();
+    const configValuesAddendum = parseConfigValuesImported(configValuesImported);
+    Object.assign(pageConfig.configValues, configValuesAddendum);
+    objectAssign(pageConfig, { isLoaded: true });
+    return pageConfig;
+}

package/dist/esm/shared/page-configs/serialize/PageConfigSerialized.d.ts

@@ -0,0 +1,32 @@
+export type { PageConfigRuntimeSerialized };
+export type { PageConfigGlobalRuntimeSerialized };
+export type { ConfigValueSerialized };
+export type { ConfigValueImported };
+import type { DefinedAt, PageConfigRuntime } from '../PageConfig.js';
+/** page config data structure serialized in virtual files: parsing it results in PageConfigRuntime */
+type PageConfigRuntimeSerialized = Omit<PageConfigRuntime, 'configValues'> & {
+    /** Config values that are loaded eagerly and serializable such as config.passToClient */
+    configValuesSerialized: Record<string, ConfigValueSerialized>;
+    /** Config values imported eagerly such as config.route */
+    configValuesImported: ConfigValueImported[];
+};
+type PageConfigGlobalRuntimeSerialized = {
+    configValuesImported: ConfigValueImported[];
+};
+/** Value is serialized. */
+type ConfigValueSerialized = {
+    valueSerialized: string;
+    definedAt: DefinedAt;
+};
+/** Value is imported. */
+type ConfigValueImported = {
+    configName: string;
+    importPath: string;
+} & ({
+    isValueFile: true;
+    exportValues: Record<string, unknown>;
+} | {
+    isValueFile: false;
+    exportName: string;
+    exportValue: unknown;
+});

package/dist/esm/shared/page-configs/serialize/PageConfigSerialized.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/shared/page-configs/serialize/assertPageConfigs.d.ts

@@ -0,0 +1,5 @@
+export { assertPageConfigsSerialized };
+export { assertPageConfigGlobalSerialized };
+import type { PageConfigGlobalRuntimeSerialized, PageConfigRuntimeSerialized } from './PageConfigSerialized.js';
+declare function assertPageConfigsSerialized(pageConfigsSerialized: unknown): asserts pageConfigsSerialized is PageConfigRuntimeSerialized[];
+declare function assertPageConfigGlobalSerialized(pageConfigGlobalSerialized: unknown): asserts pageConfigGlobalSerialized is PageConfigGlobalRuntimeSerialized;

package/dist/esm/shared/page-configs/serialize/assertPageConfigs.js

@@ -0,0 +1,16 @@
+export { assertPageConfigsSerialized };
+export { assertPageConfigGlobalSerialized };
+import { assert, isObject, hasProp } from '../../utils.js';
+function assertPageConfigsSerialized(pageConfigsSerialized) {
+    assert(Array.isArray(pageConfigsSerialized));
+    pageConfigsSerialized.forEach((pageConfigSerialized) => {
+        assert(isObject(pageConfigSerialized));
+        assert(hasProp(pageConfigSerialized, 'pageId', 'string'));
+        assert(hasProp(pageConfigSerialized, 'routeFilesystem'));
+        assert(hasProp(pageConfigSerialized, 'configValuesSerialized'));
+        assert(hasProp(pageConfigSerialized, 'configValuesImported'));
+    });
+}
+function assertPageConfigGlobalSerialized(pageConfigGlobalSerialized) {
+    assert(hasProp(pageConfigGlobalSerialized, 'configValuesImported'));
+}

package/dist/esm/shared/page-configs/serialize/parseConfigValuesImported.d.ts

@@ -0,0 +1,4 @@
+export { parseConfigValuesImported };
+import type { ConfigValues } from '../PageConfig.js';
+import type { ConfigValueImported } from './PageConfigSerialized.js';
+declare function parseConfigValuesImported(configValuesImported: ConfigValueImported[]): ConfigValues;

package/dist/esm/shared/page-configs/serialize/parseConfigValuesImported.js

@@ -0,0 +1,50 @@
+export { parseConfigValuesImported };
+import { assert, assertUsage } from '../../utils.js';
+import { assertExportsOfValueFile } from '../assertExports.js';
+import pc from '@brillout/picocolors';
+function parseConfigValuesImported(configValuesImported) {
+    const configValues = {};
+    const addConfigValue = (configName, value, importPath, exportName) => {
+        configValues[configName] = {
+            value,
+            definedAt: {
+                file: {
+                    // importPath cannot be relative to the current file, since the current file is a virtual file
+                    filePathToShowToUser: importPath,
+                    fileExportPath: [configName, 'default'].includes(exportName)
+                        ? []
+                        : // Side-effect config
+                            [exportName]
+                }
+            }
+        };
+        assertIsNotNull(value, configName, importPath);
+    };
+    configValuesImported.forEach((configValueLoaded) => {
+        if (configValueLoaded.isValueFile) {
+            const { exportValues, importPath, configName } = configValueLoaded;
+            if (configName !== 'client') {
+                assertExportsOfValueFile(exportValues, importPath, configName);
+            }
+            Object.entries(exportValues).forEach(([exportName, exportValue]) => {
+                const isSideExport = exportName !== 'default'; // .md files may have "side-exports" such as `export { frontmatter }`
+                const configName = isSideExport ? exportName : configValueLoaded.configName;
+                if (isSideExport && configName in configValues) {
+                    // We can't avoid side-export conflicts upstream. (Because we cannot know about side-exports upstream at build-time.)
+                    // Side-exports have the lowest priority.
+                    return;
+                }
+                addConfigValue(configName, exportValue, importPath, exportName);
+            });
+        }
+        else {
+            const { configName, importPath, exportValue, exportName } = configValueLoaded;
+            addConfigValue(configName, exportValue, importPath, exportName);
+        }
+    });
+    return configValues;
+}
+function assertIsNotNull(configValue, configName, importPath) {
+    assert(!importPath.includes('+config.'));
+    assertUsage(configValue !== null, `Set ${pc.cyan(configName)} to ${pc.cyan('null')} in a +config.h.js file instead of ${importPath}`);
+}

package/dist/esm/shared/page-configs/serialize/parsePageConfigs.d.ts

@@ -0,0 +1,7 @@
+export { parsePageConfigs };
+import type { PageConfigRuntime, PageConfigGlobalRuntime } from '../PageConfig.js';
+import type { PageConfigGlobalRuntimeSerialized, PageConfigRuntimeSerialized } from './PageConfigSerialized.js';
+declare function parsePageConfigs(pageConfigsSerialized: PageConfigRuntimeSerialized[], pageConfigGlobalSerialized: PageConfigGlobalRuntimeSerialized): {
+    pageConfigs: PageConfigRuntime[];
+    pageConfigGlobal: PageConfigGlobalRuntime;
+};

package/dist/esm/shared/page-configs/serialize/parsePageConfigs.js

@@ -0,0 +1,62 @@
+export { parsePageConfigs };
+import { parse } from '@brillout/json-serializer/parse';
+import { parseConfigValuesImported } from './parseConfigValuesImported.js';
+import { assert, assertUsage, isCallable } from '../../utils.js';
+import { getConfigDefinedAtString } from '../utils.js';
+function parsePageConfigs(pageConfigsSerialized, pageConfigGlobalSerialized) {
+    const pageConfigs = pageConfigsSerialized.map((pageConfigSerialized) => {
+        const configValues = {};
+        {
+            const { configValuesSerialized } = pageConfigSerialized;
+            Object.entries(configValuesSerialized).forEach(([configName, configValueSeriliazed]) => {
+                {
+                    const { valueSerialized, definedAt } = configValueSeriliazed;
+                    assert(valueSerialized);
+                    assert(!configValues[configName]);
+                    configValues[configName] = {
+                        value: parse(valueSerialized),
+                        definedAt
+                    };
+                }
+            });
+        }
+        {
+            const { configValuesImported } = pageConfigSerialized;
+            const configValuesAddendum = parseConfigValuesImported(configValuesImported);
+            Object.assign(configValues, configValuesAddendum);
+        }
+        const { pageId, isErrorPage, routeFilesystem, loadConfigValuesAll } = pageConfigSerialized;
+        assertRouteConfigValue(configValues);
+        return {
+            pageId,
+            isErrorPage,
+            routeFilesystem,
+            configValues,
+            loadConfigValuesAll
+        };
+    });
+    const pageConfigGlobal = { configValues: {} };
+    {
+        const configValuesAddendum = parseConfigValuesImported(pageConfigGlobalSerialized.configValuesImported);
+        Object.assign(pageConfigGlobal.configValues, configValuesAddendum);
+    }
+    return { pageConfigs, pageConfigGlobal };
+}
+function assertRouteConfigValue(configValues) {
+    const configName = 'route';
+    const configValue = configValues[configName];
+    if (!configValue)
+        return;
+    const { value } = configValue;
+    const configValueType = typeof value;
+    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
+    * - When using Server Routing, client-side validation is superfluous as Route Strings only need to be validated on the server-side
+   if (typeof configValue === 'string') {
+     assertRouteString(configValue, `${configElement.configDefinedAt} defines an`)
+   }
+   */
+}

package/dist/esm/shared/page-configs/serialize/serializeConfigValue.d.ts

@@ -0,0 +1,8 @@
+export { serializeConfigValue };
+export { serializeConfigValueImported };
+import { ConfigValueSource } from '../PageConfig.js';
+import { ConfigValueSerialized } from './PageConfigSerialized.js';
+declare function serializeConfigValue(lines: string[], configName: string, configValueSerialized: ConfigValueSerialized): void;
+declare function serializeConfigValueImported(configValueSource: ConfigValueSource, configName: string, whitespace: string, varCounterContainer: {
+    varCounter: number;
+}, importStatements: string[]): string[];

package/dist/esm/shared/page-configs/serialize/serializeConfigValue.js

@@ -0,0 +1,52 @@
+export { serializeConfigValue };
+export { serializeConfigValueImported };
+// This file is never loaded on the client-side but we save it under the vike/shared/ directory in order to collocate it with:
+//   - vike/shared/page-configs/serialize/parsePageConfigs.ts
+//   - vike/shared/page-configs/serialize/parseConfigValuesImported.ts
+// Both parsePageConfigs() parseConfigValuesImported() and are loaded on the client-side and server-side
+import { assertIsNotProductionRuntime } from '../../../utils/assertIsNotProductionRuntime.js';
+assertIsNotProductionRuntime();
+import path from 'path';
+import { assert, assertPosixPath } from '../../utils.js';
+import { generateEagerImport } from '../../../node/plugin/plugins/importUserCode/generateEagerImport.js';
+function serializeConfigValue(lines, configName, configValueSerialized) {
+    let whitespace = '      ';
+    lines.push(`${whitespace}['${configName}']: {`);
+    whitespace += '  ';
+    Object.entries(configValueSerialized).forEach(([key, val]) => {
+        const valSerialized = key === 'definedAt' ? JSON.stringify(val) : val;
+        lines.push(`${whitespace}  ${key}: ${valSerialized},`);
+    });
+    whitespace = whitespace.slice(2);
+    lines.push(`${whitespace}},`);
+}
+function serializeConfigValueImported(configValueSource, configName, whitespace, varCounterContainer, importStatements) {
+    assert(!configValueSource.valueIsFilePath);
+    assert(whitespace.replaceAll(' ', '').length === 0);
+    const { valueIsImportedAtRuntime, definedAtInfo } = configValueSource;
+    assert(valueIsImportedAtRuntime);
+    const { filePathRelativeToUserRootDir, importPathAbsolute, exportName } = definedAtInfo;
+    const importPath = filePathRelativeToUserRootDir ?? importPathAbsolute;
+    assertPosixPath(importPath);
+    const fileName = path.posix.basename(importPath);
+    const isValueFile = fileName.startsWith('+');
+    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: '${importPath}',`);
+    lines.push(`    isValueFile: ${JSON.stringify(isValueFile)},`);
+    if (isValueFile) {
+        lines.push(`    exportValues: ${importName},`);
+    }
+    else {
+        lines.push(`    exportValue: ${importName},`);
+        assert(exportName);
+        lines.push(`    exportName: ${JSON.stringify(exportName)},`);
+    }
+    lines.push(`  },`);
+    return lines;
+}

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

@@ -1,28 +1,35 @@
 export { getConfigValue };
 export { getPageConfig };
 export { getConfigDefinedAtString };
-export { getConfigDefinedAtInfo };
 export { getDefinedAtString };
-import type { DefinedAtInfo, PageConfig, PageConfigCommon } 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: PageConfig[]): PageConfig;
-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;
+declare function getPageConfig(pageId: string, pageConfigs: PageConfigRuntime[]): PageConfigRuntime;
+type ConfigDefinedAtUppercase<ConfigName extends string> = `Config ${ConfigName} defined ${'internally' | `at ${string}`}`;
+type ConfigDefinedAtLowercase<ConfigName extends string> = `config ${ConfigName} defined ${'internally' | `at ${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, configName: string): 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,56 @@ 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, configName)}`;
     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, configName) {
+    if (definedAt.isComputed) {
+        return 'internally';
     }
-    if (append) {
-        definedAt = `${definedAt} > (${pc.blue(append)})`;
+    let files;
+    if (definedAt.isCumulative) {
+        files = definedAt.files;
     }
-    return definedAt;
+    else {
+        files = [definedAt.file];
+    }
+    assert(files.length >= 1);
+    const sourceString = files
+        .map((source) => {
+        const { filePathToShowToUser, fileExportPath } = source;
+        let s = filePathToShowToUser;
+        const exportPath = getExportPath(fileExportPath, configName);
+        if (exportPath) {
+            s = `${s} > ${pc.cyan(exportPath)}`;
+        }
+        if (definedAt.isEffect) {
+            s = `${s} > (${pc.blue('effect')})`;
+        }
+        return s;
+    })
+        .join(' / ');
+    return `at ${sourceString}`;
+}
+function getDefinedAtString(configValue, configName) {
+    let sourceString = getSourceString(configValue.definedAt, configName);
+    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 { filePathToShowToUser } = definedAt.file;
+    assert(filePathToShowToUser);
+    return filePathToShowToUser;
+}
+function getHookFilePathToShowToUser({ definedAt }) {
+    const filePathToShowToUser = getConfigValueFilePathToShowToUser({ definedAt });
+    assert(filePathToShowToUser);
+    return filePathToShowToUser;
 }

package/dist/esm/shared/route/executeGuardHook.d.ts

@@ -1,8 +1,8 @@
 export { executeGuardHook };
 import type { PageContextExports, PageFile } from '../getPageFiles.js';
-import type { PageConfig } from '../page-configs/PageConfig.js';
+import type { PageConfigRuntime } from '../page-configs/PageConfig.js';
 declare function executeGuardHook<T extends PageContextExports & {
     _pageId: string;
     _pageFilesAll: PageFile[];
-    _pageConfigs: PageConfig[];
+    _pageConfigs: PageConfigRuntime[];
 }>(pageContext: T, prepareForUserConsumption: (pageConfig: T) => T | void): Promise<void>;

package/dist/esm/shared/route/index.d.ts

@@ -4,12 +4,12 @@ import type { PageFile } from '../getPageFiles.js';
 import { PageContextUrlComputedPropsInternal, PageContextUrlSources } from '../addUrlComputedProps.js';
 import { type OnBeforeRouteHook } from './executeOnBeforeRouteHook.js';
 import type { PageRoutes, RouteType } from './loadPageRoutes.js';
-import type { PageConfig, PageConfigGlobal } from '../page-configs/PageConfig.js';
+import type { PageConfigRuntime, PageConfigGlobalRuntime } from '../page-configs/PageConfig.js';
 type PageContextForRoute = PageContextUrlComputedPropsInternal & {
     _pageFilesAll: PageFile[];
-    _pageConfigs: PageConfig[];
+    _pageConfigs: PageConfigRuntime[];
     _allPageIds: string[];
-    _pageConfigGlobal: PageConfigGlobal;
+    _pageConfigGlobal: PageConfigGlobalRuntime;
     _pageRoutes: PageRoutes;
     _onBeforeRouteHook: OnBeforeRouteHook | null;
 } & PageContextUrlSources;

package/dist/esm/shared/route/loadPageRoutes.d.ts

@@ -3,7 +3,7 @@ export type { PageRoutes };
 export type { RouteType };
 import type { PageFile } from '../getPageFiles.js';
 import type { OnBeforeRouteHook } from './executeOnBeforeRouteHook.js';
-import type { PageConfig, PageConfigGlobal } from '../page-configs/PageConfig.js';
+import type { PageConfigRuntime, PageConfigGlobalRuntime } from '../page-configs/PageConfig.js';
 type PageRoute = {
     pageId: string;
     comesFromV1PageConfig: boolean;
@@ -23,7 +23,7 @@ type PageRoute = {
 });
 type PageRoutes = PageRoute[];
 type RouteType = 'STRING' | 'FUNCTION' | 'FILESYSTEM';
-declare function loadPageRoutes(pageFilesAll: PageFile[], pageConfigs: PageConfig[], pageConfigGlobal: PageConfigGlobal, allPageIds: string[]): Promise<{
+declare function loadPageRoutes(pageFilesAll: PageFile[], pageConfigs: PageConfigRuntime[], pageConfigGlobal: PageConfigGlobalRuntime, allPageIds: string[]): Promise<{
     pageRoutes: PageRoutes;
     onBeforeRouteHook: null | OnBeforeRouteHook;
 }>;