vike 0.4.196 → 0.4.197-commit-f4d8658

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

@@ -10,7 +10,7 @@ type PageContextDebugRouteMatches = {
 declare function debugPageFiles({ pageContext, isHtmlOnly, isClientRouting, pageFilesLoaded, pageFilesServerSide, pageFilesClientSide, clientEntries, clientDependencies }: {
     pageContext: {
         urlOriginal: string;
-        _pageId: string;
+        pageId: string;
         _pageFilesAll: PageFile[];
         _pageConfigs: PageConfigRuntime[];
     } & PageContextDebugRouteMatches;

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

@@ -7,7 +7,7 @@ function debugPageFiles({ pageContext, isHtmlOnly, isClientRouting, pageFilesLoa
     debug('All page files:', printPageFiles(pageContext._pageFilesAll, true)); // TODO
     debug(`URL:`, pageContext.urlOriginal);
     debug.options({ serialization: { emptyArray: 'No match' } })(`Routing:`, printRouteMatches(pageContext._debugRouteMatches));
-    debug(`pageId:`, pageContext._pageId);
+    debug(`pageId:`, pageContext.pageId);
     debug('Page type:', isHtmlOnly ? 'HTML-only' : 'SSR/SPA');
     debug(`Routing type:`, !isHtmlOnly && isClientRouting ? 'Client Routing' : 'Server Routing');
     debug('Server-side page files:', printPageFiles(pageFilesLoaded));

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

@@ -2,6 +2,6 @@ export { executeOnBeforeRenderAndDataHooks };
 import { type PageContextExports } from '../../../shared/getPageFiles.js';
 import { type PageContextForUserConsumptionServerSide } from './preparePageContextForUserConsumptionServerSide.js';
 declare function executeOnBeforeRenderAndDataHooks(pageContext: {
-    _pageId: string;
+    pageId: string;
     _pageContextAlreadyProvidedByOnPrerenderHook?: true;
 } & PageContextExports & PageContextForUserConsumptionServerSide): Promise<void>;

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

@@ -12,7 +12,7 @@ type RenderHook = Hook & {
 };
 type HookName = 'onRenderHtml' | 'render';
 declare function executeOnRenderHtmlHook(pageContext: PageContextForUserConsumptionServerSide & PageContextSerialization & {
-    _pageId: string;
+    pageId: string;
     _pageConfigs: PageConfigRuntime[];
     __getPageAssets: GetPageAssets;
     _isHtmlOnly: boolean;

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

@@ -6,7 +6,7 @@ declare function handleErrorWithoutErrorPage<PageContext extends {
     isClientSideNavigation: boolean;
     errorWhileRendering: null | Error;
     is404: null | boolean;
-    _pageId: null;
+    pageId: null;
     _pageFilesAll: PageFile[];
     _pageConfigs: PageConfigRuntime[];
     urlOriginal: string;

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

@@ -6,7 +6,7 @@ import { createHttpResponsePage, createHttpResponseError } from './createHttpRes
 import pc from '@brillout/picocolors';
 // When the user hasn't defined _error.page.js
 async function handleErrorWithoutErrorPage(pageContext) {
-    assert(pageContext._pageId === null);
+    assert(pageContext.pageId === null);
     assert(pageContext.errorWhileRendering || pageContext.is404);
     {
         const isV1 = pageContext._pageConfigs.length > 0;

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

@@ -13,7 +13,7 @@ type PageContext_loadUserFilesServerSide = PageContextGetPageAssets & PageContex
 };
 type PageFiles = PromiseType<ReturnType<typeof loadUserFilesServerSide>>;
 declare function loadUserFilesServerSide(pageContext: {
-    _pageId: string;
+    pageId: string;
 } & PageContext_loadUserFilesServerSide): Promise<import("../../../shared/getPageFiles.js").PageContextExports & {
     Page: unknown;
     _isHtmlOnly: boolean;

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

@@ -9,12 +9,12 @@ import { analyzePage } from './analyzePage.js';
 import { getGlobalContext } from '../globalContext.js';
 import { loadConfigValues } from '../../../shared/page-configs/loadConfigValues.js';
 async function loadUserFilesServerSide(pageContext) {
-    const pageConfig = findPageConfig(pageContext._pageConfigs, pageContext._pageId); // Make pageConfig globally available as pageContext._pageConfig?
+    const pageConfig = findPageConfig(pageContext._pageConfigs, pageContext.pageId); // Make pageConfig globally available as pageContext._pageConfig?
     const [{ pageFilesLoaded, pageContextExports }] = await Promise.all([
-        loadPageUserFiles(pageContext._pageFilesAll, pageConfig, pageContext._pageId, !getGlobalContext().isProduction),
-        analyzePageClientSideInit(pageContext._pageFilesAll, pageContext._pageId, { sharedPageFilesAlreadyLoaded: true })
+        loadPageUserFiles(pageContext._pageFilesAll, pageConfig, pageContext.pageId, !getGlobalContext().isProduction),
+        analyzePageClientSideInit(pageContext._pageFilesAll, pageContext.pageId, { sharedPageFilesAlreadyLoaded: true })
     ]);
-    const { isHtmlOnly, isClientRouting, clientEntries, clientDependencies, pageFilesClientSide, pageFilesServerSide } = analyzePage(pageContext._pageFilesAll, pageConfig, pageContext._pageId);
+    const { isHtmlOnly, isClientRouting, clientEntries, clientDependencies, pageFilesClientSide, pageFilesServerSide } = analyzePage(pageContext._pageFilesAll, pageConfig, pageContext.pageId);
     const isV1Design = !!pageConfig;
     const passToClient = [];
     const errMsg = ' should be an array of strings.';

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

@@ -12,7 +12,7 @@ type PageContextForUserConsumptionServerSide = PageContextBuiltInServerInternal
     urlParsed: PageContextUrlInternal['urlParsed'];
     routeParams: Record<string, string>;
     Page: unknown;
-    _pageId: string;
+    pageId: string;
     _pageConfigs: PageConfigRuntime[];
     is404: null | boolean;
     isClientSideNavigation: boolean;

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

@@ -1,16 +1,11 @@
 export { preparePageContextForUserConsumptionServerSide };
-import { assert, isPlainObject, isObject } from '../utils.js';
-import { sortPageContext } from '../../../shared/sortPageContext.js';
+import { assert, isPlainObject } from '../utils.js';
 import { assertPageContextUrl } from '../../../shared/getPageContextUrlComputed.js';
-import { addIs404ToPageProps } from '../../../shared/addIs404ToPageProps.js';
+import { preparePageContextForUserConsumption } from '../../../shared/preparePageContextForUserConsumption.js';
 function preparePageContextForUserConsumptionServerSide(pageContext) {
     assertPageContextUrl(pageContext);
     assert(isPlainObject(pageContext.routeParams));
     assert('Page' in pageContext);
-    assert(isObject(pageContext.pageExports));
-    assert(isObject(pageContext.exports));
-    assert(isObject(pageContext.exportsAll));
     assert(typeof pageContext.isClientSideNavigation === 'boolean');
-    sortPageContext(pageContext);
-    addIs404ToPageProps(pageContext);
+    preparePageContextForUserConsumption(pageContext);
 }

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

@@ -18,7 +18,7 @@ type PageContextAfterRender = {
     errorWhileRendering: null | Error;
 };
 declare function renderPageAlreadyRouted<PageContext extends {
-    _pageId: string;
+    pageId: string;
     _pageContextAlreadyProvidedByOnPrerenderHook?: true;
     is404: null | boolean;
     routeParams: Record<string, string>;
@@ -27,7 +27,7 @@ declare function renderPageAlreadyRouted<PageContext extends {
 } & PageContextInitEnhanced & PageContextUrlInternal & PageContext_loadUserFilesServerSide>(pageContext: PageContext): Promise<PageContext & PageContextAfterRender>;
 declare function prerenderPage(pageContext: PageContextInitEnhanced & PageFiles & {
     routeParams: Record<string, string>;
-    _pageId: string;
+    pageId: string;
     _urlRewrite: null;
     _httpRequestId: number | null;
     _usesClientRouter: boolean;
@@ -74,7 +74,7 @@ declare function prerenderPage(pageContext: PageContextInitEnhanced & PageFiles
         __getPageAssets: () => Promise<import("./getPageAssets.js").PageAsset[]>;
     } & {
         routeParams: Record<string, string>;
-        _pageId: string;
+        pageId: string;
         _urlRewrite: null;
         _httpRequestId: number | null;
         _usesClientRouter: boolean;
@@ -125,7 +125,7 @@ declare function prerenderPage(pageContext: PageContextInitEnhanced & PageFiles
         __getPageAssets: () => Promise<import("./getPageAssets.js").PageAsset[]>;
     } & {
         routeParams: Record<string, string>;
-        _pageId: string;
+        pageId: string;
         _urlRewrite: null;
         _httpRequestId: number | null;
         _usesClientRouter: boolean;
@@ -177,7 +177,7 @@ declare function prerender404Page(renderContext: RenderContext, pageContextInit_
         __getPageAssets: () => Promise<import("./getPageAssets.js").PageAsset[]>;
     } & {
         routeParams: Record<string, string>;
-        _pageId: string;
+        pageId: string;
         _urlRewrite: null;
         _httpRequestId: number | null;
         _usesClientRouter: boolean;
@@ -228,7 +228,7 @@ declare function prerender404Page(renderContext: RenderContext, pageContextInit_
         __getPageAssets: () => Promise<import("./getPageAssets.js").PageAsset[]>;
     } & {
         routeParams: Record<string, string>;
-        _pageId: string;
+        pageId: string;
         _urlRewrite: null;
         _httpRequestId: number | null;
         _usesClientRouter: boolean;

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

@@ -23,12 +23,12 @@ import pc from '@brillout/picocolors';
 import { isServerSideError } from '../../../shared/misc/isServerSideError.js';
 import { assertV1Design } from '../../shared/assertV1Design.js';
 async function renderPageAlreadyRouted(pageContext) {
-    // pageContext._pageId can either be the:
+    // pageContext.pageId can either be the:
     //  - ID of the page matching the routing, or the
     //  - ID of the error page `_error.page.js`.
-    assert(hasProp(pageContext, '_pageId', 'string'));
+    assert(hasProp(pageContext, 'pageId', 'string'));
     const isError = pageContext.is404 || !!pageContext.errorWhileRendering;
-    assert(isError === (pageContext._pageId === getErrorPageId(pageContext._pageFilesAll, pageContext._pageConfigs)));
+    assert(isError === (pageContext.pageId === getErrorPageId(pageContext._pageFilesAll, pageContext._pageConfigs)));
     objectAssign(pageContext, await loadUserFilesServerSide(pageContext));
     if (!isError) {
         await executeGuardHook(pageContext, (pageContext) => preparePageContextForUserConsumptionServerSide(pageContext));
@@ -90,7 +90,7 @@ async function prerender404Page(renderContext, pageContextInit_) {
         return null;
     }
     const pageContext = {
-        _pageId: errorPageId,
+        pageId: errorPageId,
         _httpRequestId: null,
         _urlRewrite: null,
         is404: true,

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

@@ -157,11 +157,11 @@ async function renderPageAlreadyPrepared(pageContextInit, httpRequestId, renderC
         {
             const errorPageId = getErrorPageId(renderContext.pageFilesAll, renderContext.pageConfigs);
             if (!errorPageId) {
-                objectAssign(pageContextErrorPageInit, { _pageId: null });
+                objectAssign(pageContextErrorPageInit, { pageId: null });
                 return handleErrorWithoutErrorPage(pageContextErrorPageInit);
             }
             else {
-                objectAssign(pageContextErrorPageInit, { _pageId: errorPageId });
+                objectAssign(pageContextErrorPageInit, { pageId: errorPageId });
             }
         }
         let pageContextErrorPage;
@@ -270,17 +270,17 @@ async function renderPageNominal(pageContext) {
     {
         const pageContextFromRoute = await route(pageContext);
         objectAssign(pageContext, pageContextFromRoute);
-        objectAssign(pageContext, { is404: pageContext._pageId ? null : true });
-        if (pageContext._pageId === null) {
+        objectAssign(pageContext, { is404: pageContext.pageId ? null : true });
+        if (pageContext.pageId === null) {
             const errorPageId = getErrorPageId(pageContext._pageFilesAll, pageContext._pageConfigs);
             if (!errorPageId) {
-                assert(hasProp(pageContext, '_pageId', 'null'));
+                assert(hasProp(pageContext, 'pageId', 'null'));
                 return handleErrorWithoutErrorPage(pageContext);
             }
-            objectAssign(pageContext, { _pageId: errorPageId });
+            objectAssign(pageContext, { pageId: errorPageId });
         }
     }
-    assert(hasProp(pageContext, '_pageId', 'string'));
+    assert(hasProp(pageContext, 'pageId', 'string'));
     assert(pageContext.errorWhileRendering === null);
     // Render
     const pageContextAfterRender = await renderPageAlreadyRouted(pageContext);
@@ -400,7 +400,7 @@ pageContextNominalPageInit, httpRequestId, renderContext, pageContextErrorPageIn
             assert(abortCall);
             assertUsage(errorPageId, `You called ${pc.cyan(abortCall)} but you didn't define an error page, make sure to define one https://vike.dev/error-page`);
             const pageContext = createPageContext({});
-            objectAssign(pageContext, { _pageId: errorPageId });
+            objectAssign(pageContext, { pageId: errorPageId });
             objectAssign(pageContext, pageContextAbort);
             objectAssign(pageContext, pageContextErrorPageInit);
             objectAssign(pageContext, renderContext);

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

@@ -2,6 +2,6 @@ export { addIs404ToPageProps };
 import type { PageConfigRuntime } from './page-configs/PageConfig.js';
 declare function addIs404ToPageProps(pageContext: Record<string, unknown> & PageContextAssertIs404): void;
 type PageContextAssertIs404 = {
-    _pageId: string;
+    pageId: string;
     _pageConfigs: PageConfigRuntime[];
 };

package/dist/esm/shared/addIs404ToPageProps.js

@@ -6,7 +6,7 @@ function addIs404ToPageProps(pageContext) {
     addIs404(pageContext);
 }
 function assertIs404(pageContext) {
-    if (isErrorPage(pageContext._pageId, pageContext._pageConfigs)) {
+    if (isErrorPage(pageContext.pageId, pageContext._pageConfigs)) {
         assert(hasProp(pageContext, 'is404', 'boolean'));
     }
 }

package/dist/esm/shared/assertPageContextProvidedByUser.js

@@ -10,6 +10,6 @@ function assertPageContextProvidedByUser(pageContextProvidedByUser, { hookName,
     assertUsage(!('_objectCreatedByVike' in pageContextProvidedByUser), `${errPrefix} shouldn't be the whole ${pc.cyan('pageContext')} object, see https://vike.dev/pageContext-manipulation#do-not-return-entire-pagecontext`);
     // In principle, it's possible to use onBeforeRoute()` to override and define the whole routing.
     // Is that a good idea to allow users to do this? Beyond deep integration with Vue Router or React Router, is there a use case for this?
-    assertWarning(!('_pageId' in pageContextProvidedByUser), `${errPrefix} sets ${pc.cyan('pageContext._pageId')} which means that Vike's routing is overriden. This is an experimental feature: make sure to contact a vike maintainer before using this.`, { onlyOnce: true });
+    assertWarning(!('pageId' in pageContextProvidedByUser), `${errPrefix} sets ${pc.cyan('pageContext.pageId')} which means that Vike's routing is overriden. This is an experimental feature: make sure to contact a vike maintainer before using this.`, { onlyOnce: true });
     assertUsage(!('is404' in pageContextProvidedByUser), `${errPrefix} sets ${pc.cyan('pageContext.is404')} which is forbidden, use ${pc.cyan('throw render()')} instead, see https://vike.dev/render`);
 }

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

@@ -30,13 +30,14 @@ export type { OnRenderHtmlAsync };
 export type { OnRenderHtmlSync };
 export type { RouteAsync };
 export type { RouteSync };
+export type { KeepScrollPosition };
+import type { PrefetchSetting, PrefetchStaticAssets } from '../../client/client-routing-runtime/prefetch/PrefetchSetting.js';
 import type { ConfigDefinition } from '../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/configDefinitionsBuiltIn.js';
 import type { DocumentHtml } from '../../node/runtime/html/renderHtml.js';
 import type { ConfigVikeUserProvided } from '../ConfigVike.js';
 import type { Vike, VikePackages } from '../VikeNamespace.js';
 import type { HooksTimeoutProvidedByUser } from '../hooks/getHook.js';
 import type { PageContextClient, PageContextServer } from '../types.js';
-import type { PrefetchStaticAssets } from '../types/PrefetchStaticAssets.js';
 type HookName = HookNamePage | HookNameGlobal | HookNameOldDesign;
 type HookNamePage = 'onHydrationEnd' | 'onBeforePrerenderStart' | 'onBeforeRender' | 'onPageTransitionStart' | 'onPageTransitionEnd' | 'onRenderHtml' | 'onRenderClient' | 'guard' | 'data';
 type HookNameGlobal = 'onBeforePrerender' | 'onBeforeRoute' | 'onPrerenderStart';
@@ -218,6 +219,11 @@ type RouteSync = (pageContext: PageContextServer | PageContextClient) => {
     routeParams?: Record<string, string>;
     precedence?: number;
 } | boolean;
+/** Whether the page scrolls to the top upon navigation.
+ *
+ * https://vike.dev/keepScrollPosition
+ */
+type KeepScrollPosition = boolean | string | string[] | ((pageContext: PageContextClient) => boolean | string | string[]);
 /** Page configuration.
  *
  * https://vike.dev/config
@@ -338,6 +344,15 @@ type ConfigBuiltIn = {
      * https://vike.dev/meta
      */
     meta?: ConfigMeta | ImportString;
+    /**
+     * @experimental: DON'T USE: the API *will* have breaking changes upon any minor version release.
+     *
+     * Prefetch pages/links.
+     *
+     * https://vike.dev/prefetch
+     */
+    prefetch?: PrefetchSetting | ImportString;
+    /** @deprecated Use `prefetch` setting (https://vike.dev/prefetch) instead.  */
     /** Prefetch links.
      *
      * https://vike.dev/prefetchStaticAssets
@@ -369,6 +384,11 @@ type ConfigBuiltIn = {
      * https://vike.dev/require
      */
     require?: Record<string, string>;
+    /** Whether the page scrolls to the top upon navigation.
+     *
+     * https://vike.dev/keepScrollPosition
+     */
+    keepScrollPosition?: KeepScrollPosition;
 };
 type ConfigMeta = Record<string, ConfigDefinition>;
 type ImportString = `import:${string}`;

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

@@ -2,7 +2,7 @@ export { serializeConfigValues };
 import { assertIsNotProductionRuntime } from '../../../utils/assertIsNotProductionRuntime.js';
 import { assert, assertUsage, getPropAccessNotation } from '../../../node/plugin/utils.js';
 import { addImportStatement } from '../../../node/plugin/plugins/importUserCode/addImportStatement.js';
-import { parsePointerImportData } from '../../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/transformFileImports.js';
+import { parsePointerImportData } from '../../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/transformPointerImports.js';
 import { getConfigValueFilePathToShowToUser } from '../helpers.js';
 import { stringify } from '@brillout/json-serializer/stringify';
 import pc from '@brillout/picocolors';

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

@@ -0,0 +1,5 @@
+export { preparePageContextForUserConsumption };
+import type { PageContextForUserConsumptionClientSide } from '../client/shared/preparePageContextForUserConsumptionClientSide.js';
+import type { PageContextForUserConsumptionServerSide } from '../node/runtime/renderPage/preparePageContextForUserConsumptionServerSide.js';
+type PageContextForUserConsumption = PageContextForUserConsumptionServerSide | PageContextForUserConsumptionClientSide;
+declare function preparePageContextForUserConsumption(pageContext: PageContextForUserConsumption): void;

package/dist/esm/shared/preparePageContextForUserConsumption.js

@@ -0,0 +1,32 @@
+export { preparePageContextForUserConsumption };
+import { assert, assertWarning, compareString } from './utils.js';
+import { addIs404ToPageProps } from './addIs404ToPageProps.js';
+function preparePageContextForUserConsumption(pageContext) {
+    assert(pageContext.pageId);
+    assert('config' in pageContext);
+    assert('configEntries' in pageContext);
+    addIs404ToPageProps(pageContext);
+    // TODO/next-major-release: remove
+    if (!('_pageId' in pageContext)) {
+        Object.defineProperty(pageContext, '_pageId', {
+            get() {
+                assertWarning(false, 'pageContext._pageId has been renamed to pageContext.pageId', {
+                    showStackTrace: true,
+                    onlyOnce: true
+                });
+                return pageContext.pageId;
+            },
+            enumerable: false
+        });
+    }
+    // For a more readable `console.log(pageContext)` output
+    sortPageContext(pageContext);
+}
+// Sort `pageContext` keys alphabetically, in order to make reading the `console.log(pageContext)` output easier
+function sortPageContext(pageContext) {
+    let descriptors = Object.getOwnPropertyDescriptors(pageContext);
+    for (const key of Object.keys(pageContext))
+        delete pageContext[key];
+    descriptors = Object.fromEntries(Object.entries(descriptors).sort(([key1], [key2]) => compareString(key1, key2)));
+    Object.defineProperties(pageContext, descriptors);
+}

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

@@ -2,7 +2,7 @@ export { executeGuardHook };
 import type { PageContextExports, PageFile } from '../getPageFiles.js';
 import type { PageConfigRuntime } from '../page-configs/PageConfig.js';
 declare function executeGuardHook<T extends PageContextExports & {
-    _pageId: string;
+    pageId: string;
     _pageFilesAll: PageFile[];
     _pageConfigs: PageConfigRuntime[];
 }>(pageContext: T, prepareForUserConsumption: (pageConfig: T) => T | void): Promise<void>;

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

@@ -8,7 +8,7 @@ async function executeGuardHook(pageContext, prepareForUserConsumption) {
     if (pageContext._pageFilesAll.length > 0) {
         // V0.4 design
         assert(pageContext._pageConfigs.length === 0);
-        hook = findPageGuard(pageContext._pageId, pageContext._pageFilesAll);
+        hook = findPageGuard(pageContext.pageId, pageContext._pageFilesAll);
     }
     else {
         // V1 design

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

@@ -11,8 +11,8 @@ async function executeOnBeforeRouteHook(pageContext) {
     const pageContextFromHook = await getPageContextFromHook(pageContext._onBeforeRouteHook, pageContext);
     if (pageContextFromHook) {
         objectAssign(pageContextFromOnBeforeRouteHook, pageContextFromHook);
-        if (hasProp(pageContextFromOnBeforeRouteHook, '_pageId', 'string') ||
-            hasProp(pageContextFromOnBeforeRouteHook, '_pageId', 'null')) {
+        if (hasProp(pageContextFromOnBeforeRouteHook, 'pageId', 'string') ||
+            hasProp(pageContextFromOnBeforeRouteHook, 'pageId', 'null')) {
             // We bypass Vike's routing
             if (!hasProp(pageContextFromOnBeforeRouteHook, 'routeParams')) {
                 objectAssign(pageContextFromOnBeforeRouteHook, { routeParams: {} });
@@ -45,10 +45,10 @@ async function getPageContextFromHook(onBeforeRouteHook, pageContext) {
         return null;
     }
     assertUsage(hasProp(hookReturn, 'pageContext', 'object'), `${errPrefix} returned ${pc.cyan('{ pageContext }')} but pageContext should be a plain JavaScript object.`);
-    if (hasProp(hookReturn.pageContext, '_pageId') && !hasProp(hookReturn.pageContext, '_pageId', 'null')) {
-        const errPrefix2 = `${errPrefix} returned ${pc.cyan('{ pageContext: { _pageId } }')} but ${pc.cyan('_pageId')} should be`;
-        assertUsage(hasProp(hookReturn.pageContext, '_pageId', 'string'), `${errPrefix2} a string or null`);
-        assertUsage(pageContext._allPageIds.includes(hookReturn.pageContext._pageId), `${errPrefix2} ${joinEnglish(pageContext._allPageIds.map((s) => pc.cyan(s)), 'or')}`);
+    if (hasProp(hookReturn.pageContext, 'pageId') && !hasProp(hookReturn.pageContext, 'pageId', 'null')) {
+        const errPrefix2 = `${errPrefix} returned ${pc.cyan('{ pageContext: { pageId } }')} but ${pc.cyan('pageId')} should be`;
+        assertUsage(hasProp(hookReturn.pageContext, 'pageId', 'string'), `${errPrefix2} a string or null`);
+        assertUsage(pageContext._allPageIds.includes(hookReturn.pageContext.pageId), `${errPrefix2} ${joinEnglish(pageContext._allPageIds.map((s) => pc.cyan(s)), 'or')}`);
     }
     if (hasProp(hookReturn.pageContext, 'routeParams')) {
         assertRouteParams(hookReturn.pageContext, `${errPrefix} returned ${pc.cyan('{ pageContext: { routeParams } }')} but routeParams should`);

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

@@ -17,7 +17,7 @@ type PageContextForRoute = PageContextUrlInternal & {
     _onBeforeRouteHook: Hook | null;
 } & PageContextUrlSource;
 type PageContextFromRoute = {
-    _pageId: string | null;
+    pageId: string | null;
     routeParams: Record<string, string>;
     _routingProvidedByOnBeforeRouteHook?: boolean;
     _debugRouteMatches: RouteMatches;

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

@@ -21,7 +21,7 @@ async function route(pageContext) {
     const pageContextFromOnBeforeRouteHook = await executeOnBeforeRouteHook(pageContext);
     if (pageContextFromOnBeforeRouteHook) {
         if (pageContextFromOnBeforeRouteHook._routingProvidedByOnBeforeRouteHook) {
-            assert(pageContextFromOnBeforeRouteHook._pageId);
+            assert(pageContextFromOnBeforeRouteHook.pageId);
             return pageContextFromOnBeforeRouteHook;
         }
         else {
@@ -85,7 +85,7 @@ async function route(pageContext) {
     objectAssign(pageContextFromRoute, { _routeMatch: winner });
     if (!winner) {
         objectAssign(pageContextFromRoute, {
-            _pageId: null,
+            pageId: null,
             routeParams: {}
         });
         return pageContextFromRoute;
@@ -94,7 +94,7 @@ async function route(pageContext) {
         const { routeParams } = winner;
         assert(isPlainObject(routeParams));
         objectAssign(pageContextFromRoute, {
-            _pageId: winner.pageId,
+            pageId: winner.pageId,
             routeParams: winner.routeParams
         });
     }

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

@@ -3,25 +3,12 @@ export { getUrlFromRouteString };
 export { isStaticRouteString };
 export { analyzeRouteString };
 export { assertRouteString };
-export { parseRouteString };
+export { getRouteStringParameterList };
 declare function assertRouteString(routeString: string, errPrefix?: `${string}Invalid` | `${string}invalid`): void;
 declare function resolveRouteString(routeString: string, urlPathname: string): null | {
     routeParams: Record<string, string>;
 };
-type Segment = {
-    glob: true;
-    static?: undefined;
-    param?: undefined;
-} | {
-    glob?: undefined;
-    static: string;
-    param?: undefined;
-} | {
-    glob?: undefined;
-    static?: undefined;
-    param: string;
-};
-declare function parseRouteString(routeString: string): Segment[];
+declare function getRouteStringParameterList(routeString: string): string[];
 declare function getUrlFromRouteString(routeString: string): null | string;
 declare function analyzeRouteString(routeString: string): {
     numberOfStaticPartsBeginning: number;

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

@@ -3,7 +3,7 @@ export { getUrlFromRouteString };
 export { isStaticRouteString };
 export { analyzeRouteString };
 export { assertRouteString };
-export { parseRouteString };
+export { getRouteStringParameterList };
 import { assertWarning, isBrowser, escapeRegex } from '../utils.js';
 import { assert, assertUsage } from './utils.js';
 import pc from '@brillout/picocolors';
@@ -96,6 +96,15 @@ function parseRouteString(routeString) {
     });
     return segments;
 }
+function getRouteStringParameterList(routeString) {
+    const routeParameterList = [];
+    const segments = parseRouteString(routeString);
+    segments.forEach((segment) => {
+        if (segment.param)
+            routeParameterList.push(segment.param);
+    });
+    return routeParameterList;
+}
 function getUrlFromRouteString(routeString) {
     if (isStaticRouteString(routeString)) {
         const url = routeString;

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

@@ -108,6 +108,10 @@ type PageContextBuiltInCommon<Data> = {
      * https://vike.dev/errors
      */
     errorWhileRendering?: unknown;
+    /**
+     * The page's unique identifier.
+     */
+    pageId: string | null;
     /** @experimental https://github.com/vikejs/vike/issues/1268 */
     from: From;
     /** @experimental https://github.com/vikejs/vike/issues/1268 */
@@ -120,7 +124,7 @@ type PageContextBuiltInCommon<Data> = {
     pageExports: Record<string, unknown>;
 };
 type PageContextBuiltInServer<Data> = PageContextBuiltInCommon<Data> & PageContextUrlServer;
-type PageContextBuiltInClientWithClientRouting<Data> = Partial<PageContextBuiltInCommon<Data>> & Pick<PageContextBuiltInCommon<Data>, 'Page' | 'routeParams' | 'pageExports' | 'config' | 'configEntries' | 'exports' | 'exportsAll' | 'abortReason' | 'data' | 'source' | 'sources' | 'from'> & {
+type PageContextBuiltInClientWithClientRouting<Data> = Partial<PageContextBuiltInCommon<Data>> & Pick<PageContextBuiltInCommon<Data>, 'Page' | 'routeParams' | 'pageExports' | 'config' | 'configEntries' | 'exports' | 'exportsAll' | 'abortReason' | 'data' | 'pageId' | 'source' | 'sources' | 'from'> & {
     /** Whether the current page is already rendered to HTML */
     isHydration: boolean;
     /**
@@ -130,7 +134,7 @@ type PageContextBuiltInClientWithClientRouting<Data> = Partial<PageContextBuiltI
      */
     isBackwardNavigation: boolean | null;
 } & PageContextUrlClient;
-type PageContextBuiltInClientWithServerRouting<Data> = Partial<PageContextBuiltInCommon<Data>> & Pick<PageContextBuiltInCommon<Data>, 'Page' | 'pageExports' | 'exports' | 'abortReason' | 'data'> & {
+type PageContextBuiltInClientWithServerRouting<Data> = Partial<PageContextBuiltInCommon<Data>> & Pick<PageContextBuiltInCommon<Data>, 'Page' | 'pageExports' | 'exports' | 'abortReason' | 'pageId' | 'data'> & {
     /**
      * Whether the current page is already rendered to HTML.
      *

package/dist/esm/types/index.d.ts

@@ -7,7 +7,7 @@ export type { ConfigVitePluginServerEntry } from '@brillout/vite-plugin-server-e
 export type { PageContextBuiltInServer } from '../shared/types.js';
 export type { PageContextBuiltInClientWithClientRouting } from '../shared/types.js';
 export type { PageContextBuiltInClientWithServerRouting } from '../shared/types.js';
-export type { Config, ConfigMeta as Meta, ImportString, DataAsync, DataSync, GuardAsync, GuardSync, OnBeforePrerenderStartAsync, OnBeforePrerenderStartSync, OnBeforeRenderAsync, OnBeforeRenderSync, OnBeforeRouteAsync, OnBeforeRouteSync, OnHydrationEndAsync, OnHydrationEndSync, OnPageTransitionEndAsync, OnPageTransitionEndSync, OnPageTransitionStartAsync, OnPageTransitionStartSync, OnPrerenderStartAsync, OnPrerenderStartSync, OnRenderClientAsync, OnRenderClientSync, OnRenderHtmlAsync, OnRenderHtmlSync, RouteAsync, RouteSync } from '../shared/page-configs/Config.js';
+export type { Config, ConfigMeta as Meta, ImportString, DataAsync, DataSync, GuardAsync, GuardSync, OnBeforePrerenderStartAsync, OnBeforePrerenderStartSync, OnBeforeRenderAsync, OnBeforeRenderSync, OnBeforeRouteAsync, OnBeforeRouteSync, OnHydrationEndAsync, OnHydrationEndSync, OnPageTransitionEndAsync, OnPageTransitionEndSync, OnPageTransitionStartAsync, OnPageTransitionStartSync, OnPrerenderStartAsync, OnPrerenderStartSync, OnRenderClientAsync, OnRenderClientSync, OnRenderHtmlAsync, OnRenderHtmlSync, RouteAsync, RouteSync, KeepScrollPosition } from '../shared/page-configs/Config.js';
 export type { ConfigEnv } from '../shared/page-configs/PageConfig.js';
 export type { ConfigDefinition, ConfigEffect } from '../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/configDefinitionsBuiltIn.js';
 export type { ConfigEntries } from '../shared/getPageFiles/getExports.js';

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

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.196";
+export declare const PROJECT_VERSION: "0.4.197-commit-f4d8658";

package/dist/esm/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.196';
+export const PROJECT_VERSION = '0.4.197-commit-f4d8658';

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

@@ -1,4 +1,5 @@
 export { isNpmPackageImport };
+export { isNpmPackageImport_unreliable };
 export { assertIsNpmPackageImport };
 export { isValidPathAlias };
 export { parse };
@@ -6,6 +7,7 @@ export { isDistinguishable };
 declare function isNpmPackageImport(str: string, { cannotBePathAlias }: {
     cannotBePathAlias: true;
 }): boolean;
+declare function isNpmPackageImport_unreliable(str: string): boolean;
 declare function assertIsNpmPackageImport(str: string): void;
 declare function isValidPathAlias(alias: string): boolean;
 declare function isDistinguishable(alias: string): boolean;

package/dist/esm/utils/isNpmPackage.js

@@ -1,4 +1,5 @@
 export { isNpmPackageImport };
+export { isNpmPackageImport_unreliable };
 export { assertIsNpmPackageImport };
 export { isValidPathAlias };
 /* Currently not used
@@ -15,6 +16,9 @@ assertIsNotBrowser();
 function isNpmPackageImport(str, { cannotBePathAlias }) {
     // We cannot distinguish path alises that look like npm package imports
     assert(cannotBePathAlias);
+    return isNpmPackageImport_unreliable(str);
+}
+function isNpmPackageImport_unreliable(str) {
     const res = parse(str);
     return res !== null;
 }

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

@@ -1,10 +1,10 @@
 export { isScriptFile };
-export { isJavaScriptFile };
+export { isPlainJavaScriptFile };
 export { isTemplateFile };
 export { scriptFileExtensions };
 export { scriptFileExtensionList };
 declare const scriptFileExtensionList: readonly [...string[], "jsx", "tsx", "cjsx", "ctsx", "mjsx", "mtsx", "vue", "svelte", "marko", "md", "mdx"];
 declare const scriptFileExtensions: string;
 declare function isScriptFile(filePath: string): boolean;
-declare function isJavaScriptFile(filePath: string): boolean;
+declare function isPlainJavaScriptFile(filePath: string): boolean;
 declare function isTemplateFile(filePath: string): boolean;