vike 0.4.196 → 0.4.197

package/dist/cjs/client/server-routing-runtime/onLoad.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onLoad = onLoad;
+const assertIsBrowser_js_1 = require("../../utils/assertIsBrowser.js");
+function onLoad() {
+    (0, assertIsBrowser_js_1.assertIsBrowser)();
+}

package/dist/cjs/client/server-routing-runtime/utils.js

@@ -0,0 +1,34 @@
+"use strict";
+// Utils needed by Server Routing.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// We assume all runtime entries will load this utils.ts file
+const onLoad_js_1 = require("./onLoad.js");
+(0, onLoad_js_1.onLoad)();
+__exportStar(require("../../utils/assert.js"), exports);
+__exportStar(require("../../utils/assertSingleInstance.js"), exports);
+__exportStar(require("../../shared/hooks/executeHook.js"), exports);
+__exportStar(require("../../utils/checkType.js"), exports); // Only used by Server Routing (not needed for Client Routing)
+__exportStar(require("../../utils/getCurrentUrl.js"), exports);
+__exportStar(require("../../utils/getGlobalObject.js"), exports);
+__exportStar(require("../../utils/hasProp.js"), exports);
+__exportStar(require("../../utils/isCallable.js"), exports);
+__exportStar(require("../../utils/isObject.js"), exports);
+__exportStar(require("../../utils/objectAssign.js"), exports);
+__exportStar(require("../../utils/parseUrl.js"), exports);
+__exportStar(require("../../utils/slice.js"), exports);
+__exportStar(require("../../utils/unique.js"), exports); // Only used by Server Routing (not needed for Client Routing)
+__exportStar(require("../../utils/getPropAccessNotation.js"), exports);

package/dist/cjs/client/shared/getPageContextProxyForUser.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPageContextProxyForUser = getPageContextProxyForUser;
+const utils_js_1 = require("../server-routing-runtime/utils.js");
+const notSerializable_js_1 = require("../../shared/notSerializable.js");
+const globalObject = (0, utils_js_1.getGlobalObject)('getPageContextProxyForUser.ts', {});
+/**
+ * Throw error when pageContext value isn't:
+ * - serializable, or
+ * - defined.
+ */
+function getPageContextProxyForUser(pageContext) {
+    (0, utils_js_1.assert)([true, false].includes(pageContext._hasPageContextFromServer));
+    (0, utils_js_1.assert)([true, false].includes(pageContext._hasPageContextFromClient));
+    return new Proxy(pageContext, {
+        get(_, prop) {
+            const val = pageContext[prop];
+            const propName = (0, utils_js_1.getPropAccessNotation)(prop);
+            (0, utils_js_1.assertUsage)(val !== notSerializable_js_1.notSerializable, `Can't access pageContext${propName} on the client side. Because it can't be serialized, see server logs.`);
+            passToClientHint(pageContext, prop, propName);
+            return val;
+        }
+    });
+}
+function passToClientHint(pageContext, prop, propName) {
+    if (handleVueReactivity(prop))
+        return;
+    // `prop in pageContext` is the trick we use to know the passToClient value on the client-side, as we set a value to all passToClient props, even `undefined` ones:
+    // ```html
+    // <script id="vike_pageContext" type="application/json">{"pageProps":"!undefined"}</script>
+    // ```
+    if (prop in pageContext)
+        return;
+    if (isWhitelisted(prop))
+        return;
+    // The trick described above (`prop in pageContext`) doesn't work if Vike doesn't fetch any pageContext from the server.
+    // - There would still be some value to show a warning, but it isn't worth it because of the confusion that the first recommendation (adding `prop` to `passToClient`) wouldn't actually remove the warning, and only the second recommendation (using `prop in pageContext` instead of `pageContext[prop]`) would work.
+    if (!pageContext._hasPageContextFromServer)
+        return;
+    const errMsg = `pageContext${propName} isn't defined on the client-side, see https://vike.dev/passToClient#error`;
+    if (
+    // TODO/next-major-release always make it an error.
+    // - Remove pageContext._hasPageContextFromClient logic (IIRC this is its only use case).
+    pageContext._hasPageContextFromClient) {
+        (0, utils_js_1.assertWarning)(false, errMsg, { onlyOnce: false, showStackTrace: true });
+    }
+    else {
+        (0, utils_js_1.assertUsage)(false, errMsg);
+    }
+}
+const WHITELIST = [
+    'then',
+    // Vue calls toJSON()
+    'toJSON'
+];
+function isWhitelisted(prop) {
+    if (WHITELIST.includes(prop))
+        return true;
+    if (typeof prop === 'symbol')
+        return true; // Vue tries to access some symbols
+    if (typeof prop !== 'string')
+        return true;
+    if (prop.startsWith('__v_'))
+        return true; // Vue internals upon `reactive(pageContext)`
+    return false;
+}
+// Handle Vue's reactivity.
+// When changing a reactive object:
+// - Vue tries to read its old value first. This triggers a `assertIsDefined()` failure if e.g. `pageContextReactive.routeParams = pageContextNew.routeParams` and `pageContextReactive` has no `routeParams`.
+// - Vue seems to read __v_raw before reading the property.
+function handleVueReactivity(prop) {
+    if (globalObject.prev === prop || globalObject.prev === '__v_raw')
+        return true;
+    globalObject.prev = prop;
+    window.setTimeout(() => {
+        globalObject.prev = undefined;
+    }, 0);
+    return false;
+}

package/dist/cjs/client/shared/preparePageContextForUserConsumptionClientSide.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preparePageContextForUserConsumptionClientSide = preparePageContextForUserConsumptionClientSide;
+const utils_js_1 = require("../server-routing-runtime/utils.js");
+const getPageContextProxyForUser_js_1 = require("./getPageContextProxyForUser.js");
+const preparePageContextForUserConsumption_js_1 = require("../../shared/preparePageContextForUserConsumption.js");
+function preparePageContextForUserConsumptionClientSide(pageContext, isClientRouting) {
+    if (isClientRouting) {
+        const pageContextTyped = pageContext;
+        (0, utils_js_1.assert)([true, false].includes(pageContextTyped.isHydration));
+        (0, utils_js_1.assert)([true, false, null].includes(pageContextTyped.isBackwardNavigation));
+    }
+    else {
+        const pageContextTyped = pageContext;
+        (0, utils_js_1.assert)(pageContextTyped.isHydration === true);
+        (0, utils_js_1.assert)(pageContextTyped.isBackwardNavigation === null);
+    }
+    const Page = pageContext.config.Page ||
+        // TODO/next-major-release: remove
+        pageContext.exports.Page;
+    (0, utils_js_1.objectAssign)(pageContext, { Page });
+    // TODO/next-major-release: remove
+    // - Requires https://github.com/vikejs/vike-vue/issues/198
+    // - Last time I tried to remove it (https://github.com/vikejs/vike/commit/705fd23598d9d69bf46a52c8550216cd7117ce71) the tests were failing as expected: only the Vue integrations that used shallowReactive() failed.
+    supportVueReactiviy(pageContext);
+    (0, preparePageContextForUserConsumption_js_1.preparePageContextForUserConsumption)(pageContext);
+    const pageContextProxy = (0, getPageContextProxyForUser_js_1.getPageContextProxyForUser)(pageContext);
+    return pageContextProxy;
+}
+// With Vue + Cient Routing, the `pageContext` is made reactive:
+// ```js
+// import { reactive } from 'vue'
+// // See /examples/vue-full/renderer/createVueApp.ts
+// const pageContextReactive = reactive(pageContext)
+// ```
+function supportVueReactiviy(pageContext) {
+    resolveGetters(pageContext);
+}
+// Remove propery descriptor getters because they break Vue's reactivity.
+// E.g. resolve the `pageContext.urlPathname` getter.
+function resolveGetters(pageContext) {
+    Object.entries(pageContext).forEach(([key, val]) => {
+        delete pageContext[key];
+        pageContext[key] = val;
+    });
+}

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

@@ -121,6 +121,9 @@ const configDefinitionsBuiltIn = {
     },
     require: {
         env: { config: true }
+    },
+    keepScrollPosition: {
+        env: { client: true }
     }
 };
 exports.configDefinitionsBuiltIn = configDefinitionsBuiltIn;

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

@@ -243,7 +243,7 @@ async function loadVikeConfig(userRootDir, outDirRoot, isDev, crawlWithGit) {
     const importedFilesLoaded = {};
     const { globalVikeConfig, pageConfigGlobal } = await getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importedFilesLoaded);
     const pageConfigs = await Promise.all((0, utils_js_1.objectEntries)(interfaceFilesByLocationId)
-        .filter(([_pageId, interfaceFiles]) => isDefiningPage(interfaceFiles))
+        .filter(([pageId, interfaceFiles]) => isDefiningPage(interfaceFiles))
         .map(async ([locationId]) => {
         const interfaceFilesRelevant = getInterfaceFilesRelevant(interfaceFilesByLocationId, locationId);
         const interfaceFilesRelevantList = Object.values(interfaceFilesRelevant).flat(1);

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

@@ -306,7 +306,7 @@ async function handlePagesWithStaticRoutes(prerenderContext, renderContext, doNo
         (0, utils_js_1.objectAssign)(pageContext, {
             _providedByHook: null,
             routeParams,
-            _pageId: pageId,
+            pageId: pageId,
             _debugRouteMatches: [
                 {
                     pageId,
@@ -469,8 +469,8 @@ async function routeAndPrerender(prerenderContext, concurrencyLimit, onComplete)
         const { urlOriginal } = pageContext;
         (0, utils_js_1.assert)(urlOriginal);
         const pageContextFromRoute = await (0, index_js_1.route)(pageContext);
-        (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageContextFromRoute, '_pageId', 'null') || (0, utils_js_1.hasProp)(pageContextFromRoute, '_pageId', 'string'));
-        if (pageContextFromRoute._pageId === null) {
+        (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageContextFromRoute, 'pageId', 'null') || (0, utils_js_1.hasProp)(pageContextFromRoute, 'pageId', 'string'));
+        if (pageContextFromRoute.pageId === null) {
             let hookName;
             let hookFilePath;
             if (pageContext._providedByHook) {
@@ -492,9 +492,9 @@ async function routeAndPrerender(prerenderContext, concurrencyLimit, onComplete)
                 return;
             }
         }
-        (0, utils_js_1.assert)(pageContextFromRoute._pageId);
+        (0, utils_js_1.assert)(pageContextFromRoute.pageId);
         (0, utils_js_1.objectAssign)(pageContext, pageContextFromRoute);
-        const { _pageId: pageId } = pageContext;
+        const { pageId: pageId } = pageContext;
         (0, utils_js_1.objectAssign)(pageContext, await (0, loadUserFilesServerSide_js_1.loadUserFilesServerSide)(pageContext));
         let usesClientRouter;
         {

package/dist/cjs/node/runtime/html/injectAssets/getHtmlTags.js

@@ -19,7 +19,7 @@ function getHtmlTags(pageContext, streamFromReactStreamingPackage, injectFilter,
     (0, utils_js_1.assert)([true, false].includes(pageContext._isHtmlOnly));
     const isHtmlOnly = pageContext._isHtmlOnly;
     const { isProduction } = (0, globalContext_js_1.getGlobalContext)();
-    const injectScriptsAt = getInjectScriptsAt(pageContext._pageId, pageContext._pageConfigs);
+    const injectScriptsAt = getInjectScriptsAt(pageContext.pageId, pageContext._pageConfigs);
     const injectFilterEntries = pageAssets
         .filter((asset) => {
         if (asset.isEntry && asset.assetType === 'script') {

package/dist/cjs/node/runtime/html/injectAssets/injectAssets__public.js

@@ -16,7 +16,7 @@ async function injectAssets__public(htmlString, pageContext) {
     (0, utils_js_1.assertUsage)((0, utils_js_1.hasProp)(pageContext, 'urlPathname', 'string'), errMsg('`pageContext.urlPathname` should be a string'), {
         showStackTrace: true
     });
-    (0, utils_js_1.assertUsage)((0, utils_js_1.hasProp)(pageContext, '_pageId', 'string'), errMsg('`pageContext._pageId` should be a string'), {
+    (0, utils_js_1.assertUsage)((0, utils_js_1.hasProp)(pageContext, 'pageId', 'string'), errMsg('`pageContext.pageId` should be a string'), {
         showStackTrace: true
     });
     (0, utils_js_1.assertUsage)((0, utils_js_1.hasProp)(pageContext, '__getPageAssets'), errMsg('`pageContext.__getPageAssets` is missing'), {

package/dist/cjs/node/runtime/html/serializePageContextClientSide.js

@@ -23,7 +23,7 @@ const PASS_TO_CLIENT = [
     '_abortCaller',
     */
     pageContextInitIsPassedToClient_js_1.pageContextInitIsPassedToClient,
-    '_pageId',
+    'pageId',
     'routeParams',
     'data' // for data() hook
 ];
@@ -100,7 +100,7 @@ function serialize(value, varName) {
 }
 function getPassToClient(pageContext) {
     let passToClient = [...pageContext._passToClient, ...PASS_TO_CLIENT];
-    if ((0, error_page_js_1.isErrorPage)(pageContext._pageId, pageContext._pageConfigs)) {
+    if ((0, error_page_js_1.isErrorPage)(pageContext.pageId, pageContext._pageConfigs)) {
         (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageContext, 'is404', 'boolean'));
         (0, addIs404ToPageProps_js_1.addIs404ToPageProps)(pageContext);
         passToClient.push(...PASS_TO_CLIENT_ERROR_PAGE);

package/dist/cjs/node/runtime/renderPage/createHttpResponse.js

@@ -14,7 +14,7 @@ const assertNoInfiniteHttpRedirect_js_1 = require("./createHttpResponse/assertNo
 async function createHttpResponsePage(htmlRender, renderHook, pageContext) {
     let statusCode = pageContext.abortStatusCode;
     if (!statusCode) {
-        const isError = !pageContext._pageId || (0, error_page_js_1.isErrorPage)(pageContext._pageId, pageContext._pageConfigs);
+        const isError = !pageContext.pageId || (0, error_page_js_1.isErrorPage)(pageContext.pageId, pageContext._pageConfigs);
         if (pageContext.errorWhileRendering) {
             (0, utils_js_1.assert)(isError);
         }
@@ -29,8 +29,8 @@ async function createHttpResponsePage(htmlRender, renderHook, pageContext) {
     }
     const earlyHints = (0, getEarlyHints_js_1.getEarlyHints)(await pageContext.__getPageAssets());
     const headers = [];
-    (0, utils_js_1.assert)(pageContext._pageId);
-    const cacheControl = (0, getCacheControl_js_1.getCacheControl)(pageContext._pageId, pageContext._pageConfigs);
+    (0, utils_js_1.assert)(pageContext.pageId);
+    const cacheControl = (0, getCacheControl_js_1.getCacheControl)(pageContext.pageId, pageContext._pageConfigs);
     if (cacheControl) {
         headers.push(['Cache-Control', cacheControl]);
     }

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

@@ -12,7 +12,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/cjs/node/runtime/renderPage/handleErrorWithoutErrorPage.js

@@ -11,7 +11,7 @@ const createHttpResponse_js_1 = require("./createHttpResponse.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 // When the user hasn't defined _error.page.js
 async function handleErrorWithoutErrorPage(pageContext) {
-    (0, utils_js_1.assert)(pageContext._pageId === null);
+    (0, utils_js_1.assert)(pageContext.pageId === null);
     (0, utils_js_1.assert)(pageContext.errorWhileRendering || pageContext.is404);
     {
         const isV1 = pageContext._pageConfigs.length > 0;

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

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

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

@@ -2,17 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.preparePageContextForUserConsumptionServerSide = preparePageContextForUserConsumptionServerSide;
 const utils_js_1 = require("../utils.js");
-const sortPageContext_js_1 = require("../../../shared/sortPageContext.js");
 const getPageContextUrlComputed_js_1 = require("../../../shared/getPageContextUrlComputed.js");
-const addIs404ToPageProps_js_1 = require("../../../shared/addIs404ToPageProps.js");
+const preparePageContextForUserConsumption_js_1 = require("../../../shared/preparePageContextForUserConsumption.js");
 function preparePageContextForUserConsumptionServerSide(pageContext) {
     (0, getPageContextUrlComputed_js_1.assertPageContextUrl)(pageContext);
     (0, utils_js_1.assert)((0, utils_js_1.isPlainObject)(pageContext.routeParams));
     (0, utils_js_1.assert)('Page' in pageContext);
-    (0, utils_js_1.assert)((0, utils_js_1.isObject)(pageContext.pageExports));
-    (0, utils_js_1.assert)((0, utils_js_1.isObject)(pageContext.exports));
-    (0, utils_js_1.assert)((0, utils_js_1.isObject)(pageContext.exportsAll));
     (0, utils_js_1.assert)(typeof pageContext.isClientSideNavigation === 'boolean');
-    (0, sortPageContext_js_1.sortPageContext)(pageContext);
-    (0, addIs404ToPageProps_js_1.addIs404ToPageProps)(pageContext);
+    (0, preparePageContextForUserConsumption_js_1.preparePageContextForUserConsumption)(pageContext);
 }

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

@@ -28,12 +28,12 @@ const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const isServerSideError_js_1 = require("../../../shared/misc/isServerSideError.js");
 const assertV1Design_js_1 = require("../../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`.
-    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageContext, '_pageId', 'string'));
+    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageContext, 'pageId', 'string'));
     const isError = pageContext.is404 || !!pageContext.errorWhileRendering;
-    (0, utils_js_1.assert)(isError === (pageContext._pageId === (0, error_page_js_1.getErrorPageId)(pageContext._pageFilesAll, pageContext._pageConfigs)));
+    (0, utils_js_1.assert)(isError === (pageContext.pageId === (0, error_page_js_1.getErrorPageId)(pageContext._pageFilesAll, pageContext._pageConfigs)));
     (0, utils_js_1.objectAssign)(pageContext, await (0, loadUserFilesServerSide_js_1.loadUserFilesServerSide)(pageContext));
     if (!isError) {
         await (0, executeGuardHook_js_1.executeGuardHook)(pageContext, (pageContext) => (0, preparePageContextForUserConsumptionServerSide_js_1.preparePageContextForUserConsumptionServerSide)(pageContext));
@@ -95,7 +95,7 @@ async function prerender404Page(renderContext, pageContextInit_) {
         return null;
     }
     const pageContext = {
-        _pageId: errorPageId,
+        pageId: errorPageId,
         _httpRequestId: null,
         _urlRewrite: null,
         is404: true,

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

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

package/dist/cjs/shared/addIs404ToPageProps.js

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

package/dist/cjs/shared/assertPageContextProvidedByUser.js

@@ -15,6 +15,6 @@ function assertPageContextProvidedByUser(pageContextProvidedByUser, { hookName,
     (0, utils_js_1.assertUsage)(!('_objectCreatedByVike' in pageContextProvidedByUser), `${errPrefix} shouldn't be the whole ${picocolors_1.default.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?
-    (0, utils_js_1.assertWarning)(!('_pageId' in pageContextProvidedByUser), `${errPrefix} sets ${picocolors_1.default.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 });
+    (0, utils_js_1.assertWarning)(!('pageId' in pageContextProvidedByUser), `${errPrefix} sets ${picocolors_1.default.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 });
     (0, utils_js_1.assertUsage)(!('is404' in pageContextProvidedByUser), `${errPrefix} sets ${picocolors_1.default.cyan('pageContext.is404')} which is forbidden, use ${picocolors_1.default.cyan('throw render()')} instead, see https://vike.dev/render`);
 }

package/dist/cjs/shared/preparePageContextForUserConsumption.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preparePageContextForUserConsumption = preparePageContextForUserConsumption;
+const utils_js_1 = require("./utils.js");
+const addIs404ToPageProps_js_1 = require("./addIs404ToPageProps.js");
+function preparePageContextForUserConsumption(pageContext) {
+    (0, utils_js_1.assert)(pageContext.pageId);
+    (0, utils_js_1.assert)('config' in pageContext);
+    (0, utils_js_1.assert)('configEntries' in pageContext);
+    (0, addIs404ToPageProps_js_1.addIs404ToPageProps)(pageContext);
+    // TODO/next-major-release: remove
+    if (!('_pageId' in pageContext)) {
+        Object.defineProperty(pageContext, '_pageId', {
+            get() {
+                (0, utils_js_1.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]) => (0, utils_js_1.compareString)(key1, key2)));
+    Object.defineProperties(pageContext, descriptors);
+}

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

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

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

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

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

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

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

@@ -8,7 +8,7 @@ exports.getUrlFromRouteString = getUrlFromRouteString;
 exports.isStaticRouteString = isStaticRouteString;
 exports.analyzeRouteString = analyzeRouteString;
 exports.assertRouteString = assertRouteString;
-exports.parseRouteString = parseRouteString;
+exports.getRouteStringParameterList = getRouteStringParameterList;
 const utils_js_1 = require("../utils.js");
 const utils_js_2 = require("./utils.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
@@ -101,6 +101,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/cjs/utils/PROJECT_VERSION.js

@@ -2,4 +2,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PROJECT_VERSION = void 0;
 // Automatically updated by @brillout/release-me
-exports.PROJECT_VERSION = '0.4.196';
+exports.PROJECT_VERSION = '0.4.197';

package/dist/esm/client/client-routing-runtime/getPageContextFromHooks.d.ts

@@ -10,7 +10,7 @@ type PageContext = {
     _pageConfigs: PageConfigRuntime[];
 };
 type PageContextSerialized = {
-    _pageId: string;
+    pageId: string;
     _hasPageContextFromServer: true;
 };
 declare function getPageContextFromHooks_serialized(): PageContextSerialized & {
@@ -22,13 +22,13 @@ declare function getPageContextFromHooks_isHydration(pageContext: PageContextSer
     _hasPageContextFromServer: true;
 }>;
 declare function getPageContextFromHooks_isNotHydration(pageContext: {
-    _pageId: string;
+    pageId: string;
 } & PageContext & PageContextExports, isErrorPage: boolean): Promise<{
     is404ServerSideRouted: boolean;
     pageContextAugmented?: undefined;
 } | {
     pageContextAugmented: {
-        _pageId: string;
+        pageId: string;
     } & PageContext & PageContextExports & {
         isHydration: false;
         _hasPageContextFromClient: boolean;