vike 0.4.144-commit-756f5d7 → 0.4.144-commit-6aef8a6

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/shared/page-configs/PageConfig.d.ts

@@ -14,6 +14,8 @@ export type { ConfigValuesComputed };
 export type { DefinedAt };
 export type { DefinedAtFile };
 export type { DefinedAtFileInfo };
+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;
@@ -55,51 +57,79 @@ type ConfigValueSource = {
     value?: unknown;
     configEnv: ConfigEnvInternal;
     definedAtInfo: DefinedAtFileInfo;
-    /** Wether the config value is loaded at run-time, for example config.Page or config.onBeforeRender */
+    /** 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 & {
+    fileExportName?: string;
+    fileExportPathToShowToUser: null | 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;
     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/loadConfigValues.js

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

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

@@ -3,9 +3,9 @@ export type { PageConfigGlobalRuntimeSerialized };
 export type { ConfigValueSerialized };
 export type { ConfigValueImported };
 import type { DefinedAt, PageConfigRuntime } from '../PageConfig.js';
-/** page config data structure serialized in virtual files: parsing it results in PageConfigRuntime */
+/** Page config data structure serialized in virtual files: parsing it results in PageConfigRuntime */
 type PageConfigRuntimeSerialized = Omit<PageConfigRuntime, 'configValues'> & {
-    /** Config values that are loaded eagerly and serializable such as config.passToClient */
+    /** Config values that are serializable and loaded eagerly such as config.passToClient */
     configValuesSerialized: Record<string, ConfigValueSerialized>;
     /** Config values imported eagerly such as config.route */
     configValuesImported: ConfigValueImported[];
@@ -13,12 +13,12 @@ type PageConfigRuntimeSerialized = Omit<PageConfigRuntime, 'configValues'> & {
 type PageConfigGlobalRuntimeSerialized = {
     configValuesImported: ConfigValueImported[];
 };
-/** Value is serialized. */
+/** Value is serialized */
 type ConfigValueSerialized = {
     valueSerialized: string;
     definedAt: DefinedAt;
 };
-/** Value is imported. */
+/** Value is imported */
 type ConfigValueImported = {
     configName: string;
     importPath: string;

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

@@ -11,7 +11,7 @@ function parseConfigValuesImported(configValuesImported) {
                 file: {
                     // importPath cannot be relative to the current file, since the current file is a virtual file
                     filePathToShowToUser: importPath,
-                    fileExportPath: [configName, 'default'].includes(exportName)
+                    fileExportPathToShowToUser: [configName, 'default'].includes(exportName)
                         ? []
                         : // Side-effect config
                             [exportName]

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

@@ -25,27 +25,26 @@ function serializeConfigValueImported(configValueSource, configName, whitespace,
     assert(whitespace.replaceAll(' ', '').length === 0);
     const { valueIsImportedAtRuntime, definedAtInfo } = configValueSource;
     assert(valueIsImportedAtRuntime);
-    const { filePathRelativeToUserRootDir, importPathAbsolute, exportName } = definedAtInfo;
-    const importPath = filePathRelativeToUserRootDir ?? importPathAbsolute;
-    assertPosixPath(importPath);
-    const fileName = path.posix.basename(importPath);
+    const { filePathAbsoluteVite, fileExportName } = definedAtInfo;
+    assertPosixPath(filePathAbsoluteVite);
+    const fileName = path.posix.basename(filePathAbsoluteVite);
     const isValueFile = fileName.startsWith('+');
     if (isValueFile)
-        assert(exportName === undefined);
-    const { importName, importStatement } = generateEagerImport(importPath, varCounterContainer.varCounter++, exportName);
+        assert(fileExportName === undefined);
+    const { importName, importStatement } = generateEagerImport(filePathAbsoluteVite, varCounterContainer.varCounter++, fileExportName);
     importStatements.push(importStatement);
     const lines = [];
     lines.push(`  {`);
     lines.push(`    configName: '${configName}',`);
-    lines.push(`    importPath: '${importPath}',`);
+    lines.push(`    importPath: '${filePathAbsoluteVite}',`);
     lines.push(`    isValueFile: ${JSON.stringify(isValueFile)},`);
     if (isValueFile) {
         lines.push(`    exportValues: ${importName},`);
     }
     else {
         lines.push(`    exportValue: ${importName},`);
-        assert(exportName);
-        lines.push(`    exportName: ${JSON.stringify(exportName)},`);
+        assert(fileExportName);
+        lines.push(`    exportName: ${JSON.stringify(fileExportName)},`);
     }
     lines.push(`  },`);
     return lines;

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

@@ -22,11 +22,11 @@ type ConfigDefinedAtUppercase<ConfigName extends string> = `Config ${ConfigName}
 type ConfigDefinedAtLowercase<ConfigName extends string> = `config ${ConfigName} defined ${'internally' | `at ${string}`}`;
 declare function getConfigDefinedAtString<ConfigName extends string>(configName: ConfigName, { definedAt }: {
     definedAt: DefinedAt;
-}, sentenceBegin: true, append?: 'effect'): ConfigDefinedAtUppercase<ConfigName>;
+}, sentenceBegin: true): ConfigDefinedAtUppercase<ConfigName>;
 declare function getConfigDefinedAtString<ConfigName extends string>(configName: ConfigName, { definedAt }: {
     definedAt: DefinedAt;
-}, sentenceBegin: false, append?: 'effect'): ConfigDefinedAtLowercase<ConfigName>;
-declare function getDefinedAtString(configValue: ConfigValue, configName: string): string;
+}, sentenceBegin: false): ConfigDefinedAtLowercase<ConfigName>;
+declare function getDefinedAtString(definedAt: DefinedAt, configName: string): string;
 declare function getConfigValueFilePathToShowToUser({ definedAt }: {
     definedAt: DefinedAt;
 }): null | string;

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

@@ -43,10 +43,12 @@ function getPageConfig(pageId, pageConfigs) {
     return pageConfig;
 }
 function getConfigDefinedAtString(configName, { definedAt }, sentenceBegin) {
-    const configDefinedAt = `${sentenceBegin ? `Config` : `config`} ${pc.cyan(configName)} defined ${getSourceString(definedAt, configName)}`;
+    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 getSourceString(definedAt, configName) {
+function getDefinedAtString(definedAt, configName) {
     if (definedAt.isComputed) {
         return 'internally';
     }
@@ -58,27 +60,18 @@ function getSourceString(definedAt, configName) {
         files = [definedAt.file];
     }
     assert(files.length >= 1);
-    const sourceString = files
+    const definedAtString = files
         .map((source) => {
-        const { filePathToShowToUser, fileExportPath } = source;
+        const { filePathToShowToUser, fileExportPathToShowToUser } = source;
         let s = filePathToShowToUser;
-        const exportPath = getExportPath(fileExportPath, configName);
+        const exportPath = getExportPath(fileExportPathToShowToUser, configName);
         if (exportPath) {
             s = `${s} > ${pc.cyan(exportPath)}`;
         }
-        if (definedAt.isEffect) {
-            s = `${s} > (${pc.blue('effect')})`;
-        }
         return s;
     })
         .join(' / ');
-    return `at ${sourceString}`;
-}
-function getDefinedAtString(configValue, configName) {
-    let sourceString = getSourceString(configValue.definedAt, configName);
-    if (sourceString.startsWith('at '))
-        sourceString = sourceString.slice('at '.length);
-    return sourceString;
+    return definedAtString;
 }
 function getConfigValueFilePathToShowToUser({ definedAt }) {
     // A unique file path only exists if the config value isn't cumulative nor computed:

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

@@ -41,7 +41,7 @@ function redirect(url, statusCode) {
 function render(value, abortReason) {
     const args = [typeof value === 'number' ? String(value) : JSON.stringify(value)];
     if (abortReason !== undefined)
-        args.push(truncateString(JSON.stringify(abortReason), 30, null));
+        args.push(truncateString(JSON.stringify(abortReason), 30));
     const abortCaller = 'throw render()';
     const abortCall = `throw render(${args.join(', ')})`;
     return render_(value, abortReason, abortCall, abortCaller);

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

@@ -31,7 +31,7 @@ function getPageRoutes(filesystemRoots, pageFilesAll, pageConfigs, allPageIds) {
                 const configValue = getConfigValue(pageConfig, configName);
                 if (configValue) {
                     const route = configValue.value;
-                    const definedAt = getDefinedAtString(configValue, configName);
+                    const definedAt = getDefinedAtString(configValue.definedAt, configName);
                     if (typeof route === 'string') {
                         pageRoute = {
                             pageId,

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-756f5d7";
+    projectVersion: "0.4.144-commit-6aef8a6";
     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-756f5d7';
+const PROJECT_VERSION = '0.4.144-commit-6aef8a6';
 const projectInfo = {
     projectName: 'Vike',
     projectVersion: PROJECT_VERSION,

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

@@ -1 +1,2 @@
-export declare function truncateString(str: string, lenMax: number, dim: null | ((ellipsis: string) => string)): string;
+export { truncateString };
+declare function truncateString(str: string, lenMax: number): string;

package/dist/esm/utils/truncateString.js

@@ -1,14 +1,17 @@
-export function truncateString(str, lenMax, dim) {
+export { truncateString };
+import pc from '@brillout/picocolors';
+import { assert } from './assert.js';
+function truncateString(str, lenMax) {
+    const lenMaxReal = lenMax - 3;
+    assert(lenMaxReal >= 1); // Show at least one character before the ellipsis
     if (str.length < lenMax) {
         return str;
     }
     else {
-        // May break ANSI codes
-        //  - So far, the str we pass to truncateString(str) are expected to not contain any ANSI code
-        str = str.substring(0, lenMax - 3);
-        let ellipsis = '...';
-        if (dim)
-            ellipsis = dim(ellipsis);
+        // Breaks ANSI codes.
+        //  - So far, the `str` we pass to truncateString(str) is always expected to not contain any ANSI code
+        str = str.substring(0, lenMaxReal);
+        const ellipsis = pc.dim('...');
         str = str + ellipsis;
         return str;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.144-commit-756f5d7",
+  "version": "0.4.144-commit-6aef8a6",
   "scripts": {
     "dev": "tsc --watch",
     "build": "rimraf dist/ && pnpm run build:esm && pnpm run build:cjs",

package/dist/cjs/node/plugin/plugins/importUserCode/v1-design/getFilePathToShowToUser.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getFilePathToShowToUser = void 0;
-const utils_js_1 = require("../../../utils.js");
-/*
-const f: FilePath = 1 as any
-if (f.filePathRelativeToUserRootDir === null) {
-  f.importPathAbsolute
-}
-//*/
-function getFilePathToShowToUser(filePath) {
-    const filePathToShowToUser = filePath.filePathRelativeToUserRootDir ?? filePath.filePathAbsoluteFilesystem;
-    (0, utils_js_1.assert)(filePathToShowToUser);
-    return filePathToShowToUser;
-}
-exports.getFilePathToShowToUser = getFilePathToShowToUser;

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

@@ -1,24 +0,0 @@
-export { getFilePathToShowToUser };
-export type { FilePath };
-type FilePath = {
-    /** The file's path relative to the filesystem root.
-     *
-     * Example: `/home/rom/code/my-app/pages/some-page/Page.js`
-     */
-    filePathAbsoluteFilesystem: string;
-} & ({
-    /** The file's path relative to the Vite's root (i.e. the user's project root directory).
-     *
-     * Example: `/pages/some-page/Page.js`
-     */
-    filePathRelativeToUserRootDir: string;
-    importPathAbsolute: null;
-} | {
-    filePathRelativeToUserRootDir: null;
-    /** The file's absolute import path.
-     *
-     * Example: `vike-react/config`
-     */
-    importPathAbsolute: string;
-});
-declare function getFilePathToShowToUser(filePath: FilePath): string;

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

@@ -1,13 +0,0 @@
-export { getFilePathToShowToUser };
-import { assert } from '../../../utils.js';
-/*
-const f: FilePath = 1 as any
-if (f.filePathRelativeToUserRootDir === null) {
-  f.importPathAbsolute
-}
-//*/
-function getFilePathToShowToUser(filePath) {
-    const filePathToShowToUser = filePath.filePathRelativeToUserRootDir ?? filePath.filePathAbsoluteFilesystem;
-    assert(filePathToShowToUser);
-    return filePathToShowToUser;
-}