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

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

@@ -28,29 +28,28 @@ exports.serializeConfigValue = serializeConfigValue;
 function serializeConfigValueImported(configValueSource, configName, whitespace, varCounterContainer, importStatements) {
     (0, utils_js_1.assert)(!configValueSource.valueIsFilePath);
     (0, utils_js_1.assert)(whitespace.replaceAll(' ', '').length === 0);
-    const { valueIsImportedAtRuntime, definedAtInfo } = configValueSource;
+    const { valueIsImportedAtRuntime, definedAt } = configValueSource;
     (0, utils_js_1.assert)(valueIsImportedAtRuntime);
-    const { filePathRelativeToUserRootDir, importPathAbsolute, exportName } = definedAtInfo;
-    const importPath = filePathRelativeToUserRootDir ?? importPathAbsolute;
-    (0, utils_js_1.assertPosixPath)(importPath);
-    const fileName = path_1.default.posix.basename(importPath);
+    const { filePathAbsoluteVite, fileExportName } = definedAt;
+    (0, utils_js_1.assertPosixPath)(filePathAbsoluteVite);
+    const fileName = path_1.default.posix.basename(filePathAbsoluteVite);
     const isValueFile = fileName.startsWith('+');
     if (isValueFile)
-        (0, utils_js_1.assert)(exportName === undefined);
-    const { importName, importStatement } = (0, generateEagerImport_js_1.generateEagerImport)(importPath, varCounterContainer.varCounter++, exportName);
+        (0, utils_js_1.assert)(fileExportName === undefined);
+    const { importName, importStatement } = (0, generateEagerImport_js_1.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},`);
-        (0, utils_js_1.assert)(exportName);
-        lines.push(`    exportName: ${JSON.stringify(exportName)},`);
+        (0, utils_js_1.assert)(fileExportName);
+        lines.push(`    exportName: ${JSON.stringify(fileExportName)},`);
     }
     lines.push(`  },`);
     return lines;

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

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

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

@@ -5,10 +5,10 @@ const error_page_js_1 = require("../error-page.js");
 const utils_js_1 = require("./utils.js");
 const deduceRouteStringFromFilesystemPath_js_1 = require("./deduceRouteStringFromFilesystemPath.js");
 const utils_js_2 = require("../utils.js");
-const utils_js_3 = require("../page-configs/utils.js");
+const helpers_js_1 = require("../page-configs/helpers.js");
 const resolveRouteFunction_js_1 = require("./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);
@@ -31,10 +31,10 @@ function getPageRoutes(filesystemRoots, pageFilesAll, pageConfigs, allPageIds) {
             let pageRoute = null;
             {
                 const configName = 'route';
-                const configValue = (0, utils_js_3.getConfigValue)(pageConfig, configName);
+                const configValue = (0, helpers_js_1.getConfigValue)(pageConfig, configName);
                 if (configValue) {
                     const route = configValue.value;
-                    const definedAt = (0, utils_js_3.getDefinedAtString)(configValue, configName);
+                    const definedAt = (0, helpers_js_1.getDefinedAtString)(configValue.definedAt, configName);
                     if (typeof route === 'string') {
                         pageRoute = {
                             pageId,
@@ -46,7 +46,7 @@ function getPageRoutes(filesystemRoots, pageFilesAll, pageConfigs, allPageIds) {
                     }
                     else {
                         (0, utils_js_1.assert)((0, utils_js_2.isCallable)(route));
-                        if ((0, utils_js_3.getConfigValue)(pageConfig, 'iKnowThePerformanceRisksOfAsyncRouteFunctions', 'boolean'))
+                        if ((0, helpers_js_1.getConfigValue)(pageConfig, 'iKnowThePerformanceRisksOfAsyncRouteFunctions', 'boolean'))
                             (0, resolveRouteFunction_js_1.warnDeprecatedAllowKey)();
                         pageRoute = {
                             pageId,
@@ -139,12 +139,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 = (0, utils_js_3.getHookFilePathToShowToUser)(configValue);
-            // TODO: use getConfigDefinedAtString()
-            (0, utils_js_1.assertUsage)((0, utils_js_2.isCallable)(hookFn), `The hook onBeforeRoute() defined by ${hookFilePath} should be a function.`);
+            const hookFilePath = (0, helpers_js_1.getHookFilePathToShowToUser)(configValue);
+            const hookDefinedAt = (0, helpers_js_1.getConfigDefinedAtString)('Hook', hookName, configValue);
+            (0, utils_js_1.assertUsage)((0, utils_js_2.isCallable)(hookFn), `${hookDefinedAt} should be a function.`);
             const onBeforeRouteHook = {
                 hookFilePath: hookFilePath,
                 onBeforeRoute: hookFn

package/dist/cjs/utils/projectInfo.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.projectInfo = void 0;
 const assertSingleInstance_js_1 = require("./assertSingleInstance.js");
-const PROJECT_VERSION = '0.4.144-commit-756f5d7';
+const PROJECT_VERSION = '0.4.144-commit-f7ab002';
 const projectInfo = {
     projectName: 'Vike',
     projectVersion: PROJECT_VERSION,

package/dist/cjs/utils/truncateString.js

@@ -1,17 +1,22 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.truncateString = void 0;
-function truncateString(str, lenMax, dim) {
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+const assert_js_1 = require("./assert.js");
+function truncateString(str, lenMax) {
+    const lenMaxReal = lenMax - 3;
+    (0, assert_js_1.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 = picocolors_1.default.dim('...');
         str = str + ellipsis;
         return str;
     }

package/dist/esm/client/client-routing-runtime/getPageContext.js

@@ -14,7 +14,7 @@ import { preparePageContextForUserConsumptionClientSide } from '../shared/prepar
 import { loadPageFilesClientSide } from '../shared/loadPageFilesClientSide.js';
 import { removeBuiltInOverrides } from './getPageContext/removeBuiltInOverrides.js';
 import { getPageContextRequestUrl } from '../../shared/getPageContextRequestUrl.js';
-import { getConfigValue, getPageConfig } from '../../shared/page-configs/utils.js';
+import { getConfigValue, getPageConfig } from '../../shared/page-configs/helpers.js';
 import { assertOnBeforeRenderHookReturn } from '../../shared/assertOnBeforeRenderHookReturn.js';
 import { executeGuardHook } from '../../shared/route/executeGuardHook.js';
 import { AbortRender, isAbortPageContext } from '../../shared/route/abort.js';

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

@@ -4,7 +4,7 @@ export { analyzeClientEntries };
 import { assert, resolveOutDir, isObject, viteIsSSR, getFilePathAbsolute, addOnBeforeLogHook, removeFileExtention, unique, assertPosixPath, assertUsage, getOutDirs } from '../utils.js';
 import { virtualFileIdImportUserCodeServer } from '../../shared/virtual-files/virtualFileImportUserCode.js';
 import { getVikeConfig } from './importUserCode/v1-design/getVikeConfig.js';
-import { getConfigValue } from '../../../shared/page-configs/utils.js';
+import { getConfigValue } from '../../../shared/page-configs/helpers.js';
 import { findPageFiles } from '../shared/findPageFiles.js';
 import { getConfigVike } from '../../shared/getConfigVike.js';
 import { getVirtualFileIdPageConfigValuesAll } from '../../shared/virtual-files/virtualFilePageConfigValuesAll.js';

package/dist/esm/node/plugin/plugins/devConfig/determineOptimizeDeps.js

@@ -34,18 +34,18 @@ async function getPageDeps(config, pageConfigs, isDev) {
             configValueSourcesRelevant.forEach((configValueSource) => {
                 if (!configValueSource.valueIsImportedAtRuntime)
                     return;
-                const { definedAtInfo, configEnv } = configValueSource;
+                const { definedAt, configEnv } = configValueSource;
                 if (configEnv !== 'client-only' && configEnv !== 'server-and-client')
                     return;
-                if (definedAtInfo.filePathRelativeToUserRootDir !== null) {
-                    const { filePathAbsoluteFilesystem } = definedAtInfo;
+                if (definedAt.filePathRelativeToUserRootDir !== null) {
+                    const { filePathAbsoluteFilesystem } = definedAt;
                     assert(filePathAbsoluteFilesystem);
                     // Surprisingly Vite expects entries to be absolute paths
                     entries.push(filePathAbsoluteFilesystem);
                 }
                 else {
-                    // Adding definedAtInfo.filePathAbsoluteFilesystem doesn't work for npm packages, I guess because of Vite's config.server.fs.allow
-                    const { importPathAbsolute } = definedAtInfo;
+                    // Adding definedAt.filePathAbsoluteFilesystem doesn't work for npm packages, I guess because of Vite's config.server.fs.allow
+                    const { importPathAbsolute } = definedAt;
                     assert(importPathAbsolute);
                     // We need to differentiate between npm package imports and path aliases.
                     // There are path aliases that cannot be distinguished from npm package names.

package/dist/esm/node/plugin/plugins/importBuild/index.js

@@ -26,15 +26,15 @@ function importBuild() {
     ];
 }
 function getImporterCode(config, pageFilesEntry) {
-    const importPathAbsolute = toPosixPath(
+    const filePathAbsolute = toPosixPath(
     // [RELATIVE_PATH_FROM_DIST] Current file: node_modules/vike/dist/esm/node/plugin/plugins/importBuild/index.js
     require_.resolve(`../../../../../../dist/esm/node/runtime/globalContext/loadImportBuild.js`));
     const { outDirServer } = getOutDirs(config);
-    const importPath = path.posix.relative(outDirServer, importPathAbsolute);
+    const filePathRelative = path.posix.relative(outDirServer, filePathAbsolute);
     // The only reason we went for using CJS require() instead of ESM import() is because import() doesn't support .json files
     const importerCode = [
         '(async () => {',
-        `  const { setImportBuildGetters } = await import('${importPath}');`,
+        `  const { setImportBuildGetters } = await import('${filePathRelative}');`,
         '  setImportBuildGetters({',
         `    pageFiles: () => import('./${pageFilesEntry}'),`,
         "    clientManifest: () => require('../assets.json'),",

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

@@ -4,7 +4,7 @@ export type { ConfigDefinition };
 export type { ConfigDefinitionInternal };
 export type { ConfigNameGlobal };
 export type { ConfigEffect };
-import type { ConfigEnvInternal, ConfigEnv, ConfigValueSources } from '../../../../../../shared/page-configs/PageConfig.js';
+import type { ConfigEnvInternal, ConfigEnv, ConfigValueSources, DefinedAtFileFullInfo } from '../../../../../../shared/page-configs/PageConfig.js';
 import type { Config, ConfigNameBuiltIn } from '../../../../../../shared/page-configs/Config.js';
 /** The meta definition of a config.
  *
@@ -46,6 +46,7 @@ type ConfigEffect = (config: {
 type ConfigDefinitionInternal = Omit<ConfigDefinition, 'env'> & {
     _computed?: (configValueSources: ConfigValueSources) => unknown;
     _valueIsFilePath?: true;
+    _userEffectDefinedAt?: DefinedAtFileFullInfo;
     env: ConfigEnvInternal;
 };
 type ConfigDefinitionsBuiltIn = Record<ConfigNameBuiltIn, ConfigDefinitionInternal>;

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

@@ -48,16 +48,17 @@ const configDefinitionsBuiltIn = {
         _valueIsFilePath: true
     },
     clientRouting: {
-        env: 'server-and-client' // TODO: config-only instead?
+        // We could make it 'server-only' (we don't yet because of some legacy V0.4 design code)
+        env: 'server-and-client'
     },
     prerender: {
         env: 'server-only'
     },
     hydrationCanBeAborted: {
-        env: 'client-only' // TODO: config-only instead?
+        env: 'client-only'
     },
     prefetchStaticAssets: {
-        env: 'client-only' // TODO: config-only instead?
+        env: 'client-only'
     },
     extends: {
         env: 'config-only'

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

@@ -11,7 +11,7 @@ export { getLogicalPath };
  * getLocationId('/pages/some-page') => '/pages/some-page'
  * getLocationId('/renderer/+config.js') => '/renderer'
  */
-declare function getLocationId(somePath: string): string;
+declare function getLocationId(filePathAbsoluteVite: string): string;
 /** Get URL determined by filesystem path */
 declare function getFilesystemRouteString(locationId: string): string;
 /**

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

@@ -13,8 +13,8 @@ import { assert, assertPosixPath, getNpmPackageImportPath, isNpmPackageImport, h
  * getLocationId('/pages/some-page') => '/pages/some-page'
  * getLocationId('/renderer/+config.js') => '/renderer'
  */
-function getLocationId(somePath) {
-    const locationId = removeFilename(somePath, true);
+function getLocationId(filePathAbsoluteVite) {
+    const locationId = removeFilename(filePathAbsoluteVite, true);
     assertLocationId(locationId);
     return locationId;
 }
@@ -110,21 +110,21 @@ function removeDirectories(somePath, removeDirs) {
         somePath = '/';
     return somePath;
 }
-function removeFilename(filePath, optional) {
-    assertPosixPath(filePath);
-    assert(filePath.startsWith('/') || isNpmPackageImport(filePath));
+function removeFilename(filePathAbsoluteVite, optional) {
+    assertPosixPath(filePathAbsoluteVite);
+    assert(filePathAbsoluteVite.startsWith('/') || isNpmPackageImport(filePathAbsoluteVite));
     {
-        const filename = filePath.split('/').slice(-1)[0];
+        const filename = filePathAbsoluteVite.split('/').slice(-1)[0];
         if (!filename.includes('.')) {
             assert(optional);
-            return filePath;
+            return filePathAbsoluteVite;
         }
     }
-    filePath = filePath.split('/').slice(0, -1).join('/');
-    if (filePath === '')
-        filePath = '/';
-    assertLocationId(filePath);
-    return filePath;
+    let locationId = filePathAbsoluteVite.split('/').slice(0, -1).join('/');
+    if (locationId === '')
+        locationId = '/';
+    assertLocationId(locationId);
+    return locationId;
 }
 function getFilesystemRouteDefinedBy(locationId) {
     if (locationId === '/')