vike 0.4.144-commit-756f5d7 → 0.4.144-commit-f7ab002

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

@@ -4,7 +4,7 @@ import { getVirtualFileIdPageConfigValuesAll, isVirtualFileIdPageConfigValuesAll
 import { getVikeConfig } from './getVikeConfig.js';
 import { extractAssetsAddQuery } from '../../../../shared/extractAssetsQuery.js';
 import { debug } from './debug.js';
-import { getConfigValue } from '../../../../../shared/page-configs/utils.js';
+import { getConfigValue } from '../../../../../shared/page-configs/helpers.js';
 import { getConfigValueSourcesRelevant } from '../../../shared/getConfigValueSourcesRelevant.js';
 import { isRuntimeEnvMatch } from './isRuntimeEnvMatch.js';
 import { serializeConfigValueImported } from '../../../../../shared/page-configs/serialize/serializeConfigValue.js';

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

@@ -1,14 +1,14 @@
 export { getVirtualFilePageConfigs };
 export { getConfigValueSerialized };
-import { assert, assertUsage, getPropAccessNotation, hasProp, objectEntries } from '../../../utils.js';
+import { assert, assertUsage, getPropAccessNotation, objectEntries } from '../../../utils.js';
 import { getVirtualFileIdPageConfigValuesAll } from '../../../../shared/virtual-files/virtualFilePageConfigValuesAll.js';
 import { debug } from './debug.js';
-import { stringify } from '@brillout/json-serializer/stringify';
+import { isJsonSerializerError, stringify } from '@brillout/json-serializer/stringify';
 import { getConfigEnv } from './helpers.js';
 import pc from '@brillout/picocolors';
 import { getVikeConfig } from './getVikeConfig.js';
 import { isRuntimeEnvMatch } from './isRuntimeEnvMatch.js';
-import { getConfigValueFilePathToShowToUser } from '../../../../../shared/page-configs/utils.js';
+import { getConfigValueFilePathToShowToUser } from '../../../../../shared/page-configs/helpers.js';
 import { serializeConfigValue, serializeConfigValueImported } from '../../../../../shared/page-configs/serialize/serializeConfigValue.js';
 async function getVirtualFilePageConfigs(userRootDir, outDirRoot, isForClientSide, isDev, id, configVike, isClientRouting) {
     const { pageConfigs, pageConfigGlobal } = await getVikeConfig(userRootDir, outDirRoot, isDev, configVike.extensions, true);
@@ -105,15 +105,23 @@ function getConfigValueSerialized(value, configName, definedAt) {
     const valueName = `config${getPropAccessNotation(configName)}`;
     let configValueSerialized;
     try {
-        configValueSerialized = stringify(value, { valueName });
+        configValueSerialized = stringify(value, { valueName, forbidReactElements: true });
     }
     catch (err) {
-        assert(hasProp(err, 'messageCore', 'string'));
+        let serializationErrMsg = '';
+        if (isJsonSerializerError(err)) {
+            serializationErrMsg = err.messageCore;
+        }
+        else {
+            console.error('Serialization error:');
+            console.error(err);
+            serializationErrMsg = 'see serialization error printed above';
+        }
         const configValueFilePathToShowToUser = getConfigValueFilePathToShowToUser({ definedAt });
         assert(configValueFilePathToShowToUser);
         assertUsage(false, [
             `The value of the config ${pc.cyan(configName)} cannot be defined inside the file ${configValueFilePathToShowToUser}:`,
-            `its value must be defined in an another file and then imported by ${configValueFilePathToShowToUser}. (Because the value isn't serializable: ${err.messageCore}.)`,
+            `its value must be defined in an another file and then imported by ${configValueFilePathToShowToUser}. (Because its value isn't serializable: ${serializationErrMsg}.)`,
             `Only serializable config values can be defined inside +config.h.js files, see https://vike.dev/header-file.`
         ].join(' '));
     }

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

@@ -6,20 +6,7 @@ function getConfigEnv(configValueSources, configName) {
     const configValueSource = getConfigValueSource(configValueSources, configName);
     if (!configValueSource)
         return null;
-    if (configValueSource) {
-        return configValueSource.configEnv;
-    }
-    else {
-        // In case of effect/computed config values, there isn't any configValueSource
-        // TODO: make it work for custom config definitions
-        //  - Ideally set configValueSource also for effect/computed config values?
-        assert(false, 'TODO');
-        /*
-        const configDef = configDefinitionsBuiltIn[configName as keyof typeof configDefinitionsBuiltIn]
-        if (!configDef) return null
-        return configDef.env
-        */
-    }
+    return configValueSource.configEnv;
 }
 function isConfigSet(configValueSources, configName) {
     const configValueSource = getConfigValueSource(configValueSources, configName);

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

@@ -3,8 +3,8 @@ export { getConfigBuildErrorFormatted };
 export { getConfigExecutionErrorIntroMsg as getConfigExecutionErrorIntroMsg };
 export { isTmpFile };
 import 'source-map-support/register.js';
-import { type FilePath } from './getFilePathToShowToUser.js';
-declare function transpileAndExecuteFile(filePath: FilePath, isValueFile: boolean, userRootDir: string): Promise<{
+import type { FilePathResolved } from '../../../../../shared/page-configs/PageConfig.js';
+declare function transpileAndExecuteFile(filePath: FilePathResolved, isValueFile: boolean, userRootDir: string): Promise<{
     fileExports: Record<string, unknown>;
 }>;
 declare function getConfigBuildErrorFormatted(err: unknown): null | string;

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

@@ -11,7 +11,6 @@ import { assertPosixPath, getRandomId, assertIsNotProductionRuntime, assert, uni
 import { isImportData, replaceImportStatements } from './replaceImportStatements.js';
 import { vikeConfigDependencies } from './getVikeConfig.js';
 import 'source-map-support/register.js';
-import { getFilePathToShowToUser } from './getFilePathToShowToUser.js';
 import { assertExportsOfConfigFile } from '../../../../../shared/page-configs/assertExports.js';
 assertIsNotProductionRuntime();
 async function transpileAndExecuteFile(filePath, isValueFile, userRootDir) {
@@ -36,14 +35,13 @@ async function transpileFile(filePath, isValueFile, userRootDir) {
 }
 function transpileImports(codeOriginal, filePath, isValueFile) {
     // Do we need to remove the imports?
-    const { filePathAbsoluteFilesystem } = filePath;
+    const { filePathAbsoluteFilesystem, filePathToShowToUser } = filePath;
     assertPosixPath(filePathAbsoluteFilesystem);
     const isHeader = isHeaderFile(filePathAbsoluteFilesystem);
     const isPageConfigFile = !isValueFile;
     if (!isHeader && !isPageConfigFile) {
         return null;
     }
-    const filePathToShowToUser = getFilePathToShowToUser(filePath);
     assertWarning(isPageConfigFile, `${filePathToShowToUser} is a JavaScript header file (.h.js), but JavaScript header files should only be used for +config.h.js, see https://vike.dev/header-file`, { onlyOnce: true });
     // Remove the imports
     const res = replaceImportStatements(codeOriginal, filePathToShowToUser);
@@ -273,7 +271,7 @@ function triggerPrepareStackTrace(err) {
 function getErrIntroMsg(operation, filePath) {
     const msg = [
         pc.red(`Failed to ${operation}`),
-        pc.bold(pc.red(getFilePathToShowToUser(filePath))),
+        pc.bold(pc.red(filePath.filePathToShowToUser)),
         pc.red(`because:`)
     ].join(' ');
     return msg;

package/dist/esm/node/plugin/plugins/previewConfig.js

@@ -26,9 +26,13 @@ function previewConfig() {
             markEnvAsPreview();
             return () => {
                 assertDist();
-                if (!configVike.prerender) {
-                    addSsrMiddleware(server.middlewares);
+                /* We don't use this condition (we wrongfully always use the SSR middleware) because of the regression introduced by https://github.com/vitejs/vite/pull/14756 which stops servering .html files when `appType: 'custom'`.
+                if (!configVike.prerender || configVike.prerender.partial) {
+                  addSsrMiddleware(server.middlewares)
                 }
+                /*/
+                addSsrMiddleware(server.middlewares);
+                //*/
                 addStatic404Middleware(server.middlewares);
             };
         }

package/dist/esm/node/prerender/runPrerender.js

@@ -16,7 +16,7 @@ import { getConfigVike } from '../shared/getConfigVike.js';
 import { getPageFilesServerSide } from '../../shared/getPageFiles.js';
 import { getPageContextRequestUrl } from '../../shared/getPageContextRequestUrl.js';
 import { getUrlFromRouteString } from '../../shared/route/resolveRouteString.js';
-import { getConfigValue, getConfigValueFilePathToShowToUser, getHookFilePathToShowToUser } from '../../shared/page-configs/utils.js';
+import { getConfigValue, getConfigValueFilePathToShowToUser, getHookFilePathToShowToUser } from '../../shared/page-configs/helpers.js';
 import { loadConfigValues } from '../../shared/page-configs/loadConfigValues.js';
 import { isErrorPage } from '../../shared/error-page.js';
 import { addUrlComputedProps } from '../../shared/addUrlComputedProps.js';
@@ -285,7 +285,7 @@ async function callOnPrerenderStartHook(prerenderContext, renderContext) {
         const configValue = pageConfigGlobal.configValues.onPrerenderStart;
         if (configValue?.value) {
             const { value: hookFn } = configValue;
-            // config.onPrerenderStart isn't a computed nor a cumulative config => definedAtInfo should always be defined
+            // config.onPrerenderStart isn't a computed nor a cumulative config => definedAt should always be defined
             const hookFilePath = getHookFilePathToShowToUser(configValue);
             assert(hookFilePath);
             onPrerenderStartHook = {

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/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,6 @@
 export { log404 };
-export { getPagesAndRoutesInfo };
+// Exported for ./index.spec.ts
+export { getRoutesInfo };
 import { getGlobalContext } from '../../globalContext.js';
 import { assert, assertUsage, assertInfo, compareString, stripAnsi, getTerminalWidth, truncateString } from '../../utils.js';
 import pc from '@brillout/picocolors';
@@ -13,14 +14,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)} doesn't match the route of any of your pages`;
+        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 +75,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 +127,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

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,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,52 +56,72 @@ type ConfigEnvInternal = ConfigEnv | '_routing-eager' | '_routing-lazy';
 type ConfigValueSource = {
     value?: unknown;
     configEnv: ConfigEnvInternal;
-    definedAtInfo: DefinedAtFileInfo;
-    /** Wether the config value is loaded at run-time, for example config.Page or config.onBeforeRender */
+    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;
+type ConfigValues = Record<string, ConfigValue>;
+type FilePathResolved = FilePath & {
     filePathAbsoluteFilesystem: string;
-    importPathAbsolute: null;
-} | {
-    filePathRelativeToUserRootDir: null;
+};
+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;
+    /** 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;