vike 0.4.144 → 0.4.145-commit-2520555

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

@@ -1,21 +1,18 @@
 export { parseConfigValuesImported };
-import { assert, assertUsage } from '../../utils.js';
+import { assert } from '../../utils.js';
 import { assertExportsOfValueFile } from '../assertExports.js';
-import pc from '@brillout/picocolors';
 function parseConfigValuesImported(configValuesImported) {
     const configValues = {};
     const addConfigValue = (configName, value, importPath, exportName) => {
         configValues[configName] = {
             value,
             definedAt: {
-                file: {
-                    // importPath cannot be relative to the current file, since the current file is a virtual file
-                    filePathToShowToUser: importPath,
-                    fileExportPath: [configName, 'default'].includes(exportName)
-                        ? []
-                        : // Side-effect config
-                            [exportName]
-                }
+                // importPath cannot be relative to the current file, since the current file is a virtual file
+                filePathToShowToUser: importPath,
+                fileExportPathToShowToUser: [configName, 'default'].includes(exportName)
+                    ? []
+                    : // Side-effect config
+                        [exportName]
             }
         };
         assertIsNotNull(value, configName, importPath);
@@ -46,5 +43,12 @@ function parseConfigValuesImported(configValuesImported) {
 }
 function assertIsNotNull(configValue, configName, importPath) {
     assert(!importPath.includes('+config.'));
-    assertUsage(configValue !== null, `Set ${pc.cyan(configName)} to ${pc.cyan('null')} in a +config.h.js file instead of ${importPath}`);
+    /* Re-use this for:
+     *  - upcoming config.requestPageContextOnNavigation
+     *  - for cumulative values in the future: we don't need this for now because, currently, cumulative values are never imported.
+    assertUsage(
+      configValue !== null,
+      `Set ${pc.cyan(configName)} to ${pc.cyan('null')} in a +config.h.js file instead of ${importPath}`
+    )
+    */
 }

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

@@ -2,7 +2,7 @@ export { parsePageConfigs };
 import { parse } from '@brillout/json-serializer/parse';
 import { parseConfigValuesImported } from './parseConfigValuesImported.js';
 import { assert, assertUsage, isCallable } from '../../utils.js';
-import { getConfigDefinedAtString } from '../utils.js';
+import { getConfigDefinedAtString } from '../helpers.js';
 function parsePageConfigs(pageConfigsSerialized, pageConfigGlobalSerialized) {
     const pageConfigs = pageConfigsSerialized.map((pageConfigSerialized) => {
         const configValues = {};
@@ -49,7 +49,7 @@ function assertRouteConfigValue(configValues) {
         return;
     const { value } = configValue;
     const configValueType = typeof value;
-    const configDefinedAt = getConfigDefinedAtString(configName, configValue, true);
+    const configDefinedAt = getConfigDefinedAtString('Config', configName, configValue);
     assertUsage(configValueType === 'string' || isCallable(value), `${configDefinedAt} has an invalid type '${configValueType}': it should be a string or a function instead, see https://vike.dev/route`);
     /* We don't use assertRouteString() in order to avoid unnecessarily bloating the client-side bundle when using Server Routing:
     * - When using Server Routing, this file is loaded => loading assertRouteString() would bloat the client bundle.

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

@@ -23,29 +23,28 @@ function serializeConfigValue(lines, configName, configValueSerialized) {
 function serializeConfigValueImported(configValueSource, configName, whitespace, varCounterContainer, importStatements) {
     assert(!configValueSource.valueIsFilePath);
     assert(whitespace.replaceAll(' ', '').length === 0);
-    const { valueIsImportedAtRuntime, definedAtInfo } = configValueSource;
+    const { valueIsImportedAtRuntime, definedAt } = configValueSource;
     assert(valueIsImportedAtRuntime);
-    const { filePathRelativeToUserRootDir, importPathAbsolute, exportName } = definedAtInfo;
-    const importPath = filePathRelativeToUserRootDir ?? importPathAbsolute;
-    assertPosixPath(importPath);
-    const fileName = path.posix.basename(importPath);
+    const { filePathAbsoluteVite, fileExportName } = definedAt;
+    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/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/executeOnBeforeRouteHook.d.ts

@@ -1,3 +1,4 @@
+import type { PageContextForRoute, PageContextFromRoute } from './index.js';
 export { executeOnBeforeRouteHook };
 export type { OnBeforeRouteHook };
 type OnBeforeRouteHook = {
@@ -6,12 +7,8 @@ type OnBeforeRouteHook = {
         urlOriginal: string;
     } & Record<string, unknown>) => unknown;
 };
-declare function executeOnBeforeRouteHook(onBeforeRouteHook: OnBeforeRouteHook, pageContext: {
-    urlOriginal: string;
-    _allPageIds: string[];
-}): Promise<null | {
-    urlOriginal?: string;
-    _urlOriginalPristine?: string;
-    _pageId?: string | null;
-    routeParams?: Record<string, string>;
+declare function executeOnBeforeRouteHook(pageContext: PageContextForRoute): Promise<null | ({
+    _routingProvidedByOnBeforeRouteHook: true;
+} & PageContextFromRoute) | {
+    _routingProvidedByOnBeforeRouteHook: false;
 }>;

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

@@ -1,11 +1,40 @@
 import { assertPageContextProvidedByUser } from '../assertPageContextProvidedByUser.js';
-import { assertUsage, hasProp, isObjectWithKeys, objectAssign, assertWarning, assertUsageUrl, joinEnglish } from './utils.js';
+import { assertUsage, hasProp, isObjectWithKeys, objectAssign, assertWarning, assertUsageUrl, joinEnglish, assert } from './utils.js';
 import { assertRouteParams, assertSyncRouting } from './resolveRouteFunction.js';
 import pc from '@brillout/picocolors';
 export { executeOnBeforeRouteHook };
-async function executeOnBeforeRouteHook(onBeforeRouteHook, pageContext) {
+async function executeOnBeforeRouteHook(pageContext) {
+    const pageContextFromOnBeforeRouteHook = {};
+    if (!pageContext._onBeforeRouteHook)
+        return null;
+    const pageContextFromHook = await executeHook(pageContext._onBeforeRouteHook, pageContext);
+    if (pageContextFromHook) {
+        objectAssign(pageContextFromOnBeforeRouteHook, pageContextFromHook);
+        if (hasProp(pageContextFromOnBeforeRouteHook, '_pageId', 'string') ||
+            hasProp(pageContextFromOnBeforeRouteHook, '_pageId', 'null')) {
+            // We bypass Vike's routing
+            if (!hasProp(pageContextFromOnBeforeRouteHook, 'routeParams')) {
+                objectAssign(pageContextFromOnBeforeRouteHook, { routeParams: {} });
+            }
+            else {
+                assert(hasProp(pageContextFromOnBeforeRouteHook, 'routeParams', 'object'));
+            }
+            objectAssign(pageContextFromOnBeforeRouteHook, {
+                _routingProvidedByOnBeforeRouteHook: true,
+                _debugRouteMatches: 'CUSTOM_ROUTING'
+            });
+            return pageContextFromOnBeforeRouteHook;
+        }
+    }
+    objectAssign(pageContextFromOnBeforeRouteHook, {
+        _routingProvidedByOnBeforeRouteHook: false
+    });
+    return pageContextFromOnBeforeRouteHook;
+}
+async function executeHook(onBeforeRouteHook, pageContext) {
     let hookReturn = onBeforeRouteHook.onBeforeRoute(pageContext);
     assertSyncRouting(hookReturn, `The onBeforeRoute() hook ${onBeforeRouteHook.hookFilePath}`);
+    // TODO/v1-release: make executeOnBeforeRouteHook() and route() sync
     hookReturn = await hookReturn;
     const errPrefix = `The onBeforeRoute() hook defined by ${onBeforeRouteHook.hookFilePath}`;
     assertUsage(hookReturn === null ||
@@ -23,28 +52,25 @@ async function executeOnBeforeRouteHook(onBeforeRouteHook, pageContext) {
     if (hasProp(hookReturn.pageContext, 'routeParams')) {
         assertRouteParams(hookReturn.pageContext, `${errPrefix} returned ${pc.cyan('{ pageContext: { routeParams } }')} but routeParams should`);
     }
-    const pageContextAddendumHook = {};
+    const deprecatedReturn = (prop) => `${errPrefix} returned ${pc.cyan(`{ pageContext: { ${prop} } }`)} which is deprecated. Return ${pc.cyan('{ pageContext: { urlLogical } }')} instead.`;
     if (hasProp(hookReturn.pageContext, 'url')) {
-        assertWarning(false, `${errPrefix} returned ${pc.cyan('{ pageContext: { url } }')} but ${pc.cyan('pageContext.url')} has been renamed to ${pc.cyan('pageContext.urlOriginal')}. Return ${pc.cyan('{ pageContext: { urlOriginal } }')} instead. (See https://vike.dev/migration/0.4.23 for more information.)`, { onlyOnce: true });
-        hookReturn.pageContext.urlOriginal = hookReturn.pageContext.url;
+        assertWarning(false, deprecatedReturn('url'), { onlyOnce: true });
+        hookReturn.pageContext.urlLogical = hookReturn.pageContext.url;
         delete hookReturn.pageContext.url;
     }
     if (hasProp(hookReturn.pageContext, 'urlOriginal')) {
-        assertUsageUrl(hookReturn.pageContext.urlOriginal, `${errPrefix} returned ${pc.cyan('{ pageContext: { urlOriginal } }')} but ${pc.cyan('urlOriginal')}`);
-        // Ugly workaround: ideally urlOriginal should be immutable.
-        //  - Instead of using pageContext._urlOriginalPristine, maybe we can keep pageContext.urlOriginal immutable while re-using `pageContext._urlRewrite`.
-        //  - Or better yet we rename pageContext._urlRewrite to pageContext.urlLogical and we allow the user to override pageContext.urlLogical, and we rename pageContext.urlOriginal => `pageContext.urlReal`.
-        //    - pageContext.urlReal / pageContext.urlLogical
-        //                         VS
-        //      pageContext.urlReal / pageContext.urlModified
-        //                         VS
-        //      pageContext.urlOriginal / pageContext.urlModified
-        objectAssign(pageContextAddendumHook, { _urlOriginalPristine: pageContext.urlOriginal });
+        assertWarning(false, deprecatedReturn('urlOriginal'), { onlyOnce: true });
+        hookReturn.pageContext.urlLogical = hookReturn.pageContext.urlOriginal;
+        delete hookReturn.pageContext.urlOriginal;
+    }
+    if (hasProp(hookReturn.pageContext, 'urlLogical')) {
+        assertUsageUrl(hookReturn.pageContext.urlLogical, `${errPrefix} returned ${pc.cyan('{ pageContext: { urlLogical } }')} but ${pc.cyan('urlLogical')}`);
     }
     assertPageContextProvidedByUser(hookReturn.pageContext, {
         hookFilePath: onBeforeRouteHook.hookFilePath,
         hookName: 'onBeforeRoute'
     });
+    const pageContextAddendumHook = {};
     objectAssign(pageContextAddendumHook, hookReturn.pageContext);
     return pageContextAddendumHook;
 }

package/dist/esm/shared/route/index.d.ts

@@ -1,5 +1,8 @@
 export { route };
-export type { PageRoutes, PageContextForRoute, RouteMatches };
+export type { PageContextForRoute };
+export type { PageContextFromRoute };
+export type { PageRoutes };
+export type { RouteMatches };
 import type { PageFile } from '../getPageFiles.js';
 import { PageContextUrlComputedPropsInternal, PageContextUrlSources } from '../addUrlComputedProps.js';
 import { type OnBeforeRouteHook } from './executeOnBeforeRouteHook.js';
@@ -13,6 +16,12 @@ type PageContextForRoute = PageContextUrlComputedPropsInternal & {
     _pageRoutes: PageRoutes;
     _onBeforeRouteHook: OnBeforeRouteHook | null;
 } & PageContextUrlSources;
+type PageContextFromRoute = {
+    _pageId: string | null;
+    routeParams: Record<string, string>;
+    _routingProvidedByOnBeforeRouteHook?: boolean;
+    _debugRouteMatches: RouteMatches;
+};
 type RouteMatch = {
     pageId: string;
     routeString?: string;
@@ -20,12 +29,5 @@ type RouteMatch = {
     routeType: RouteType;
     routeParams: Record<string, string>;
 };
-type RouteMatches = 'CUSTOM_ROUTE' | RouteMatch[];
-declare function route(pageContext: PageContextForRoute): Promise<{
-    pageContextAddendum: {
-        _pageId: string | null;
-        routeParams: Record<string, string>;
-        _routingProvidedByOnBeforeRouteHook: boolean;
-        _routeMatches: RouteMatches;
-    } & Record<string, unknown>;
-}>;
+type RouteMatches = 'CUSTOM_ROUTING' | RouteMatch[];
+declare function route(pageContextForRoute: PageContextForRoute): Promise<PageContextFromRoute>;

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

@@ -5,7 +5,7 @@ import { isBrowser } from '../../utils/isBrowser.js';
 if (isBrowser()) {
     assertClientRouting();
 }
-import { assert, assertUsage, hasProp, isPlainObject, objectAssign } from './utils.js';
+import { assert, assertUsage, isPlainObject, objectAssign } from './utils.js';
 import { addUrlComputedProps } from '../addUrlComputedProps.js';
 import { resolvePrecendence } from './resolvePrecedence.js';
 import { resolveRouteString } from './resolveRouteString.js';
@@ -13,35 +13,25 @@ import { resolveRouteFunction } from './resolveRouteFunction.js';
 import { executeOnBeforeRouteHook } from './executeOnBeforeRouteHook.js';
 import { debug } from './debug.js';
 import pc from '@brillout/picocolors';
-async function route(pageContext) {
-    addUrlComputedProps(pageContext);
-    debug('Pages routes:', pageContext._pageRoutes);
-    const pageContextAddendum = {};
-    if (pageContext._onBeforeRouteHook) {
-        const pageContextAddendumHook = await executeOnBeforeRouteHook(pageContext._onBeforeRouteHook, pageContext);
-        if (pageContextAddendumHook) {
-            objectAssign(pageContextAddendum, pageContextAddendumHook);
-            if (hasProp(pageContextAddendum, '_pageId', 'string') || hasProp(pageContextAddendum, '_pageId', 'null')) {
-                // We bypass Vike's routing
-                if (!hasProp(pageContextAddendum, 'routeParams')) {
-                    objectAssign(pageContextAddendum, { routeParams: {} });
-                }
-                else {
-                    assert(hasProp(pageContextAddendum, 'routeParams', 'object'));
-                }
-                objectAssign(pageContextAddendum, {
-                    _routingProvidedByOnBeforeRouteHook: true,
-                    _routeMatches: 'CUSTOM_ROUTE'
-                });
-                return { pageContextAddendum };
-            }
-            // We already assign so that `pageContext.urlOriginal === pageContextAddendum.urlOriginal`; enabling the `onBeforeRoute()` hook to mutate `pageContext.urlOriginal` before routing.
-            objectAssign(pageContext, pageContextAddendum);
+async function route(pageContextForRoute) {
+    debug('Pages routes:', pageContextForRoute._pageRoutes);
+    addUrlComputedProps(pageContextForRoute);
+    const pageContextFromRoute = {};
+    // onBeforeRoute()
+    const pageContextFromOnBeforeRouteHook = await executeOnBeforeRouteHook(pageContextForRoute);
+    if (pageContextFromOnBeforeRouteHook) {
+        if (pageContextFromOnBeforeRouteHook._routingProvidedByOnBeforeRouteHook) {
+            assert(pageContextFromOnBeforeRouteHook._pageId);
+            return pageContextFromOnBeforeRouteHook;
+        }
+        else {
+            objectAssign(pageContextFromRoute, pageContextFromOnBeforeRouteHook);
         }
     }
-    objectAssign(pageContextAddendum, {
-        _routingProvidedByOnBeforeRouteHook: false
-    });
+    // We take into account pageContext.urlLogical set by onBeforeRoute()
+    const pageContext = {};
+    objectAssign(pageContext, pageContextForRoute);
+    objectAssign(pageContext, pageContextFromOnBeforeRouteHook);
     // Vike's routing
     const allPageIds = pageContext._allPageIds;
     assert(allPageIds.length >= 0);
@@ -93,21 +83,21 @@ async function route(pageContext) {
     resolvePrecendence(routeMatches);
     const winner = routeMatches[0];
     debug(`Route matches for URL ${pc.cyan(urlPathname)} (in precedence order):`, routeMatches);
-    objectAssign(pageContextAddendum, { _routeMatches: routeMatches });
+    objectAssign(pageContextFromRoute, { _debugRouteMatches: routeMatches });
     if (!winner) {
-        objectAssign(pageContextAddendum, {
+        objectAssign(pageContextFromRoute, {
             _pageId: null,
             routeParams: {}
         });
-        return { pageContextAddendum };
+        return pageContextFromRoute;
     }
     {
         const { routeParams } = winner;
         assert(isPlainObject(routeParams));
-        objectAssign(pageContextAddendum, {
+        objectAssign(pageContextFromRoute, {
             _pageId: winner.pageId,
             routeParams: winner.routeParams
         });
     }
-    return { pageContextAddendum };
+    return pageContextFromRoute;
 }

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

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

package/dist/esm/shared/route/noRouteMatch.d.ts

@@ -0,0 +1 @@
+export declare const noRouteMatch = "doesn't match the route of any of your pages";

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

@@ -0,0 +1 @@
+export const noRouteMatch = "doesn't match the route of any of your pages";

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

@@ -9,7 +9,7 @@ async function resolveRouteFunction(routeFunction, pageContext, routeDefinedAt)
     assertPageContextUrlComputedProps(pageContext);
     let result = routeFunction(pageContext);
     assertSyncRouting(result, `The Route Function ${routeDefinedAt}`);
-    // TODO/v1-release
+    // TODO/v1-release: make resolveRouteFunction() and route() sync
     //* We disallow asynchronous routing, because we need to check whether a link is a Vike link in a synchronous fashion before calling ev.preventDefault() in the 'click' event listener
     result = await result;
     //*/

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

@@ -15,7 +15,7 @@ export * from '../utils/stringifyStringArray.js';
 export * from '../utils/filesystemPathHandling.js';
 export * from '../utils/cast.js';
 export * from '../utils/projectInfo.js';
-export * from '../utils/hasPropertyGetter.js';
+export * from '../utils/isPropertyGetter.js';
 export * from '../utils/isPromise.js';
 export * from '../utils/checkType.js';
 export * from '../utils/objectEntries.js';

package/dist/esm/shared/utils.js

@@ -19,7 +19,7 @@ export * from '../utils/stringifyStringArray.js';
 export * from '../utils/filesystemPathHandling.js';
 export * from '../utils/cast.js';
 export * from '../utils/projectInfo.js';
-export * from '../utils/hasPropertyGetter.js';
+export * from '../utils/isPropertyGetter.js';
 export * from '../utils/isPromise.js';
 export * from '../utils/checkType.js';
 export * from '../utils/objectEntries.js';

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

@@ -2,4 +2,4 @@ export { getFilePathAbsolute };
 export { getFilePathRelativeToUserRootDir };
 import type { ResolvedConfig } from 'vite';
 declare function getFilePathAbsolute(filePath: string, config: ResolvedConfig): string;
-declare function getFilePathRelativeToUserRootDir(filePathAbsolute: string, userRootDir: string, alwaysRelative?: boolean): string;
+declare function getFilePathRelativeToUserRootDir(filePathAbsoluteFilesystem: string, userRootDir: string, alwaysRelative?: boolean): string;

package/dist/esm/utils/getFilePathAbsolute.js

@@ -30,26 +30,26 @@ function getFilePathAbsolute(filePath, config) {
         filePathUnresolved = path.posix.join(root, filePath);
         assertPathIsFilesystemAbsolute(filePathUnresolved);
     }
-    let filePathAbsolute;
+    let filePathAbsoluteFilesystem;
     try {
-        filePathAbsolute = require_.resolve(filePathUnresolved, { paths: [config.root] });
+        filePathAbsoluteFilesystem = require_.resolve(filePathUnresolved, { paths: [config.root] });
     }
     catch (err) {
         console.error(err);
         assert(false);
     }
-    filePathAbsolute = toPosixPath(filePathAbsolute);
-    assertPathIsFilesystemAbsolute(filePathAbsolute);
-    return filePathAbsolute;
+    filePathAbsoluteFilesystem = toPosixPath(filePathAbsoluteFilesystem);
+    assertPathIsFilesystemAbsolute(filePathAbsoluteFilesystem);
+    return filePathAbsoluteFilesystem;
 }
-function getFilePathRelativeToUserRootDir(filePathAbsolute, userRootDir, alwaysRelative = false) {
-    assertPosixPath(filePathAbsolute);
+function getFilePathRelativeToUserRootDir(filePathAbsoluteFilesystem, userRootDir, alwaysRelative = false) {
+    assertPosixPath(filePathAbsoluteFilesystem);
     assertPosixPath(userRootDir);
-    let filePathRelativeToUserRootDir = path.posix.relative(userRootDir, filePathAbsolute);
-    if (filePathAbsolute.startsWith(userRootDir)) {
+    let filePathRelativeToUserRootDir = path.posix.relative(userRootDir, filePathAbsoluteFilesystem);
+    if (filePathAbsoluteFilesystem.startsWith(userRootDir)) {
         assert(!filePathRelativeToUserRootDir.startsWith('.') && !filePathRelativeToUserRootDir.startsWith('/'), 
         // Surprinsingly, this assertion seem to fail sometimes: https://github.com/vikejs/vike/issues/1139
-        { filePathRelativeToUserRootDir, filePathAbsolute, userRootDir });
+        { filePathRelativeToUserRootDir, filePathAbsoluteFilesystem, userRootDir });
         filePathRelativeToUserRootDir = `/${filePathRelativeToUserRootDir}`;
         return filePathRelativeToUserRootDir;
     }
@@ -58,7 +58,7 @@ function getFilePathRelativeToUserRootDir(filePathAbsolute, userRootDir, alwaysR
             return filePathRelativeToUserRootDir;
         }
         else {
-            return filePathAbsolute;
+            return filePathAbsoluteFilesystem;
         }
     }
 }

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

@@ -0,0 +1 @@
+export declare function isPropertyGetter(obj: Object, prop: string): boolean;

package/dist/esm/utils/{hasPropertyGetter.js → isPropertyGetter.js}

@@ -1,4 +1,4 @@
-export function hasPropertyGetter(obj, prop) {
+export function isPropertyGetter(obj, prop) {
     const descriptor = Object.getOwnPropertyDescriptor(obj, prop);
     return !!descriptor && !('value' in descriptor) && !!descriptor.get;
 }

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

@@ -0,0 +1,4 @@
+export { onPageHide };
+export { onPageShow };
+declare function onPageHide(listener: () => void): void;
+declare function onPageShow(listener: () => void): void;

package/dist/esm/utils/onPageVisibilityChange.js

@@ -0,0 +1,16 @@
+export { onPageHide };
+export { onPageShow };
+function onPageHide(listener) {
+    window.addEventListener('visibilitychange', () => {
+        if (document.visibilityState === 'hidden') {
+            listener();
+        }
+    });
+}
+function onPageShow(listener) {
+    window.addEventListener('visibilitychange', () => {
+        if (document.visibilityState === 'visible') {
+            listener();
+        }
+    });
+}

package/dist/esm/utils/parseUrl.js

@@ -51,7 +51,7 @@ function parseUrl(url, baseServer) {
     const searchAll = {};
     Array.from(new URLSearchParams(searchOriginal || '')).forEach(([key, val]) => {
         search[key] = val;
-        searchAll[key] = [...(searchAll[key] || []), val];
+        searchAll[key] = [...(searchAll.hasOwnProperty(key) ? searchAll[key] : []), val];
     });
     // Origin + pathname
     const { origin, pathname: pathnameResolved } = parsePathname(urlWithoutHashNorSearch, baseServer);

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";
+    projectVersion: "0.4.145-commit-2520555";
     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';
+const PROJECT_VERSION = '0.4.145-commit-2520555';
 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/node/cli/bin-entry.js

@@ -1,3 +1,3 @@
 #!/usr/bin/env node
 
-import '../../dist/esm/node/cli/bin.mjs'
+import '../../dist/esm/node/cli/bin.js'