vike 0.4.144 → 0.4.145-commit-2520555

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

@@ -6,7 +6,7 @@ function debugPageFiles({ pageContext, isHtmlOnly, isClientRouting, pageFilesLoa
     const padding = '   - ';
     debug('All page files:', printPageFiles(pageContext._pageFilesAll, true)); // TODO
     debug(`URL:`, pageContext.urlOriginal);
-    debug.options({ serialization: { emptyArray: 'No match' } })(`Routing:`, printRouteMatches(pageContext._routeMatches));
+    debug.options({ serialization: { emptyArray: 'No match' } })(`Routing:`, printRouteMatches(pageContext._debugRouteMatches));
     debug(`pageId:`, pageContext._pageId);
     debug('Page type:', isHtmlOnly ? 'HTML-only' : 'SSR/SPA');
     debug(`Routing type:`, !isHtmlOnly && isClientRouting ? 'Client Routing' : 'Server Routing');
@@ -16,14 +16,14 @@ function debugPageFiles({ pageContext, isHtmlOnly, isClientRouting, pageFilesLoa
     debug('Client-side entries:', clientEntries);
     debug('Client-side dependencies:', clientDependencies);
     return;
-    function printRouteMatches(routeMatches) {
-        if (routeMatches === 'ROUTE_ERROR') {
+    function printRouteMatches(debugRouteMatches) {
+        if (debugRouteMatches === 'ROUTING_ERROR') {
             return 'Routing Failed';
         }
-        if (routeMatches === 'CUSTOM_ROUTE') {
+        if (debugRouteMatches === 'CUSTOM_ROUTING') {
             return 'Custom Routing';
         }
-        return routeMatches;
+        return debugRouteMatches;
     }
     function printPageFiles(pageFiles, genericPageFilesLast = false) {
         if (pageFiles.length === 0) {

package/dist/esm/node/runtime/renderPage/loadPageFilesServerSide.d.ts

@@ -4,9 +4,9 @@ export type { PageContext_loadPageFilesServerSide };
 import { type PageFile } from '../../../shared/getPageFiles.js';
 import { PromiseType } from '../utils.js';
 import { PageContextGetPageAssets, type PageAsset } from './getPageAssets.js';
-import { type PageContextDebug } from './debugPageFiles.js';
+import { type PageContextDebugRouteMatches } from './debugPageFiles.js';
 import type { PageConfigRuntime } from '../../../shared/page-configs/PageConfig.js';
-type PageContext_loadPageFilesServerSide = PageContextGetPageAssets & PageContextDebug & {
+type PageContext_loadPageFilesServerSide = PageContextGetPageAssets & PageContextDebugRouteMatches & {
     urlOriginal: string;
     _pageFilesAll: PageFile[];
     _pageConfigs: PageConfigRuntime[];

package/dist/esm/node/runtime/renderPage/log404/index.d.ts

@@ -1,5 +1,5 @@
 export { log404 };
-export { getPagesAndRoutesInfo };
+export { getRoutesInfo };
 import type { PageRoutes } from '../../../../shared/route/index.js';
 declare function log404(pageContext: {
     urlPathname: string;
@@ -7,4 +7,4 @@ declare function log404(pageContext: {
     isClientSideNavigation: boolean;
     _pageRoutes: PageRoutes;
 }): Promise<void>;
-declare function getPagesAndRoutesInfo(pageRoutes: PageRoutes): string;
+declare function getRoutesInfo(pageRoutes: PageRoutes): string | null;

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

@@ -1,5 +1,7 @@
 export { log404 };
-export { getPagesAndRoutesInfo };
+// Exported for ./index.spec.ts
+export { getRoutesInfo };
+import { noRouteMatch } from '../../../../shared/route/noRouteMatch.js';
 import { getGlobalContext } from '../../globalContext.js';
 import { assert, assertUsage, assertInfo, compareString, stripAnsi, getTerminalWidth, truncateString } from '../../utils.js';
 import pc from '@brillout/picocolors';
@@ -13,14 +15,19 @@ async function log404(pageContext) {
     );
     const globalContext = getGlobalContext();
     if (!globalContext.isProduction && !isFileRequest(urlPathname) && !pageContext.isClientSideNavigation) {
-        assertInfo(false, [
-            `URL ${pc.cyan(urlPathname)} doesn't match the route of any of your pages:`,
-            getPagesAndRoutesInfo(pageRoutes),
-            'See https://vike.dev/routing for more information about routing.'
-        ].join('\n'), { onlyOnce: false });
+        const routesInfo = getRoutesInfo(pageRoutes);
+        let msg = `URL ${pc.cyan(urlPathname)} ${noRouteMatch}`;
+        const outro = 'See https://vike.dev/routing for more information about routing.';
+        if (!routesInfo) {
+            msg = `${msg}. ${pc.dim(outro)}`;
+        }
+        else {
+            msg = `${msg}:\n${routesInfo}\n${outro}`;
+        }
+        assertInfo(false, msg, { onlyOnce: false });
     }
 }
-function getPagesAndRoutesInfo(pageRoutes) {
+function getRoutesInfo(pageRoutes) {
     const entries = pageRoutes
         .map((pageRoute) => {
         let routeStr;
@@ -69,19 +76,24 @@ function getPagesAndRoutesInfo(pageRoutes) {
     const terminalWidth = getTerminalWidth() || 134;
     let width2 = Math.max(...linesContent.map(({ routeTypeSrc }) => stripAnsi(routeTypeSrc).length));
     let width3 = Math.max(...linesContent.map(({ routeDefinedBy }) => stripAnsi(routeDefinedBy).length));
-    let width1 = terminalWidth - width3 - width2 - 10;
+    const width1_max = terminalWidth -
+        width3 -
+        width2 -
+        // Total width of table border & padding
+        10;
+    if (width1_max < 10)
+        return null;
     linesContent.forEach((lineContent) => {
         let { routeStr } = lineContent;
-        if (lineContent.routeTypeSrc !== 'Route Function') {
-            routeStr = truncateString(routeStr, width1, (s) => pc.dim(s));
-        }
-        else {
-            routeStr = truncateRouteFunction(routeStr, width1);
+        if (lineContent.routeTypeSrc === 'Route Function') {
+            routeStr = truncateRouteFunction(routeStr, width1_max);
+            assert(stripAnsi(routeStr).length <= width1_max);
         }
-        assert(stripAnsi(routeStr).length <= width1);
         lineContent.routeStr = routeStr;
     });
-    width1 = Math.max(...linesContent.map(({ routeStr }) => stripAnsi(routeStr).length));
+    let width1 = Math.max(...linesContent.map(({ routeStr }) => stripAnsi(routeStr).length));
+    if (width1 > width1_max)
+        return null;
     let lines = linesContent.map(({ routeStr, routeTypeSrc, routeDefinedBy }, i) => {
         let cell1 = padEnd(routeStr, width1 + (stripAnsi(routeStr).length - stripAnsi(routeStr).length));
         let cell2 = padEnd(routeTypeSrc, width2);
@@ -116,7 +128,7 @@ function truncateRouteFunction(routeStr, lenMax) {
     routeStr = stripAnsi(routeStr);
     routeStr = removeNonAscii(routeStr);
     routeStr = routeStr.split(/\s/).filter(Boolean).join(' ');
-    routeStr = truncateString(routeStr, lenMax, (s) => pc.dim(s));
+    routeStr = truncateString(routeStr, lenMax);
     return routeStr;
 }
 /** Same as String.prototype.padEnd but with stripAnsi() */

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
@@ -102,7 +102,7 @@ async function prerender404Page(renderContext, pageContextInit_) {
         routeParams: {},
         // `prerender404Page()` is about generating `dist/client/404.html` for static hosts; there is no Client Routing.
         _usesClientRouter: false,
-        _routeMatches: []
+        _debugRouteMatches: []
     };
     const pageContextInit = {
         urlOriginal: '/fake-404-url',

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

@@ -240,8 +240,8 @@ async function renderPageNominal(pageContext) {
     }
     // Route
     {
-        const routeResult = await route(pageContext);
-        objectAssign(pageContext, routeResult.pageContextAddendum);
+        const pageContextFromRoute = await route(pageContext);
+        objectAssign(pageContext, pageContextFromRoute);
         objectAssign(pageContext, { is404: pageContext._pageId ? null : true });
         if (pageContext._pageId === null) {
             const errorPageId = getErrorPageId(pageContext._pageFilesAll, pageContext._pageConfigs);
@@ -268,7 +268,7 @@ async function getPageContextErrorPageInit(pageContextInit, errNominalPage, page
         routeParams: {}
     };
     objectAssign(pageContext, {
-        _routeMatches: pageContextNominalPagePartial._routeMatches || 'ROUTE_ERROR'
+        _debugRouteMatches: pageContextNominalPagePartial._debugRouteMatches || 'ROUTING_ERROR'
     });
     assert(pageContext.errorWhileRendering);
     return pageContext;

package/dist/esm/node/runtime/utils.d.ts

@@ -25,7 +25,7 @@ export * from '../../utils/capitalizeFirstLetter.js';
 export * from '../../utils/debugGlob.js';
 export * from '../../utils/isEquivalentError.js';
 export * from '../../utils/styleFileRE.js';
-export * from '../../utils/hasPropertyGetter.js';
+export * from '../../utils/isPropertyGetter.js';
 export * from '../../utils/debug.js';
 export * from '../../utils/urlToFile.js';
 export * from '../../utils/getGlobalObject.js';

package/dist/esm/node/runtime/utils.js

@@ -28,7 +28,7 @@ export * from '../../utils/capitalizeFirstLetter.js';
 export * from '../../utils/debugGlob.js';
 export * from '../../utils/isEquivalentError.js';
 export * from '../../utils/styleFileRE.js';
-export * from '../../utils/hasPropertyGetter.js';
+export * from '../../utils/isPropertyGetter.js';
 export * from '../../utils/debug.js';
 export * from '../../utils/urlToFile.js';
 export * from '../../utils/getGlobalObject.js';

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/node/shared/getConfigVike.d.ts

@@ -1,3 +1,4 @@
 export { getConfigVike };
+import { ResolvedConfig } from 'vite';
 import type { ConfigVikeResolved } from '../../shared/ConfigVike.js';
-declare function getConfigVike(config: Record<string, unknown>): Promise<ConfigVikeResolved>;
+declare function getConfigVike(config: ResolvedConfig): Promise<ConfigVikeResolved>;

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

@@ -1,5 +1,8 @@
 export { getConfigVike };
+import { assert } from './utils.js';
 async function getConfigVike(config) {
-    const configVike = (await config.configVikePromise);
+    const { configVikePromise } = config;
+    assert(configVikePromise);
+    const configVike = await configVikePromise;
     return configVike;
 }

package/dist/esm/shared/addUrlComputedProps.d.ts

@@ -55,6 +55,7 @@ type PageContextUrlComputedPropsServer = PageContextUrlComputedPropsClient & {
 declare function addUrlComputedProps<PageContext extends Record<string, unknown> & PageContextUrlSources>(pageContext: PageContext, enumerable?: boolean): asserts pageContext is PageContext & PageContextUrlComputedPropsInternal;
 type PageContextUrlSources = {
     urlOriginal: string;
+    urlLogical?: string;
     _urlRewrite: string | null;
     _baseServer: string;
     _urlHandler: null | ((url: string) => string);

package/dist/esm/shared/addUrlComputedProps.js

@@ -1,28 +1,40 @@
 // URLs props need to be computed props, because the user can modify the URL e.g. with onBeforeRoute() for i18n
 export { addUrlComputedProps };
 export { assertPageContextUrlComputedProps };
-import { assert, parseUrl, assertWarning, isPlainObject, hasPropertyGetter, isBrowser } from './utils.js';
+import { assert, parseUrl, assertWarning, isPlainObject, isPropertyGetter, isBrowser } from './utils.js';
 function addUrlComputedProps(pageContext, enumerable = true) {
     assert(pageContext.urlOriginal);
     if ('urlPathname' in pageContext) {
-        assert(hasPropertyGetter(pageContext, 'urlPathname'));
+        assert(typeof pageContext.urlPathname === 'string');
+        /* If this assert() fails then it's most likely because Object.assign() was used instead of objectAssign(), i.e.:
+           ```js
+           // Add property getters such as pageContext.urlPathname to pageContext
+           addUrlComputedProps(pageContext)
+           // ❌ Breaks the property getters of pageContext set by addUrlComputedProps() such as pageContext.urlPathname
+           Object.assign(pageContext2, pageContext)
+           // ❌ Also breaks the property getters
+           const pageContext3 = { ...pageContext }
+           // ✅ Preserves property getters of pageContext (see objectAssign() implementation)
+           objectAssign(pageContext2, pageContext)
+           ```
+        */
+        assert(isPropertyGetter(pageContext, 'urlPathname'));
     }
+    if ('urlParsed' in pageContext)
+        assert(isPropertyGetter(pageContext, 'urlParsed'));
+    // TODO/v1-release: move pageContext.urlParsed to pageContext.url
+    if ('url' in pageContext)
+        assert(isPropertyGetter(pageContext, 'url'));
     Object.defineProperty(pageContext, 'urlPathname', {
         get: urlPathnameGetter,
         enumerable,
         configurable: true
     });
-    // TODO/v1-release: move pageContext.urlParsed to pageContext.url
-    if ('url' in pageContext)
-        assert(hasPropertyGetter(pageContext, 'url'));
     Object.defineProperty(pageContext, 'url', {
         get: urlGetter,
         enumerable: false,
         configurable: true
     });
-    if ('urlParsed' in pageContext) {
-        assert(hasPropertyGetter(pageContext, 'urlParsed'));
-    }
     Object.defineProperty(pageContext, 'urlParsed', {
         get: urlParsedGetter,
         enumerable,
@@ -30,17 +42,17 @@ function addUrlComputedProps(pageContext, enumerable = true) {
     });
 }
 function getUrlParsed(pageContext) {
-    // We use a url handler function because the onBeforeRoute() hook may modify pageContext.urlOriginal (e.g. for i18n)
+    // We need a url handler function because the onBeforeRoute() hook may set pageContext.urlLogical (typically for i18n)
     let urlHandler = pageContext._urlHandler;
     if (!urlHandler) {
         urlHandler = (url) => url;
     }
-    const url = pageContext._urlRewrite ?? pageContext.urlOriginal;
-    assert(url && typeof url === 'string');
-    const urlLogical = urlHandler(url);
+    let urlResolved = pageContext._urlRewrite ?? pageContext.urlLogical ?? pageContext.urlOriginal;
+    urlResolved = urlHandler(urlResolved);
     const baseServer = pageContext._baseServer;
+    assert(urlResolved && typeof urlResolved === 'string');
     assert(baseServer.startsWith('/'));
-    return parseUrl(urlLogical, baseServer);
+    return parseUrl(urlResolved, baseServer);
 }
 function urlPathnameGetter() {
     const { pathname } = getUrlParsed(this);

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,9 @@ 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';
 type PageConfigBase = {
     pageId: string;
@@ -23,9 +25,9 @@ type PageConfigBase = {
         definedBy: string;
     };
 };
-/** Page config data structure available and used at runtime */
+/** Page config data structure available at runtime */
 type PageConfigRuntime = PageConfigBase & {
-    /** Loaded config values */
+    /** All loaded config values */
     configValues: ConfigValues;
     /** Load config values that are lazily loaded such as config.Page */
     loadConfigValuesAll: () => Promise<ConfigValueImported[]>;
@@ -33,9 +35,9 @@ type PageConfigRuntime = PageConfigBase & {
 /** Same as PageConfigRuntime but also contains all lazily loaded config values such as config.Page */
 type PageConfigRuntimeLoaded = PageConfigRuntime & {
     /** Whether loadConfigValuesAll() was called */
-    isLoaded: true;
+    isAllLoaded: true;
 };
-/** Page config data structure available and used at build-time */
+/** Page config data structure available at build-time */
 type PageConfigBuildTime = PageConfigBase & {
     configValues: ConfigValues;
     configValueSources: ConfigValueSources;
@@ -54,50 +56,72 @@ 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 DefinedAtFileFullInfo = DefinedAtFile & FilePath & {
+    fileExportName?: string;
+};
+type ConfigValueSources = Record<string, ConfigValueSource[]>;
 type ConfigValueComputed = {
     configEnv: ConfigEnvInternal;
     value: unknown;
 };
 type ConfigValuesComputed = Record<string, ConfigValueComputed>;
-type ConfigValueSources = Record<string, ConfigValueSource[]>;
 type ConfigValue = {
     value: unknown;
     definedAt: DefinedAt;
 };
-type ConfigValues = Record<string, ConfigValue>;
-type DefinedAt = {
-    file: DefinedAtFile;
-    isEffect?: true;
-    isComputed?: undefined;
-    isCumulative?: undefined;
-} | {
-    isCumulative: true;
+type DefinedAt = DefinedAtFile | {
     files: DefinedAtFile[];
-    isEffect?: undefined;
-    isComputed?: undefined;
 } | {
     isComputed: true;
-    isEffect?: undefined;
-    isCumulative?: undefined;
 };
 type DefinedAtFile = {
     filePathToShowToUser: string;
-    fileExportPath: null | string[];
+    fileExportPathToShowToUser: null | string[];
 };
-type DefinedAtFileInfo = // TODO: replace filePathRelativeToUserRootDir and importPathAbsolute with following?
-({
-    filePathRelativeToUserRootDir: string;
-    filePathAbsolute: string;
-    importPathAbsolute: null;
-} | {
+type ConfigValues = Record<string, ConfigValue>;
+type FilePathResolved = FilePath & {
+    filePathAbsoluteFilesystem: string;
+};
+type FilePath = {
+    /** The file's path, absolute from Vite's perspective.
+     *
+     * We use this to generate import paths in virtual modules. (Virtual modules cannot have relative import paths.)
+     *
+     * Its value is equivalent to `filePath.filePathRelativeToUserRootDir ?? filePath.importPathAbsolute`, for example:
+     *   - `vike-react/config`, or
+     *   - `/pages/+config.h.js`.
+     */
+    filePathAbsoluteVite: string;
+    /** The file's path, absolute from the filesystem root.
+     *
+     * Example: `/home/rom/code/my-app/pages/some-page/Page.js`
+     *
+     * The value is `null` upon aliased import paths which we cannot resolve (we'd need to re-implement https://www.npmjs.com/package/@rollup/plugin-alias).
+     */
+    filePathAbsoluteFilesystem: string | null;
+    /** The file's path, shown to user upon logging.
+     *
+     * Currently, its value is equivalent to `FilePath['filePathAbsoluteVite']`.
+     */
+    filePathToShowToUser: string;
+} & ({
     filePathRelativeToUserRootDir: null;
-    filePathAbsolute: string | null;
+    /** The file's path, as absolute import path. It's either:
+     *  - an npm package import (e.g. `vike-react/config`), or
+     *  - an alias (`#components/Counter').
+     */
     importPathAbsolute: string;
-}) & {
-    exportName?: string;
-    fileExportPath: null | string[];
-};
+} | {
+    /** The file's path, relative to Vite's root (i.e. the user project's root directory).
+     *
+     * Example: `/pages/some-page/Page.js`
+     */
+    filePathRelativeToUserRootDir: string;
+    importPathAbsolute: null | string;
+});

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

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

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

@@ -1,9 +1,9 @@
 export { getExportPath };
 import { assert } from '../utils.js';
-function getExportPath(fileExportPath, configName) {
-    if (!fileExportPath)
+function getExportPath(fileExportPathToShowToUser, configName) {
+    if (!fileExportPathToShowToUser)
         return null;
-    let [exportName, ...exportObjectPath] = fileExportPath;
+    let [exportName, ...exportObjectPath] = fileExportPathToShowToUser;
     if (!exportName)
         return null;
     if (exportObjectPath.length === 0 && ['*', 'default', configName].includes(exportName))

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;
+}