vike 0.4.196 → 0.4.197-commit-9db6c02

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/page-configs/serialize/serializeConfigValues.js

@@ -7,7 +7,7 @@ exports.serializeConfigValues = serializeConfigValues;
 const assertIsNotProductionRuntime_js_1 = require("../../../utils/assertIsNotProductionRuntime.js");
 const utils_js_1 = require("../../../node/plugin/utils.js");
 const addImportStatement_js_1 = require("../../../node/plugin/plugins/importUserCode/addImportStatement.js");
-const transformFileImports_js_1 = require("../../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/transformFileImports.js");
+const transformPointerImports_js_1 = require("../../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/transformPointerImports.js");
 const helpers_js_1 = require("../helpers.js");
 const stringify_1 = require("@brillout/json-serializer/stringify");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
@@ -164,7 +164,7 @@ function valueToJson(value, configName, definedAtData, importStatements) {
             //   - https://github.com/vikejs/vike-react/pull/113
             replacer(_, value) {
                 if (typeof value === 'string') {
-                    const importData = (0, transformFileImports_js_1.parsePointerImportData)(value);
+                    const importData = (0, transformPointerImports_js_1.parsePointerImportData)(value);
                     if (importData) {
                         const { importName } = (0, addImportStatement_js_1.addImportStatement)(importStatements, importData.importPath, importData.exportName);
                         const replacement = [REPLACE_ME_BEFORE, importName, REPLACE_ME_AFTER].join('');

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-commit-9db6c02';

package/dist/cjs/utils/isNpmPackage.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isNpmPackageImport = isNpmPackageImport;
+exports.isNpmPackageImport_unreliable = isNpmPackageImport_unreliable;
 exports.assertIsNpmPackageImport = assertIsNpmPackageImport;
 exports.isValidPathAlias = isValidPathAlias;
 exports.parse = parse;
@@ -11,6 +12,9 @@ const assertIsNotBrowser_js_1 = require("./assertIsNotBrowser.js");
 function isNpmPackageImport(str, { cannotBePathAlias }) {
     // We cannot distinguish path alises that look like npm package imports
     (0, assert_js_1.assert)(cannotBePathAlias);
+    return isNpmPackageImport_unreliable(str);
+}
+function isNpmPackageImport_unreliable(str) {
     const res = parse(str);
     return res !== null;
 }

package/dist/cjs/utils/isScriptFile.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.scriptFileExtensionList = exports.scriptFileExtensions = void 0;
 exports.isScriptFile = isScriptFile;
-exports.isJavaScriptFile = isJavaScriptFile;
+exports.isPlainJavaScriptFile = isPlainJavaScriptFile;
 exports.isTemplateFile = isTemplateFile;
 const assert_js_1 = require("./assert.js");
 // We can't use a RegExp:
@@ -49,11 +49,11 @@ const scriptFileExtensions = '(' + scriptFileExtensionList.join('|') + ')';
 exports.scriptFileExtensions = scriptFileExtensions;
 function isScriptFile(filePath) {
     const yes = scriptFileExtensionList.some((ext) => filePath.endsWith('.' + ext));
-    if (isJavaScriptFile(filePath))
+    if (isPlainJavaScriptFile(filePath))
         (0, assert_js_1.assert)(yes);
     return yes;
 }
-function isJavaScriptFile(filePath) {
+function isPlainJavaScriptFile(filePath) {
     const yes1 = /\.(c|m)?(j|t)s$/.test(filePath);
     const yes2 = extJavaScript.some((ext) => filePath.endsWith('.' + ext));
     (0, assert_js_1.assert)(yes1 === yes2);

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

@@ -1,7 +1,7 @@
 import { assertClientRouting } from '../../utils/assertRoutingType.js';
 assertClientRouting();
 import './pageFiles';
-import { installClientRouter } from './installClientRouter.js';
+import { initClientRouter } from './initClientRouter.js';
 import { assertSingleInstance_onClientEntryClientRouting } from './utils.js';
 import { removeFoucBuster } from '../shared/removeFoucBuster.js';
 // @ts-ignore Since dist/cjs/client/ is never used, we can ignore this error.
@@ -9,4 +9,4 @@ const isProd = import.meta.env.PROD;
 assertSingleInstance_onClientEntryClientRouting(isProd);
 if (import.meta.env.DEV)
     removeFoucBuster();
-installClientRouter();
+initClientRouter();

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

@@ -0,0 +1,10 @@
+export { setPageContextCurrent };
+export { getPageContextCurrent };
+export { getPageContextCurrentAsync };
+import type { PageContextExports } from '../../shared/getPageFiles.js';
+type PageContextCurrent = PageContextExports & {
+    urlPathname: string;
+};
+declare function getPageContextCurrent(): null | PageContextCurrent;
+declare function getPageContextCurrentAsync(): Promise<PageContextCurrent>;
+declare function setPageContextCurrent(pageContextCurrent: PageContextCurrent): void;

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

@@ -0,0 +1,25 @@
+export { setPageContextCurrent };
+export { getPageContextCurrent };
+export { getPageContextCurrentAsync };
+import { genPromise, getGlobalObject } from './utils.js';
+const globalObject = getGlobalObject('getPageContextCurrent.ts', (() => {
+    const { promise: pageContextCurrentPromise, resolve: pageContextCurrentPromiseResolve } = genPromise();
+    return {
+        pageContextCurrent: null,
+        pageContextCurrentPromise,
+        pageContextCurrentPromiseResolve
+    };
+})());
+function getPageContextCurrent() {
+    const { pageContextCurrent } = globalObject;
+    return pageContextCurrent;
+}
+// TODO/pageContext-prefetch: I think we can remove this? Once we use Vike's default if pageContextCurrent isn't defined yet.
+async function getPageContextCurrentAsync() {
+    const pageContextCurrent = await globalObject.pageContextCurrentPromise;
+    return pageContextCurrent;
+}
+function setPageContextCurrent(pageContextCurrent) {
+    globalObject.pageContextCurrent = pageContextCurrent;
+    globalObject.pageContextCurrentPromiseResolve(pageContextCurrent);
+}

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

@@ -1,6 +1,10 @@
 export { getPageContextFromHooks_isHydration };
-export { getPageContextFromHooks_isNotHydration };
 export { getPageContextFromHooks_serialized };
+export { getPageContextFromServerHooks };
+export { getPageContextFromClientHooks };
+export { setPageContextInitIsPassedToClient };
+export type { PageContextFromServerHooks };
+export type { PageContextFromClientHooks };
 import type { PageContextExports, PageFile } from '../../shared/getPageFiles.js';
 import type { PageConfigRuntime } from '../../shared/page-configs/PageConfig.js';
 type PageContext = {
@@ -10,30 +14,36 @@ type PageContext = {
     _pageConfigs: PageConfigRuntime[];
 };
 type PageContextSerialized = {
-    _pageId: string;
+    pageId: string;
     _hasPageContextFromServer: true;
 };
 declare function getPageContextFromHooks_serialized(): PageContextSerialized & {
     routeParams: Record<string, string>;
 };
-declare function getPageContextFromHooks_isHydration(pageContext: PageContextSerialized & PageContext & PageContextExports): Promise<PageContextSerialized & PageContext & PageContextExports & {
-    isHydration: true;
-    _hasPageContextFromClient: false;
+declare function getPageContextFromHooks_isHydration(pageContext: PageContextSerialized & PageContext & PageContextExports & {
+    _hasPageContextFromServer: true;
+}): Promise<PageContextSerialized & PageContext & PageContextExports & {
     _hasPageContextFromServer: true;
+} & {
+    isHydration: true;
+    _hasPageContextFromClient: boolean;
 }>;
-declare function getPageContextFromHooks_isNotHydration(pageContext: {
-    _pageId: string;
-} & PageContext & PageContextExports, isErrorPage: boolean): Promise<{
-    is404ServerSideRouted: boolean;
-    pageContextAugmented?: undefined;
+type PageContextFromServerHooks = {
+    _hasPageContextFromServer: boolean;
+};
+declare function getPageContextFromServerHooks(pageContext: {
+    pageId: string;
+} & PageContext, isErrorPage: boolean): Promise<{
+    is404ServerSideRouted: true;
 } | {
-    pageContextAugmented: {
-        _pageId: string;
-    } & PageContext & PageContextExports & {
-        isHydration: false;
-        _hasPageContextFromClient: boolean;
-    } & {
-        _hasPageContextFromServer: boolean;
-    };
     is404ServerSideRouted?: undefined;
+    pageContextFromServerHooks: PageContextFromServerHooks;
 }>;
+type PageContextFromClientHooks = {
+    _hasPageContextFromClient: boolean;
+};
+declare function getPageContextFromClientHooks(pageContext: {
+    pageId: string;
+    _hasPageContextFromServer: boolean;
+} & PageContext & PageContextExports, isErrorPage: boolean): Promise<PageContextFromClientHooks>;
+declare function setPageContextInitIsPassedToClient(pageContext: Record<string, unknown>): void;