vike 0.4.144-commit-6aef8a6 → 0.4.144-commit-f7ab002

package/dist/esm/node/runtime/html/serializePageContextClientSide.js

@@ -1,6 +1,6 @@
 export { serializePageContextClientSide };
 export { serializePageContextAbort };
-import { stringify } from '@brillout/json-serializer/stringify';
+import { stringify, isJsonSerializerError } from '@brillout/json-serializer/stringify';
 import { assert, assertWarning, hasProp, unique } from '../utils.js';
 import { isErrorPage } from '../../../shared/error-page.js';
 import { addIs404ToPageProps } from '../../../shared/addIs404ToPageProps.js';
@@ -46,19 +46,32 @@ function serializePageContextClientSide(pageContext) {
             catch (err) {
                 hasWarned = true;
                 propsNonSerializable.push(prop);
-                assert(hasProp(err, 'messageCore', 'string'));
-                assertWarning(false, [
+                let msg = [
                     `${varName} cannot be serialized and, therefore, cannot be passed to the client.`,
-                    `Make sure that ${varName} is serializable, or remove ${h(propName)} from ${h('passToClient')}.`,
-                    `Serialization error: ${err.messageCore}.`
-                ].join(' '), { onlyOnce: false });
+                    `Make sure that ${varName} is serializable, or remove ${h(propName)} from ${h('passToClient')}.`
+                ].join(' ');
+                if (isJsonSerializerError(err)) {
+                    msg = `${msg} Serialization error: ${err.messageCore}.`;
+                }
+                else {
+                    console.warn('Serialization error:');
+                    console.warn(err);
+                    msg = `${msg} The serialization failed because of the error printed above.`;
+                }
+                // We warn (instead of throwing an error) since Vike's client runtime throws an error (with `assertUsage()`) if the user's client code tries to access the property that cannot be serialized
+                assertWarning(false, msg, { onlyOnce: false });
             }
         });
         assert(hasWarned);
         propsNonSerializable.forEach((prop) => {
             pageContextClient[prop] = notSerializable;
         });
-        pageContextSerialized = serialize(pageContextClient);
+        try {
+            pageContextSerialized = serialize(pageContextClient);
+        }
+        catch (err) {
+            assert(false);
+        }
     }
     return pageContextSerialized;
 }

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

@@ -20,7 +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';
+import { getConfigValueFilePathToShowToUser } from '../../../shared/page-configs/helpers.js';
 async function renderPageAlreadyRouted(pageContext) {
     // pageContext._pageId can either be the:
     //  - ID of the page matching the routing, or the

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

@@ -1,5 +1,5 @@
 export { getClientEntryFilePath };
-import { getConfigValue } from '../../shared/page-configs/utils.js';
+import { getConfigValue } from '../../shared/page-configs/helpers.js';
 function getClientEntryFilePath(pageConfig) {
     const configName = 'client';
     const configValue = getConfigValue(pageConfig, configName, 'string');

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

@@ -1,5 +1,5 @@
 export { analyzeClientSide };
-import { getConfigValue } from '../page-configs/utils.js';
+import { getConfigValue } from '../page-configs/helpers.js';
 import { analyzePageClientSide } from './analyzePageClientSide.js';
 function analyzeClientSide(pageConfig, pageFilesAll, pageId) {
     // V1 design
@@ -9,9 +9,7 @@ function analyzeClientSide(pageConfig, pageFilesAll, pageId) {
         return { isClientSideRenderable, isClientRouting };
     }
     else {
-        // TODO/v1-release:
-        //  - remove V0.4 implementation
-        //  - globally rename isHtmlOnly to !isClientSideRenderable
+        // TODO/v1-release: remove
         // V0.4 design
         const { isHtmlOnly, isClientRouting } = analyzePageClientSide(pageFilesAll, pageId);
         return { isClientSideRenderable: !isHtmlOnly, isClientRouting };

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, getConfigValueFilePathToShowToUser } from '../page-configs/utils.js';
+import { getConfigDefinedAtString, getConfigValueFilePathToShowToUser } from '../page-configs/helpers.js';
 import pc from '@brillout/picocolors';
 function getExports(pageFiles, pageConfig) {
     const configEntries = {};
@@ -31,7 +31,7 @@ function getExports(pageFiles, pageConfig) {
         Object.entries(pageConfig.configValues).forEach(([configName, configValue]) => {
             const { value } = configValue;
             const configValueFilePathToShowToUser = getConfigValueFilePathToShowToUser(configValue);
-            const configDefinedAt = getConfigDefinedAtString(configName, configValue, true);
+            const configDefinedAt = getConfigDefinedAtString('Config', configName, configValue);
             config[configName] = config[configName] ?? value;
             configEntries[configName] = configEntries[configName] ?? [];
             // Currently each configName has only one entry. Adding an entry for each overriden config value isn't implemented yet. (This is an isomorphic file and it isn't clear whether this can/should be implemented on the client-side. We should load a minimum amount of code on the client-side.)

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

@@ -23,6 +23,6 @@ function assertHook(pageContext, hookName) {
 function assertHookFn(hookFn, { hookName, hookFilePath }) {
     assert(hookName && hookFilePath);
     assert(!hookName.endsWith(')'));
-    assertUsage(isCallable(hookFn), `hook ${hookName}() defined by ${hookFilePath} should be a function`);
+    assertUsage(isCallable(hookFn), `Hook ${hookName}() defined by ${hookFilePath} should be a function`);
     checkType(hookFn);
 }

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

@@ -13,7 +13,7 @@ export type { ConfigValueComputed };
 export type { ConfigValuesComputed };
 export type { DefinedAt };
 export type { DefinedAtFile };
-export type { DefinedAtFileInfo };
+export type { DefinedAtFileFullInfo };
 export type { FilePathResolved };
 export type { FilePath };
 import type { ConfigValueImported } from './serialize/PageConfigSerialized.js';
@@ -56,15 +56,14 @@ type ConfigEnvInternal = ConfigEnv | '_routing-eager' | '_routing-lazy';
 type ConfigValueSource = {
     value?: unknown;
     configEnv: ConfigEnvInternal;
-    definedAtInfo: DefinedAtFileInfo;
+    definedAt: DefinedAtFileFullInfo;
     /** Wether the config value is loaded at runtime, for example config.Page or config.onBeforeRender */
     valueIsImportedAtRuntime: boolean;
     /** Whether the config value is a file path, for example config.client */
     valueIsFilePath?: true;
 };
-type DefinedAtFileInfo = FilePath & {
+type DefinedAtFileFullInfo = DefinedAtFile & FilePath & {
     fileExportName?: string;
-    fileExportPathToShowToUser: null | string[];
 };
 type ConfigValueSources = Record<string, ConfigValueSource[]>;
 type ConfigValueComputed = {
@@ -76,17 +75,10 @@ type ConfigValue = {
     value: unknown;
     definedAt: DefinedAt;
 };
-type DefinedAt = {
-    file: DefinedAtFile;
-    isComputed?: undefined;
-    isCumulative?: undefined;
-} | {
-    isCumulative: true;
+type DefinedAt = DefinedAtFile | {
     files: DefinedAtFile[];
-    isComputed?: undefined;
 } | {
     isComputed: true;
-    isCumulative?: undefined;
 };
 type DefinedAtFile = {
     filePathToShowToUser: string;

package/dist/esm/shared/page-configs/helpers/getConfigDefinedAtString.d.ts

@@ -0,0 +1,7 @@
+export { getConfigDefinedAtString };
+export { getDefinedAtString };
+import type { DefinedAt } from '../PageConfig.js';
+declare function getConfigDefinedAtString<ConfigName extends string, SentenceBegin extends 'Config' | 'config' | 'Hook'>(sentenceBegin: SentenceBegin, configName: ConfigName, { definedAt }: {
+    definedAt: DefinedAt;
+}): `${SentenceBegin} ${ConfigName}${string} defined ${'internally' | `at ${string}`}`;
+declare function getDefinedAtString(definedAt: DefinedAt, configName: string): string;

package/dist/esm/shared/page-configs/helpers/getConfigDefinedAtString.js

@@ -0,0 +1,37 @@
+export { getConfigDefinedAtString };
+export { getDefinedAtString };
+import { assert } from '../../utils.js';
+import pc from '@brillout/picocolors';
+import { getExportPath } from '../getExportPath.js';
+function getConfigDefinedAtString(sentenceBegin, configName, { definedAt }) {
+    const definedAtString = getDefinedAtString(definedAt, configName);
+    const definedAtStr = definedAtString === 'internally' ? definedAtString : `at ${definedAtString}`;
+    let configNameStr = `${configName}${sentenceBegin === 'Hook' ? '()' : ''}`;
+    const configDefinedAt = `${sentenceBegin} ${pc.cyan(configNameStr)} defined ${definedAtStr}`;
+    return configDefinedAt;
+}
+function getDefinedAtString(definedAt, configName) {
+    if ('isComputed' in definedAt) {
+        return 'internally';
+    }
+    let files;
+    if ('files' in definedAt) {
+        files = definedAt.files;
+    }
+    else {
+        files = [definedAt];
+    }
+    assert(files.length >= 1);
+    const definedAtString = files
+        .map((source) => {
+        const { filePathToShowToUser, fileExportPathToShowToUser } = source;
+        let s = filePathToShowToUser;
+        const exportPath = getExportPath(fileExportPathToShowToUser, configName);
+        if (exportPath) {
+            s = `${s} > ${pc.cyan(exportPath)}`;
+        }
+        return s;
+    })
+        .join(' / ');
+    return definedAtString;
+}

package/dist/esm/shared/page-configs/helpers/getConfigValue.d.ts

@@ -0,0 +1,14 @@
+export { getConfigValue };
+import type { PageConfigRuntime, PageConfigBuildTime, ConfigValue } 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 | ConfigValue & {
+    value: string;
+};
+declare function getConfigValue(pageConfig: PageConfigCommon, configName: ConfigName, type: 'boolean'): null | ConfigValue & {
+    value: boolean;
+};
+declare function getConfigValue(pageConfig: PageConfigCommon, configName: ConfigName): null | ConfigValue & {
+    value: unknown;
+};

package/dist/esm/shared/page-configs/helpers/getConfigValue.js

@@ -0,0 +1,38 @@
+export { getConfigValue };
+import { assert, assertUsage, getValuePrintable } from '../../utils.js';
+import pc from '@brillout/picocolors';
+import { getConfigDefinedAtString } from './getConfigDefinedAtString.js';
+// prettier-ignore
+function getConfigValue(pageConfig, configName, type) {
+    const configValue = getConfigValueEntry(pageConfig, configName);
+    if (configValue === null)
+        return null;
+    const { value, definedAt } = configValue;
+    if (type)
+        assertConfigValueType(value, type, configName, definedAt);
+    return configValue;
+}
+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('Config', configName, {
+        definedAt
+    });
+    const errMsg = `${configDefinedAt} has an invalid ${problem}: it should be a ${pc.cyan(type)} instead`;
+    assertUsage(false, errMsg);
+}
+function getConfigValueEntry(pageConfig, configName) {
+    const configValue = pageConfig.configValues[configName];
+    if (!configValue)
+        return null;
+    // Enable users to suppress global config values by setting the local config value to null
+    if (configValue.value === null)
+        return null;
+    return configValue;
+}

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

@@ -0,0 +1,13 @@
+export { getPageConfig };
+export { getConfigValueFilePathToShowToUser };
+export { getHookFilePathToShowToUser };
+export { getConfigDefinedAtString, getDefinedAtString } from './helpers/getConfigDefinedAtString.js';
+export { getConfigValue } from './helpers/getConfigValue.js';
+import type { PageConfigRuntime, DefinedAt } from './PageConfig.js';
+declare function getPageConfig(pageId: string, pageConfigs: PageConfigRuntime[]): PageConfigRuntime;
+declare function getConfigValueFilePathToShowToUser({ definedAt }: {
+    definedAt: DefinedAt;
+}): null | string;
+declare function getHookFilePathToShowToUser({ definedAt }: {
+    definedAt: DefinedAt;
+}): string;

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

@@ -0,0 +1,27 @@
+export { getPageConfig };
+export { getConfigValueFilePathToShowToUser };
+export { getHookFilePathToShowToUser };
+export { getConfigDefinedAtString, getDefinedAtString } from './helpers/getConfigDefinedAtString.js';
+export { getConfigValue } from './helpers/getConfigValue.js';
+import { assert } from '../utils.js';
+function getPageConfig(pageId, pageConfigs) {
+    const pageConfig = pageConfigs.find((p) => p.pageId === pageId);
+    assert(pageConfigs.length > 0);
+    assert(pageConfig);
+    return pageConfig;
+}
+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 ('isComputed' in definedAt || 'files' in definedAt)
+        return null;
+    const { filePathToShowToUser } = definedAt;
+    assert(filePathToShowToUser);
+    return filePathToShowToUser;
+}
+function getHookFilePathToShowToUser({ definedAt }) {
+    const filePathToShowToUser = getConfigValueFilePathToShowToUser({ definedAt });
+    assert(filePathToShowToUser);
+    return filePathToShowToUser;
+}

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

@@ -8,14 +8,12 @@ function parseConfigValuesImported(configValuesImported) {
         configValues[configName] = {
             value,
             definedAt: {
-                file: {
-                    // importPath cannot be relative to the current file, since the current file is a virtual file
-                    filePathToShowToUser: importPath,
-                    fileExportPathToShowToUser: [configName, 'default'].includes(exportName)
-                        ? []
-                        : // Side-effect config
-                            [exportName]
-                }
+                // importPath cannot be relative to the current file, since the current file is a virtual file
+                filePathToShowToUser: importPath,
+                fileExportPathToShowToUser: [configName, 'default'].includes(exportName)
+                    ? []
+                    : // Side-effect config
+                        [exportName]
             }
         };
         assertIsNotNull(value, configName, importPath);

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

@@ -2,7 +2,7 @@ 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';
+import { getConfigDefinedAtString } from '../helpers.js';
 function parsePageConfigs(pageConfigsSerialized, pageConfigGlobalSerialized) {
     const pageConfigs = pageConfigsSerialized.map((pageConfigSerialized) => {
         const configValues = {};
@@ -49,7 +49,7 @@ function assertRouteConfigValue(configValues) {
         return;
     const { value } = configValue;
     const configValueType = typeof value;
-    const configDefinedAt = getConfigDefinedAtString(configName, configValue, true);
+    const configDefinedAt = getConfigDefinedAtString('Config', configName, configValue);
     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.

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

@@ -23,9 +23,9 @@ function serializeConfigValue(lines, configName, configValueSerialized) {
 function serializeConfigValueImported(configValueSource, configName, whitespace, varCounterContainer, importStatements) {
     assert(!configValueSource.valueIsFilePath);
     assert(whitespace.replaceAll(' ', '').length === 0);
-    const { valueIsImportedAtRuntime, definedAtInfo } = configValueSource;
+    const { valueIsImportedAtRuntime, definedAt } = configValueSource;
     assert(valueIsImportedAtRuntime);
-    const { filePathAbsoluteVite, fileExportName } = definedAtInfo;
+    const { filePathAbsoluteVite, fileExportName } = definedAt;
     assertPosixPath(filePathAbsoluteVite);
     const fileName = path.posix.basename(filePathAbsoluteVite);
     const isValueFile = fileName.startsWith('+');

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

@@ -3,10 +3,10 @@ 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 { getConfigValue, getDefinedAtString, getHookFilePathToShowToUser } from '../page-configs/utils.js';
+import { getConfigDefinedAtString, getConfigValue, getDefinedAtString, getHookFilePathToShowToUser } from '../page-configs/helpers.js';
 import { warnDeprecatedAllowKey } from './resolveRouteFunction.js';
 async function loadPageRoutes(
-// TODO: remove all arguments and use GlobalContext instead
+// Remove all arguments and use GlobalContext instead?
 pageFilesAll, pageConfigs, pageConfigGlobal, allPageIds) {
     await Promise.all(pageFilesAll.filter((p) => p.fileType === '.page.route').map((p) => p.loadFile?.()));
     const { onBeforeRouteHook, filesystemRoots } = getGlobalHooks(pageFilesAll, pageConfigs, pageConfigGlobal);
@@ -136,12 +136,13 @@ function getPageRoutes(filesystemRoots, pageFilesAll, pageConfigs, allPageIds) {
 function getGlobalHooks(pageFilesAll, pageConfigs, pageConfigGlobal) {
     // V1 Design
     if (pageConfigs.length > 0) {
-        if (pageConfigGlobal.configValues.onBeforeRoute?.value) {
-            const configValue = pageConfigGlobal.configValues.onBeforeRoute;
+        const hookName = 'onBeforeRoute';
+        if (pageConfigGlobal.configValues[hookName]?.value) {
+            const configValue = pageConfigGlobal.configValues[hookName];
             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 hookDefinedAt = getConfigDefinedAtString('Hook', hookName, configValue);
+            assertUsage(isCallable(hookFn), `${hookDefinedAt} should be a function.`);
             const onBeforeRouteHook = {
                 hookFilePath: hookFilePath,
                 onBeforeRoute: hookFn

package/dist/esm/utils/projectInfo.d.ts

@@ -5,7 +5,7 @@ type ProjectVersion = typeof projectInfo.projectVersion;
 type ProjectTag = `[${PackageName}]` | `[${PackageName}@${ProjectVersion}]`;
 declare const projectInfo: {
     projectName: "Vike";
-    projectVersion: "0.4.144-commit-6aef8a6";
+    projectVersion: "0.4.144-commit-f7ab002";
     npmPackageName: "vike";
     githubRepository: "https://github.com/vikejs/vike";
 };

package/dist/esm/utils/projectInfo.js

@@ -1,6 +1,6 @@
 export { projectInfo };
 import { onProjectInfo } from './assertSingleInstance.js';
-const PROJECT_VERSION = '0.4.144-commit-6aef8a6';
+const PROJECT_VERSION = '0.4.144-commit-f7ab002';
 const projectInfo = {
     projectName: 'Vike',
     projectVersion: PROJECT_VERSION,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.144-commit-6aef8a6",
+  "version": "0.4.144-commit-f7ab002",
   "scripts": {
     "dev": "tsc --watch",
     "build": "rimraf dist/ && pnpm run build:esm && pnpm run build:cjs",
@@ -13,7 +13,7 @@
   },
   "dependencies": {
     "@brillout/import": "0.2.3",
-    "@brillout/json-serializer": "^0.5.6",
+    "@brillout/json-serializer": "^0.5.8",
     "@brillout/picocolors": "^1.0.9",
     "@brillout/require-shim": "^0.1.2",
     "@brillout/vite-plugin-import-build": "^0.2.20",

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

@@ -1,96 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-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");
-// prettier-ignore
-function getConfigValue(pageConfig, configName, type) {
-    const configValue = getConfigValueEntry(pageConfig, configName);
-    if (configValue === null)
-        return null;
-    const { value, definedAt } = configValue;
-    if (type)
-        assertConfigValueType(value, type, configName, definedAt);
-    return configValue;
-}
-exports.getConfigValue = getConfigValue;
-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`);
-}
-function getConfigValueEntry(pageConfig, configName) {
-    const configValue = pageConfig.configValues[configName];
-    if (!configValue)
-        return null;
-    // Enable users to suppress global config values by setting the local config value to null
-    if (configValue.value === null)
-        return null;
-    return configValue;
-}
-function getPageConfig(pageId, pageConfigs) {
-    const pageConfig = pageConfigs.find((p) => p.pageId === pageId);
-    (0, utils_js_1.assert)(pageConfigs.length > 0);
-    (0, utils_js_1.assert)(pageConfig);
-    return pageConfig;
-}
-exports.getPageConfig = getPageConfig;
-function getConfigDefinedAtString(configName, { definedAt }, sentenceBegin) {
-    const definedAtString = getDefinedAtString(definedAt, configName);
-    const definedAtStr = definedAtString === 'internally' ? definedAtString : `at ${definedAtString}`;
-    const configDefinedAt = `${sentenceBegin ? `Config` : `config`} ${picocolors_1.default.cyan(configName)} defined ${definedAtStr}`;
-    return configDefinedAt;
-}
-exports.getConfigDefinedAtString = getConfigDefinedAtString;
-function getDefinedAtString(definedAt, configName) {
-    if (definedAt.isComputed) {
-        return 'internally';
-    }
-    let files;
-    if (definedAt.isCumulative) {
-        files = definedAt.files;
-    }
-    else {
-        files = [definedAt.file];
-    }
-    (0, utils_js_1.assert)(files.length >= 1);
-    const definedAtString = files
-        .map((source) => {
-        const { filePathToShowToUser, fileExportPathToShowToUser } = source;
-        let s = filePathToShowToUser;
-        const exportPath = (0, getExportPath_js_1.getExportPath)(fileExportPathToShowToUser, configName);
-        if (exportPath) {
-            s = `${s} > ${picocolors_1.default.cyan(exportPath)}`;
-        }
-        return s;
-    })
-        .join(' / ');
-    return definedAtString;
-}
-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 { filePathToShowToUser } = definedAt.file;
-    (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/esm/shared/page-configs/utils.d.ts

@@ -1,35 +0,0 @@
-export { getConfigValue };
-export { getPageConfig };
-export { getConfigDefinedAtString };
-export { getDefinedAtString };
-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 | ConfigValue & {
-    value: string;
-};
-declare function getConfigValue(pageConfig: PageConfigCommon, configName: ConfigName, type: 'boolean'): null | ConfigValue & {
-    value: boolean;
-};
-declare function getConfigValue(pageConfig: PageConfigCommon, configName: ConfigName): null | ConfigValue & {
-    value: unknown;
-};
-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): ConfigDefinedAtUppercase<ConfigName>;
-declare function getConfigDefinedAtString<ConfigName extends string>(configName: ConfigName, { definedAt }: {
-    definedAt: DefinedAt;
-}, sentenceBegin: false): ConfigDefinedAtLowercase<ConfigName>;
-declare function getDefinedAtString(definedAt: DefinedAt, 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,90 +0,0 @@
-export { getConfigValue };
-export { getPageConfig };
-export { getConfigDefinedAtString };
-export { getDefinedAtString };
-export { getConfigValueFilePathToShowToUser };
-export { getHookFilePathToShowToUser };
-import { assert, assertUsage, getValuePrintable } from '../utils.js';
-import pc from '@brillout/picocolors';
-import { getExportPath } from './getExportPath.js';
-// prettier-ignore
-function getConfigValue(pageConfig, configName, type) {
-    const configValue = getConfigValueEntry(pageConfig, configName);
-    if (configValue === null)
-        return null;
-    const { value, definedAt } = configValue;
-    if (type)
-        assertConfigValueType(value, type, configName, definedAt);
-    return configValue;
-}
-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;
-    // Enable users to suppress global config values by setting the local config value to null
-    if (configValue.value === null)
-        return null;
-    return configValue;
-}
-function getPageConfig(pageId, pageConfigs) {
-    const pageConfig = pageConfigs.find((p) => p.pageId === pageId);
-    assert(pageConfigs.length > 0);
-    assert(pageConfig);
-    return pageConfig;
-}
-function getConfigDefinedAtString(configName, { definedAt }, sentenceBegin) {
-    const definedAtString = getDefinedAtString(definedAt, configName);
-    const definedAtStr = definedAtString === 'internally' ? definedAtString : `at ${definedAtString}`;
-    const configDefinedAt = `${sentenceBegin ? `Config` : `config`} ${pc.cyan(configName)} defined ${definedAtStr}`;
-    return configDefinedAt;
-}
-function getDefinedAtString(definedAt, configName) {
-    if (definedAt.isComputed) {
-        return 'internally';
-    }
-    let files;
-    if (definedAt.isCumulative) {
-        files = definedAt.files;
-    }
-    else {
-        files = [definedAt.file];
-    }
-    assert(files.length >= 1);
-    const definedAtString = files
-        .map((source) => {
-        const { filePathToShowToUser, fileExportPathToShowToUser } = source;
-        let s = filePathToShowToUser;
-        const exportPath = getExportPath(fileExportPathToShowToUser, configName);
-        if (exportPath) {
-            s = `${s} > ${pc.cyan(exportPath)}`;
-        }
-        return s;
-    })
-        .join(' / ');
-    return definedAtString;
-}
-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;
-}