vike 0.4.180-commit-648cd01 → 0.4.181

package/dist/cjs/utils/projectInfo.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PROJECT_VERSION = exports.projectInfo = void 0;
-const PROJECT_VERSION = '0.4.180-commit-648cd01';
+const PROJECT_VERSION = '0.4.181';
 exports.PROJECT_VERSION = PROJECT_VERSION;
 const projectInfo = {
     projectName: 'Vike',

package/dist/cjs/utils/redirectHard.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.redirectHard = void 0;
+function redirectHard(url) {
+    window.location.href = url;
+}
+exports.redirectHard = redirectHard;

package/dist/cjs/utils/urlToFile.js

@@ -5,7 +5,7 @@ const assert_js_1 = require("./assert.js");
 const parseUrl_js_1 = require("./parseUrl.js");
 const slice_js_1 = require("./slice.js");
 // - When doing a `.pageContext.json` HTTP request, the base URL should be preserved. (The server-side will handle the base URL.)
-// - While prerendering there is no base URL
+// - While pre-rendering there is no base URL
 const baseServer = '/';
 exports.baseServer = baseServer;
 function urlToFile(url, fileExtension, doNotCreateExtraDirectory) {

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

@@ -13,7 +13,7 @@ declare function createPageContext(urlOriginal: string): Promise<{
     _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
     _isPageContextObject: boolean;
 } & {
-    urlParsed: import("../../shared/getPageContextUrlComputed.js").Url;
+    urlParsed: import("./utils.js").UrlPublic;
     urlPathname: string;
     url: string;
 }>;

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

@@ -1,7 +1,7 @@
 export { getPageContextFromHooks_isHydration };
 export { getPageContextFromHooks_isNotHydration };
 export { getPageContextFromHooks_serialized };
-import { assert, assertUsage, hasProp, objectAssign, getProjectError, serverSideRouteTo, executeHook, isObject, getGlobalObject } from './utils.js';
+import { assert, assertUsage, hasProp, objectAssign, getProjectError, redirectHard, executeHook, isObject, getGlobalObject } from './utils.js';
 import { parse } from '@brillout/json-serializer/parse';
 import { getPageContextSerializedInHtml } from '../shared/getPageContextSerializedInHtml.js';
 import { analyzePageServerSide } from '../../shared/getPageFiles/analyzePageServerSide.js';
@@ -208,7 +208,7 @@ async function fetchPageContextFromServer(pageContext) {
         const isCorrect = contentType && contentType.includes(contentTypeCorrect);
         // Static hosts + page doesn't exist
         if (!isCorrect && response.status === 404) {
-            serverSideRouteTo(pageContext.urlOriginal);
+            redirectHard(pageContext.urlOriginal);
             return { is404ServerSideRouted: true };
         }
         assertUsage(isCorrect, `Wrong Content-Type for ${pageContextUrl}: it should be ${contentTypeCorrect} but it's ${contentType} instead. Make sure to properly use pageContext.httpResponse.headers, see https://vike.dev/renderPage`);

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

@@ -1,7 +1,7 @@
 export { navigate };
 export { reload };
 import { renderPageClientSide } from './renderPageClientSide.js';
-import { assertClientRouting, getCurrentUrl } from './utils.js';
+import { assertClientRouting, assertUsageUrlPathname, getCurrentUrl } from './utils.js';
 assertClientRouting();
 /** Programmatically navigate to a new page.
  *
@@ -12,6 +12,7 @@ assertClientRouting();
  * @param overwriteLastHistoryEntry - Don't create a new entry in the browser's history, instead let the new URL replace the current URL. (This effectively removes the current URL from the browser history).
  */
 async function navigate(url, { keepScrollPosition = false, overwriteLastHistoryEntry = false } = {}) {
+    assertUsageUrlPathname(url, '[navigate(url)] url');
     const scrollTarget = { preserveScroll: keepScrollPosition };
     await renderPageClientSide({
         scrollTarget,

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

@@ -1,6 +1,6 @@
 export { prefetch };
 export { addLinkPrefetchHandlers };
-import { assert, assertClientRouting, assertUsage, assertWarning, checkIfClientRouting, getGlobalObject, isExternalLink } from './utils.js';
+import { assert, assertClientRouting, assertUsage, assertUsageUrlPathname, assertWarning, checkIfClientRouting, getGlobalObject } from './utils.js';
 import { isErrorFetchingStaticAssets, loadUserFilesClientSide } from '../shared/loadUserFilesClientSide.js';
 import { skipLink } from './skipLink.js';
 import { getPrefetchSettings } from './prefetch/getPrefetchSettings.js';
@@ -10,6 +10,7 @@ import { isClientSideRoutable } from './isClientSideRoutable.js';
 import { createPageContext } from './createPageContext.js';
 import { route } from '../../shared/route/index.js';
 import { noRouteMatch } from '../../shared/route/noRouteMatch.js';
+import pc from '@brillout/picocolors';
 assertClientRouting();
 const globalObject = getGlobalObject('prefetch.ts', { linkPrefetchHandlerAdded: new WeakMap() });
 async function prefetchAssets(pageId, pageContext) {
@@ -36,8 +37,8 @@ async function prefetch(url) {
     assertUsage(checkIfClientRouting(), 'prefetch() only works with Client Routing, see https://vike.dev/prefetch', {
         showStackTrace: true
     });
-    const errPrefix = `Cannot prefetch URL ${url} because it`;
-    assertUsage(!isExternalLink(url), `${errPrefix} lives on another domain`, { showStackTrace: true });
+    const errPrefix = '[prefetch(url)] url';
+    assertUsageUrlPathname(url, errPrefix);
     if (isAlreadyPrefetched(url))
         return;
     markAsAlreadyPrefetched(url);
@@ -52,7 +53,7 @@ async function prefetch(url) {
     }
     const pageId = pageContextFromRoute._pageId;
     if (!pageId) {
-        assertWarning(false, `${errPrefix} ${noRouteMatch}`, {
+        assertWarning(false, `${errPrefix} ${pc.string(url)} ${noRouteMatch}`, {
             showStackTrace: true,
             onlyOnce: false
         });

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

@@ -1,7 +1,7 @@
 export { renderPageClientSide };
 export { getRenderCount };
 export { disableClientRouting };
-import { assert, getCurrentUrl, isSameErrorMessage, objectAssign, serverSideRouteTo, getGlobalObject, executeHook, hasProp, augmentType } from './utils.js';
+import { assert, getCurrentUrl, isSameErrorMessage, objectAssign, redirectHard, getGlobalObject, executeHook, hasProp, augmentType } from './utils.js';
 import { getPageContextFromHooks_isHydration, getPageContextFromHooks_isNotHydration, getPageContextFromHooks_serialized } from './getPageContextFromHooks.js';
 import { createPageContext } from './createPageContext.js';
 import { addLinkPrefetchHandlers } from './prefetch.js';
@@ -25,7 +25,7 @@ async function renderPageClientSide(renderArgs) {
     assert(isClientSideNavigation === !isHydrationRender); // isHydrationRender === (renderNumber === 1)
     assertNoInfiniteAbortLoop(pageContextsFromRewrite.length, redirectCount);
     if (globalObject.clientRoutingIsDisabled) {
-        serverSideRouteTo(urlOriginal);
+        redirectHard(urlOriginal);
         return;
     }
     await renderPageNominal();
@@ -89,7 +89,7 @@ async function renderPageClientSide(renderArgs) {
                     return;
             }
             if (!isClientRoutable) {
-                serverSideRouteTo(urlOriginal);
+                redirectHard(urlOriginal);
                 return;
             }
             assert(hasProp(pageContextFromRoute, '_pageId', 'string')); // Help TS
@@ -183,7 +183,7 @@ async function renderPageClientSide(renderArgs) {
                 /* When we can't render the error page, we prefer showing a blank page over letting the server-side try because otherwise:
                    - We risk running into an infinite loop of reloads which would overload the server.
                    - An infinite reloading page is a even worse UX than a blank page.
-                serverSideRouteTo(urlOriginal)
+                redirectHard(urlOriginal)
                 */
                 console.error(err);
             }
@@ -228,9 +228,9 @@ async function renderPageClientSide(renderArgs) {
                 // throw redirect('/some-url')
                 if (pageContextAbort._urlRedirect) {
                     const urlRedirect = pageContextAbort._urlRedirect.url;
-                    if (urlRedirect.startsWith('http')) {
+                    if (!urlRedirect.startsWith('/')) {
                         // External redirection
-                        window.location.href = urlRedirect;
+                        redirectHard(urlRedirect);
                         return;
                     }
                     else {
@@ -408,7 +408,7 @@ function handleErrorFetchingStaticAssets(err, pageContext, isHydrationRender) {
     else {
         disableClientRouting(err, true);
     }
-    serverSideRouteTo(pageContext.urlOriginal);
+    redirectHard(pageContext.urlOriginal);
     return true;
 }
 function disableClientRouting(err, log) {

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

@@ -1,30 +1,19 @@
 export { skipLink };
 import { getBaseServer } from './getBaseServer.js';
-import { assert, parseUrl, isBaseServer, isParsable, isExternalLink } from './utils.js';
+import { assert, parseUrl, isBaseServer, isUrl, isUrlExternal } from './utils.js';
 function skipLink(linkTag) {
     const url = linkTag.getAttribute('href');
-    if (url === null)
-        return true;
-    if (url === '')
-        return true;
-    if (isExternalLink(url))
-        return true;
-    if (isNewTabLink(linkTag))
-        return true;
-    if (isHashUrl(url))
-        return true;
-    if (!hasBaseServer(url)) {
-        return true;
-    }
-    if (!isParsable(url)) {
-        return true;
-    }
-    // Purposely last because disableAutomaticLinkInterception will be removed in the major release
-    if (!isVikeLink(linkTag))
-        return true;
-    return false;
+    return (url === null ||
+        !isUrl(url) ||
+        url === '' ||
+        isUrlExternal(url) ||
+        isHashUrl(url) ||
+        isNewTabLink(linkTag) ||
+        !hasBaseServer(url) ||
+        // Purposely last because disableAutomaticLinkInterception will be removed in the next major release
+        !isVikeLink(linkTag));
 }
-// TODO/v1-release: remove this in favor of synchronously checking whether URL matches the route of a page (possible since Async Route Functions will be deprecated)
+// TODO/next-major-release: remove this in favor of synchronously checking whether URL matches the route of a page (possible since Async Route Functions will be deprecated)
 function isVikeLink(linkTag) {
     const disableAutomaticLinkInterception = isDisableAutomaticLinkInterception();
     if (!disableAutomaticLinkInterception) {

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

@@ -15,11 +15,10 @@ export * from '../../utils/objectAssign.js';
 export * from '../../utils/parseUrl.js';
 export * from '../../utils/projectInfo.js';
 export * from '../../utils/PromiseType.js';
-export * from '../../utils/serverSideRouteTo.js';
+export * from '../../utils/redirectHard.js';
 export * from '../../utils/sleep.js';
 export * from '../../utils/slice.js';
 export * from '../../utils/throttle.js';
 export * from '../../utils/assertRoutingType.js';
 export * from '../../utils/onPageVisibilityChange.js';
-export * from '../../utils/isExternalLink.js';
 export * from '../../utils/augmentType.js';

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

@@ -21,11 +21,10 @@ export * from '../../utils/objectAssign.js';
 export * from '../../utils/parseUrl.js';
 export * from '../../utils/projectInfo.js';
 export * from '../../utils/PromiseType.js';
-export * from '../../utils/serverSideRouteTo.js';
+export * from '../../utils/redirectHard.js';
 export * from '../../utils/sleep.js';
 export * from '../../utils/slice.js';
 export * from '../../utils/throttle.js';
 export * from '../../utils/assertRoutingType.js';
 export * from '../../utils/onPageVisibilityChange.js';
-export * from '../../utils/isExternalLink.js';
 export * from '../../utils/augmentType.js';

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

@@ -1,11 +1,11 @@
 export { assertNoInfiniteHttpRedirect };
-import { assert, assertUsage, getGlobalObject, isUriWithProtocol } from '../../utils.js';
+import { assert, assertUsage, getGlobalObject } from '../../utils.js';
 import pc from '@brillout/picocolors';
 const globalObject = getGlobalObject('assertNoInfiniteHttpRedirect.ts', {
     redirectGraph: {}
 });
 function assertNoInfiniteHttpRedirect(urlRedirectTarget, urlLogical) {
-    if (isUriWithProtocol(urlRedirectTarget)) {
+    if (!urlRedirectTarget.startsWith('/')) {
         // We assume that urlRedirectTarget points to an origin that is external (not the same origin), and we can therefore assume that the app doesn't define an infinite loop (in itself).
         //  - There isn't a reliable way to check whether the redirect points to an external origin or the same origin. For same origins, we assume/hope the user to pass the URL without origin.
         //    ```js
@@ -14,7 +14,6 @@ function assertNoInfiniteHttpRedirect(urlRedirectTarget, urlLogical) {
         //    ```
         return;
     }
-    assert(urlRedirectTarget.startsWith('/'));
     assert(urlLogical.startsWith('/'));
     const graph = copy(globalObject.redirectGraph);
     graph[urlRedirectTarget] ?? (graph[urlRedirectTarget] = new Set());

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

@@ -60,7 +60,7 @@ declare function prerenderPage(pageContext: PageContextInitEnhanced & PageFiles
         _urlHandler: ((url: string) => string) | null;
         isClientSideNavigation: boolean;
     } & {
-        urlParsed: import("../../../shared/getPageContextUrlComputed.js").Url;
+        urlParsed: import("../utils.js").UrlPublic;
         urlPathname: string;
         url: string;
     } & {
@@ -111,7 +111,7 @@ declare function prerenderPage(pageContext: PageContextInitEnhanced & PageFiles
         _urlHandler: ((url: string) => string) | null;
         isClientSideNavigation: boolean;
     } & {
-        urlParsed: import("../../../shared/getPageContextUrlComputed.js").Url;
+        urlParsed: import("../utils.js").UrlPublic;
         urlPathname: string;
         url: string;
     } & {
@@ -163,7 +163,7 @@ declare function prerender404Page(renderContext: RenderContext, pageContextInit_
         _urlHandler: ((url: string) => string) | null;
         isClientSideNavigation: boolean;
     } & {
-        urlParsed: import("../../../shared/getPageContextUrlComputed.js").Url;
+        urlParsed: import("../utils.js").UrlPublic;
         urlPathname: string;
         url: string;
     } & {
@@ -214,7 +214,7 @@ declare function prerender404Page(renderContext: RenderContext, pageContextInit_
         _urlHandler: ((url: string) => string) | null;
         isClientSideNavigation: boolean;
     } & {
-        urlParsed: import("../../../shared/getPageContextUrlComputed.js").Url;
+        urlParsed: import("../utils.js").UrlPublic;
         urlPathname: string;
         url: string;
     } & {
@@ -274,7 +274,7 @@ declare function getPageContextInitEnhanced(pageContextInit: {
     _urlHandler: ((url: string) => string) | null;
     isClientSideNavigation: boolean;
 } & {
-    urlParsed: import("../../../shared/getPageContextUrlComputed.js").Url;
+    urlParsed: import("../utils.js").UrlPublic;
     urlPathname: string;
     url: string;
 } & {

package/dist/esm/{shared/route → node/runtime/renderPage}/resolveRedirects.js

@@ -1,13 +1,13 @@
 export { resolveRedirects };
 // For ./resolveRedirects.spec.ts
 export { resolveRouteStringRedirect };
-import { assertIsNotBrowser } from '../../utils/assertIsNotBrowser.js';
-import { assert, assertUsage, isUriWithProtocol } from '../utils.js';
-import { resolveUrlPathname } from './resolveUrlPathname.js';
-import { assertRouteString, resolveRouteString } from './resolveRouteString.js';
+import { assertIsNotBrowser } from '../../../utils/assertIsNotBrowser.js';
+import { assert, assertUsage, assertUsageUrlRedirectTarget, isUrlRedirectTarget } from '../../../shared/utils.js';
+import { resolveUrlPathname } from '../../../shared/route/resolveUrlPathname.js';
+import { assertRouteString, resolveRouteString } from '../../../shared/route/resolveRouteString.js';
 import pc from '@brillout/picocolors';
 assertIsNotBrowser(); // Don't bloat the client
-// TODO/v1-release: update
+// TODO/next-major-release: update
 const configSrc = '[vite.config.js > vike({ redirects })]';
 function resolveRedirects(redirects, urlPathname) {
     for (const [urlSource, urlTarget] of Object.entries(redirects)) {
@@ -19,10 +19,8 @@ function resolveRedirects(redirects, urlPathname) {
 }
 function resolveRouteStringRedirect(urlSource, urlTarget, urlPathname) {
     assertRouteString(urlSource, `${configSrc} Invalid`);
-    assertUsage(urlTarget.startsWith('/') ||
-        // Is allowing any protocol a safety issue? https://github.com/vikejs/vike/pull/1292#issuecomment-1828043917
-        isUriWithProtocol(urlTarget) ||
-        urlTarget === '*', `${configSrc} Invalid redirection target URL ${pc.cyan(urlTarget)}: the target URL should start with ${pc.cyan('/')}, a valid protocol (${pc.cyan('https:')}, ${pc.cyan('http:')}, ${pc.cyan('mailto:')}, ${pc.cyan('ipfs:')}, ${pc.cyan('magnet:')}, ...), or be ${pc.cyan('*')}`);
+    // Is allowing any protocol a safety issue? https://github.com/vikejs/vike/pull/1292#issuecomment-1828043917
+    assertUsageUrlRedirectTarget(urlTarget, `${configSrc} The URL redirection target`, true);
     assertParams(urlSource, urlTarget);
     const match = resolveRouteString(urlSource, urlPathname);
     if (!match)
@@ -30,7 +28,7 @@ function resolveRouteStringRedirect(urlSource, urlTarget, urlPathname) {
     const urlResolved = resolveUrlPathname(urlTarget, match.routeParams);
     if (urlResolved === urlPathname)
         return null;
-    assert(urlResolved.startsWith('/') || isUriWithProtocol(urlResolved));
+    assert(isUrlRedirectTarget(urlResolved));
     return urlResolved;
 }
 function assertParams(urlSource, urlTarget) {
@@ -38,7 +36,7 @@ function assertParams(urlSource, urlTarget) {
     routeSegments.forEach((routeSegment) => {
         if (routeSegment.startsWith('@') || routeSegment.startsWith('*')) {
             const segments = urlSource.split('/');
-            assertUsage(segments.includes(routeSegment), `${configSrc} The redirection source URL ${pc.cyan(urlSource)} is missing the URL parameter ${pc.cyan(routeSegment)} used by the redirection target URL ${pc.cyan(urlTarget)}`);
+            assertUsage(segments.includes(routeSegment), `${configSrc} The redirection source URL ${pc.string(urlSource)} is missing the URL parameter ${pc.string(routeSegment)} used by the redirection target URL ${pc.string(urlTarget)}`);
         }
     });
 }

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

@@ -1,7 +1,7 @@
 export { renderPage };
 export { renderPage_addWrapper };
 import { HttpResponse } from './renderPage/createHttpResponseObject.js';
-import type { PageContextBuiltInServer } from '../../types/index.js';
+import type { PageContextServer } from '../../types/index.js';
 declare let renderPage_wrapper: <PageContext>(_httpRequestId: number, ret: () => Promise<PageContext>) => Promise<{
     pageContextReturn: Awaited<PageContext>;
 }>;
@@ -13,4 +13,4 @@ declare function renderPage<PageContextUserAdded extends {}, PageContextInit ext
     urlOriginal: string;
 }>(pageContextInit: PageContextInit): Promise<PageContextInit & {
     httpResponse: HttpResponse | null;
-} & Partial<PageContextBuiltInServer & PageContextUserAdded>>;
+} & Partial<PageContextServer & PageContextUserAdded>>;

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

@@ -2,7 +2,7 @@ export { renderPage };
 export { renderPage_addWrapper };
 import { getRenderContext, getPageContextInitEnhanced, renderPageAlreadyRouted } from './renderPage/renderPageAlreadyRouted.js';
 import { route } from '../../shared/route/index.js';
-import { assert, hasProp, objectAssign, isParsable, parseUrl, assertEnv, assertWarning, getGlobalObject, checkType, assertUsage, normalizeUrlPathname, removeBaseServer, modifyUrlPathname, prependBase, removeUrlOrigin, addUrlOrigin, createUrlFromComponents, isUriWithProtocol } from './utils.js';
+import { assert, hasProp, objectAssign, isUrl, parseUrl, assertEnv, assertWarning, getGlobalObject, checkType, assertUsage, normalizeUrlPathname, removeBaseServer, modifyUrlPathname, prependBase, removeUrlOrigin, addUrlOrigin, createUrlFromComponents, isUri } from './utils.js';
 import { assertNoInfiniteAbortLoop, getPageContextFromAllRewrites, isAbortError, logAbortErrorHandled } from '../../shared/route/abort.js';
 import { getGlobalContext, initGlobalContext } from './globalContext.js';
 import { handlePageContextRequestUrl } from './renderPage/handlePageContextRequestUrl.js';
@@ -17,7 +17,7 @@ import { serializePageContextAbort, serializePageContextClientSide } from './htm
 import { getErrorPageId } from '../../shared/error-page.js';
 import { handleErrorWithoutErrorPage } from './renderPage/handleErrorWithoutErrorPage.js';
 import { loadUserFilesServerSide } from './renderPage/loadUserFilesServerSide.js';
-import { resolveRedirects } from '../../shared/route/resolveRedirects.js';
+import { resolveRedirects } from './renderPage/resolveRedirects.js';
 const globalObject = getGlobalObject('runtime/renderPage.ts', {
     httpRequestsCount: 0,
     pendingRequestsCount: 0
@@ -326,12 +326,9 @@ function getRequestId() {
     return httpRequestId;
 }
 function isIgnoredUrl(urlOriginal) {
-    const isViteClientRequest = urlOriginal.endsWith('/@vite/client') || urlOriginal.startsWith('/@fs/');
-    assertWarning(!isViteClientRequest, `The vike middleware renderPage() was called with the URL ${urlOriginal} which is unexpected because the HTTP request should have already been handled by Vite's development middleware. Make sure to 1. install Vite's development middleware and 2. add Vite's middleware *before* Vike's middleware, see https://vike.dev/renderPage`, { onlyOnce: true });
-    return (urlOriginal.endsWith('/__vite_ping') ||
-        urlOriginal.endsWith('/favicon.ico') ||
-        !isParsable(urlOriginal) ||
-        isViteClientRequest);
+    const isViteRequest = urlOriginal.endsWith('/@vite/client') || urlOriginal.startsWith('/@fs/');
+    assertWarning(!isViteRequest, `The vike middleware renderPage() was called with the URL ${urlOriginal} which is unexpected because the HTTP request should have already been handled by Vite's development middleware. Make sure to 1. install Vite's development middleware and 2. add Vite's middleware *before* Vike's middleware, see https://vike.dev/renderPage`, { onlyOnce: true });
+    return (urlOriginal.endsWith('/__vite_ping') || urlOriginal.endsWith('/favicon.ico') || !isUrl(urlOriginal) || isViteRequest);
 }
 function normalizeUrl(pageContextInit, httpRequestId) {
     const { trailingSlash, disableUrlNormalization, baseServer } = getGlobalContext();
@@ -359,9 +356,9 @@ function getPermanentRedirect(pageContextInit, httpRequestId) {
         const urlTarget = resolveRedirects(redirects, urlPathname);
         if (urlTarget === null)
             return null;
-        if (!isParsable(urlTarget)) {
+        if (!isUrl(urlTarget)) {
             // E.g. `urlTarget === 'mailto:some@example.com'`
-            assert(isUriWithProtocol(urlTarget) && !urlTarget.startsWith('http'));
+            assert(isUri(urlTarget));
             urlTargetExternal = urlTarget;
             return null;
         }

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

@@ -4,32 +4,10 @@ export type { PageContextUrlInternal };
 export type { PageContextUrlClient };
 export type { PageContextUrlServer };
 export type { PageContextUrlSource };
-export type { Url };
-type Url = {
-    /** The URL origin, e.g. `https://example.com` of `https://example.com/product/42?details=yes#reviews` */
-    origin: null | string;
-    /** The URL pathname, e.g. `/product/42` of `https://example.com/product/42?details=yes#reviews` */
-    pathname: string;
-    /** URL pathname including the Base URL, e.g. `/some-base-url/product/42` of `https://example.com/some-base-url/product/42` (whereas `pageContext.urlParsed.pathname` is `/product/42`) */
-    pathnameOriginal: string;
-    /** The URL search parameters, e.g. `{ details: 'yes' }` for `https://example.com/product/42?details=yes#reviews` */
-    search: Record<string, string>;
-    /** The URL search parameters array, e.g. `{ fruit: ['apple', 'orange'] }` for `https://example.com?fruit=apple&fruit=orange` **/
-    searchAll: Record<string, string[]>;
-    /** The URL search parameterer string, e.g. `?details=yes` of `https://example.com/product/42?details=yes#reviews` */
-    searchOriginal: null | string;
-    /** The URL hash, e.g. `reviews` of `https://example.com/product/42?details=yes#reviews` */
-    hash: string;
-    /** The URL hash string, e.g. `#reviews` of `https://example.com/product/42?details=yes#reviews` */
-    hashOriginal: null | string;
-    /** @deprecated */
-    hashString: null | string;
-    /** @deprecated */
-    searchString: null | string;
-};
+import { type UrlPublic } from './utils.js';
 type PageContextUrlComputed = {
     /** Parsed information about the current URL */
-    urlParsed: Url;
+    urlParsed: UrlPublic;
     /** The URL pathname, e.g. `/product/42` of `https://example.com/product/42?details=yes#reviews` */
     urlPathname: string;
     /** @deprecated */

package/dist/esm/shared/getPageContextUrlComputed.js

@@ -28,11 +28,6 @@ function getPageContextUrlComputed(pageContext) {
     return pageContextUrlComputed;
 }
 function getUrlParsed(pageContext) {
-    // We need a url handler function because the onBeforeRoute() hook may set pageContext.urlLogical (typically for i18n)
-    let urlHandler = pageContext._urlHandler;
-    if (!urlHandler) {
-        urlHandler = (url) => url;
-    }
     // Example of i18n app using `throw render()`:
     //  1. User goes to '/fr-FR/admin'.
     //  2. The first onBeforeRoute() call accesses pageContext.urlPathname (its value is '/fr-FR/admin': the pathname of pageContext.urlOriginal, since both pageContext.urlLogical and pageContext._urlRewrite are undefined) and sets pageContext.urlLogical to '/admin'.
@@ -41,23 +36,36 @@ function getUrlParsed(pageContext) {
     //  5. The second onBeforeRoute() call accesses pageContext.urlPathname (its value is '/fr-FR/login': the pathname of pageContext._urlRewrite, since pageContext.urlLogical is undefined) and sets pageContext.urlLogical to '/login'.
     //  6. The value of pageContext.urlPathname is now '/login': the pathname of `pageContext.urlLogical`. (While pageContext.urlOriginal is still '/fr-FR/admin'.)
     // Reproduction: https://github.com/vikejs/vike/discussions/1436#discussioncomment-8142023
-    let urlResolved = 
-    // Set by onBeforeRoute()
-    pageContext.urlLogical ??
+    // Determine logical URL
+    let urlResolved;
+    let baseToBeRemoved;
+    if (pageContext.urlLogical) {
+        // Set by onBeforeRoute()
+        urlResolved = pageContext.urlLogical;
+        baseToBeRemoved = false;
+    }
+    else if (pageContext._urlRewrite) {
         // Set by `throw render()`
-        pageContext._urlRewrite ??
+        urlResolved = pageContext._urlRewrite;
+        baseToBeRemoved = false;
+    }
+    else {
         // Set by renderPage()
-        pageContext.urlOriginal;
-    urlResolved = urlHandler(urlResolved);
-    /*
-    console.log('pageContext.urlLogical', pageContext.urlLogical)
-    console.log('pageContext._urlRewrite', pageContext._urlRewrite)
-    console.log('pageContext.urlOriginal', pageContext.urlOriginal)
-    console.log()
-    //*/
-    const baseServer = pageContext._baseServer;
+        urlResolved = pageContext.urlOriginal;
+        baseToBeRemoved = true;
+    }
     assert(urlResolved && typeof urlResolved === 'string');
-    assert(baseServer.startsWith('/'));
+    // Remove .pageContext.json
+    let urlHandler = pageContext._urlHandler;
+    if (!urlHandler)
+        urlHandler = (url) => url;
+    urlResolved = urlHandler(urlResolved);
+    // Remove Base URL.
+    // - We assume there isn't any Base URL to the URLs set by the user at `throw render()` and onBeforeRoute()
+    //   - This makes sense because the Base URL is merely a setting: ideally the user should write code that doesn't know anything about it (so that the user can remove/add/change Base URL without having to modify any code).
+    // - pageContext.urlOriginal is the URL of the HTTP request and thus contains the Base URL.
+    const baseServer = !baseToBeRemoved ? '/' : pageContext._baseServer;
+    // Parse URL
     return parseUrl(urlResolved, baseServer);
 }
 function urlPathnameGetter() {
@@ -72,47 +80,45 @@ function urlGetter() {
     return urlPathnameGetter.call(this);
 }
 function urlParsedGetter() {
-    const urlParsedOriginal = getUrlParsed(this);
-    const { origin, pathname, pathnameOriginal, search, searchAll, searchOriginal, hash, hashOriginal } = urlParsedOriginal;
+    const { 
+    // remove hasBaseServer as it isn't part of UrlPublic
+    hasBaseServer: _, ...urlParsed } = getUrlParsed(this);
     const hashIsAvailable = isBrowser();
     const warnHashNotAvailable = (prop) => {
         assertWarning(hashIsAvailable, `pageContext.urlParsed.${prop} isn't available on the server-side (HTTP requests don't include the URL hash)`, { onlyOnce: true, showStackTrace: true });
     };
-    const urlParsed = {
-        origin,
-        pathname,
-        pathnameOriginal,
-        search,
-        searchAll,
-        searchOriginal,
+    const urlParsedEnhanced = {
+        ...urlParsed,
         get hash() {
             warnHashNotAvailable('hash');
-            return hash;
+            return urlParsed.hash;
         },
         get hashOriginal() {
             warnHashNotAvailable('hashOriginal');
-            return hashOriginal;
+            return urlParsed.hashOriginal;
         },
+        // TODO/next-major-release: remove
         get hashString() {
             assertWarning(false, 'pageContext.urlParsed.hashString has been renamed to pageContext.urlParsed.hashOriginal', {
                 onlyOnce: true,
                 showStackTrace: true
             });
             warnHashNotAvailable('hashString');
-            return hashOriginal;
+            return urlParsed.hashOriginal;
         },
+        // TODO/next-major-release: remove
         get searchString() {
             assertWarning(false, 'pageContext.urlParsed.searchString has been renamed to pageContext.urlParsed.searchOriginal', { onlyOnce: true, showStackTrace: true });
-            return searchOriginal;
+            return urlParsed.searchOriginal;
         }
     };
-    changeEnumerable(urlParsed, 'hashString', false);
-    changeEnumerable(urlParsed, 'searchString', false);
+    changeEnumerable(urlParsedEnhanced, 'hashString', false);
+    changeEnumerable(urlParsedEnhanced, 'searchString', false);
     if (!hashIsAvailable) {
-        changeEnumerable(urlParsed, 'hash', false);
-        changeEnumerable(urlParsed, 'hashOriginal', false);
+        changeEnumerable(urlParsedEnhanced, 'hash', false);
+        changeEnumerable(urlParsedEnhanced, 'hashOriginal', false);
     }
-    return urlParsed;
+    return urlParsedEnhanced;
 }
 function assertPageContextUrl(pageContext) {
     assert(typeof pageContext.urlOriginal === 'string');

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

@@ -0,0 +1,14 @@
+export { modifyUrl };
+/**
+ * Modify a URL.
+ *
+ * Example: changing the URL pathname for internationalization.
+ *
+ * https://vike.dev/modifyUrl
+ */
+declare function modifyUrl(url: string, modify: {
+    pathname?: string;
+    hostname?: string;
+    port?: number;
+    protocol?: string;
+}): string;

package/dist/esm/shared/modifyUrl.js

@@ -0,0 +1,28 @@
+export { modifyUrl };
+import { createUrlFromComponents, parseUrl } from './utils.js';
+/**
+ * Modify a URL.
+ *
+ * Example: changing the URL pathname for internationalization.
+ *
+ * https://vike.dev/modifyUrl
+ */
+function modifyUrl(url, modify) {
+    const urlParsed = parseUrl(url, '/');
+    // Pathname
+    const pathname = modify.pathname ?? urlParsed.pathname;
+    // Origin
+    const originParts = [
+        modify.protocol ?? urlParsed.protocol ?? '',
+        modify.hostname ?? urlParsed.hostname ?? ''
+    ];
+    const port = modify.port ?? urlParsed.port;
+    if (port || port === 0) {
+        originParts.push(`:${port}`);
+    }
+    const origin = originParts.join('');
+    const urlModified = createUrlFromComponents(origin, pathname, 
+    // Should we also support modifying search and hash?
+    urlParsed.searchOriginal, urlParsed.hashOriginal);
+    return urlModified;
+}