vike 0.4.180-commit-648cd01 → 0.4.181-commit-ee50efa

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/plugin/plugins/envVars.d.ts

@@ -1,5 +1,3 @@
 export { envVarsPlugin };
-export { applyEnvVar };
 import type { Plugin } from 'vite';
 declare function envVarsPlugin(): Plugin;
-declare function applyEnvVar(envName: string, envVal: string, code: string): string;

package/dist/esm/node/plugin/plugins/envVars.js

@@ -1,6 +1,4 @@
 export { envVarsPlugin };
-// For ./envVars.spec.ts
-export { applyEnvVar };
 import { loadEnv } from 'vite';
 import { assert, assertPosixPath, assertUsage, assertWarning, escapeRegex, isArray, lowerFirst } from '../utils.js';
 import { sourceMapPassthrough } from '../shared/rollupSourceMap.js';
@@ -43,12 +41,13 @@ function envVarsPlugin() {
                 return !envPrefix.some((prefix) => key.startsWith(prefix));
             })
                 .forEach(([envName, envVal]) => {
+                const envStatement = `import.meta.env.${envName}`;
+                const envStatementRegEx = new RegExp(escapeRegex(envStatement) + '\\b', 'g');
                 // Security check
                 {
-                    const envStatement = getEnvStatement(envName);
                     const isPrivate = !envName.startsWith(PUBLIC_ENV_PREFIX) && !PUBLIC_ENV_WHITELIST.includes(envName);
                     if (isPrivate && isClientSide) {
-                        if (!code.includes(envStatement))
+                        if (!envStatementRegEx.test(code))
                             return;
                         const modulePath = getModuleFilePath(id, config);
                         const errMsgAddendum = isBuild ? '' : ' (Vike will prevent your app from building for production)';
@@ -67,7 +66,7 @@ function envVarsPlugin() {
                     assert(!(isPrivate && isClientSide) || !isBuild);
                 }
                 // Apply
-                code = applyEnvVar(envName, envVal, code);
+                code = applyEnvVar(envStatementRegEx, envVal, code);
             });
             // Line numbers didn't change.
             //  - We only break the column number of a couple of lines, wich is acceptable.
@@ -77,13 +76,8 @@ function envVarsPlugin() {
         }
     };
 }
-function applyEnvVar(envName, envVal, code) {
-    const envStatement = getEnvStatement(envName);
-    const regex = new RegExp(escapeRegex(envStatement) + '\\b', 'g');
-    return code.replace(regex, JSON.stringify(envVal));
-}
-function getEnvStatement(envName) {
-    return `import.meta.env.${envName}`;
+function applyEnvVar(envStatementRegEx, envVal, code) {
+    return code.replace(envStatementRegEx, JSON.stringify(envVal));
 }
 function getIsClientSide(config, options) {
     const isBuild = config.command === 'build';

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;
+}

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

@@ -8,7 +8,7 @@ export { getPageContextFromAllRewrites };
 export { AbortRender };
 export { assertNoInfiniteAbortLoop };
 import { isUserHookError } from '../hooks/executeHook.js';
-import { assert, assertInfo, assertUsage, assertWarning, checkType, hasProp, isUriWithProtocol, joinEnglish, objectAssign, truncateString } from './utils.js';
+import { assert, assertInfo, assertUsage, assertUsageUrlPathnameAbsolute, assertUsageUrlRedirectTarget, assertWarning, checkType, hasProp, joinEnglish, objectAssign, truncateString } from './utils.js';
 import pc from '@brillout/picocolors';
 /**
  * Abort the rendering of the current page, and redirect the user to another URL instead.
@@ -20,7 +20,7 @@ import pc from '@brillout/picocolors';
  */
 function redirect(url, statusCode) {
     const abortCaller = 'throw redirect()';
-    assertUrl(url, abortCaller, true);
+    assertUsageUrlRedirectTarget(url, getErrPrefix(abortCaller));
     const args = [JSON.stringify(url)];
     if (!statusCode) {
         statusCode = 302;
@@ -60,7 +60,7 @@ function render_(urlOrStatusCode, abortReason, abortCall, abortCaller, pageConte
     }
     if (typeof urlOrStatusCode === 'string') {
         const url = urlOrStatusCode;
-        assertUrl(url, abortCaller);
+        assertUsageUrlPathnameAbsolute(url, getErrPrefix(abortCaller));
         objectAssign(pageContextAbort, {
             _urlRewrite: url
         });
@@ -168,12 +168,6 @@ function assertNoInfiniteAbortLoop(rewriteCount, redirectCount) {
         .join(' and ');
     assertUsage(rewriteCount + redirectCount <= 7, `Maximum chain length of 7 ${abortCalls} exceeded. Did you define an infinite loop of ${abortCalls}?`);
 }
-function assertUrl(url, abortCaller, allowAbsoluteUrl) {
-    assertUsage(url.startsWith('/') || (allowAbsoluteUrl && isUriWithProtocol(url)), [
-        `Invalid URL ${pc.cyan(url)} passed to ${pc.cyan(abortCaller)}:`,
-        `the URL should start with ${pc.cyan('/')}`,
-        allowAbsoluteUrl && `or a valid protocol (${pc.cyan('https:')}, ${pc.cyan('ipfs:')}, ...)`
-    ]
-        .filter(Boolean)
-        .join(' '));
+function getErrPrefix(abortCaller) {
+    return `URL passed to ${pc.code(abortCaller)}`;
 }

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

@@ -1,6 +1,6 @@
 export { executeOnBeforeRouteHook };
 import { assertPageContextProvidedByUser } from '../assertPageContextProvidedByUser.js';
-import { assertUsage, hasProp, isObjectWithKeys, objectAssign, assertWarning, assertUsageUrl, joinEnglish, assert } from './utils.js';
+import { assertUsage, hasProp, isObjectWithKeys, objectAssign, assertWarning, assertUsageUrlPathnameAbsolute, joinEnglish, assert } from './utils.js';
 import { assertRouteParams, assertSyncRouting } from './resolveRouteFunction.js';
 import pc from '@brillout/picocolors';
 import { executeHook } from '../hooks/executeHook.js';
@@ -65,7 +65,9 @@ async function getPageContextFromHook(onBeforeRouteHook, pageContext) {
         delete hookReturn.pageContext.urlOriginal;
     }
     if (hasProp(hookReturn.pageContext, 'urlLogical')) {
-        assertUsageUrl(hookReturn.pageContext.urlLogical, `${errPrefix} returned ${pc.cyan('{ pageContext: { urlLogical } }')} but ${pc.cyan('urlLogical')}`);
+        assertUsageUrlPathnameAbsolute(
+        // We type-cast to string instead of assertUsage() in order to save client-side KBs
+        hookReturn.pageContext.urlLogical, `${errPrefix} returned ${pc.cyan('{ pageContext: { urlLogical } }')} but ${pc.cyan('urlLogical')}`);
     }
     assertPageContextProvidedByUser(hookReturn.pageContext, {
         hookFilePath: onBeforeRouteHook.hookFilePath,

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

@@ -10,7 +10,7 @@ export type { Config, ConfigMeta as Meta, ImportString, DataAsync, DataSync, Gua
 export type { ConfigEnv } from '../shared/page-configs/PageConfig.js';
 export type { ConfigDefinition, ConfigEffect } from '../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/configDefinitionsBuiltIn.js';
 export type { ConfigEntries } from '../shared/getPageFiles/getExports.js';
-export type { Url } from '../shared/getPageContextUrlComputed.js';
+export type { UrlPublic as Url } from '../utils/parseUrl.js';
 export type { InjectFilterEntry } from '../node/runtime/html/injectAssets/getHtmlTags.js';
 export { defineConfig } from './defineConfig.js';
 import type { ConfigEnv } from '../shared/page-configs/PageConfig.js';

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

@@ -1,24 +1,57 @@
 export { parseUrl };
-export { isParsable };
-export { assertUsageUrl };
+export { assertUsageUrlPathname };
+export { assertUsageUrlPathnameAbsolute };
+export { assertUsageUrlRedirectTarget };
+export { isUrl };
+export { isUri };
+export { isUrlRedirectTarget };
+export { isUrlExternal };
 export { isBaseServer };
 export { assertUrlComponents };
 export { createUrlFromComponents };
-export { isUriWithProtocol };
-declare function isParsable(url: string): boolean;
-declare function assertUsageUrl(url: unknown, errPrefix: string): asserts url is string;
-declare function parseUrl(url: string, baseServer: string): {
+export type { UrlPublic };
+export type { UrlPrivate };
+type UrlPublic = {
+    /** The full URL. */
+    href: string;
+    /** The URL protocol, e.g. `https://` in `https://example.com` */
+    protocol: null | string;
+    /** The URL hostname, e.g. `example.com` in `https://example.com/product` and `localhost` in `http://localhost:3000/product` */
+    hostname: null | string;
+    /** The URL host port, e.g. `3000` in `http://localhost:3000/product` */
+    port: null | number;
+    /** The URL origin, e.g. `https://example.com` in `https://example.com/product/42` */
     origin: null | string;
+    /** The URL pathname, e.g. `/product/42` in `https://example.com/product/42?details=yes#reviews` */
     pathname: string;
+    /** URL pathname including the Base URL, e.g. `/some-base-url/product/42` in `https://example.com/some-base-url/product/42` (whereas `pageContext.urlParsed.pathname` is `/product/42`) */
     pathnameOriginal: string;
-    hasBaseServer: boolean;
+    /** 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` in `https://example.com/product/42?details=yes#reviews` */
     searchOriginal: null | string;
+    /** The URL hash, e.g. `reviews` in `https://example.com/product/42?details=yes#reviews` */
     hash: string;
+    /** The URL hash string, e.g. `#reviews` in `https://example.com/product/42?details=yes#reviews` */
     hashOriginal: null | string;
+    /** @deprecated */
+    hashString: null | string;
+    /** @deprecated */
+    searchString: null | string;
+};
+type UrlPrivate = Omit<UrlPublic, 'hashString' | 'searchString'> & {
+    hasBaseServer: boolean;
 };
+declare function parseUrl(url: string, baseServer: string): UrlPrivate;
 declare function isBaseServer(baseServer: string): boolean;
-declare function assertUrlComponents(url: string, origin: string | null, pathname: string, searchOriginal: string | null, hashOriginal: string | null): void;
-declare function createUrlFromComponents(origin: string | null, pathname: string, searchOriginal: string | null, hashOriginal: string | null): string;
-declare function isUriWithProtocol(str: string): boolean;
+declare function assertUrlComponents(url: string, origin: string | null, pathnameOriginal: string, searchOriginal: string | null, hashOriginal: string | null): void;
+declare function createUrlFromComponents(origin: string | null, pathname: string, search: string | null, hash: string | null): string;
+declare function isUrl(url: string): boolean;
+declare function isUrlRedirectTarget(url: string): boolean;
+declare function isUrlExternal(url: string): boolean;
+declare function isUri(uri: string): boolean;
+declare function assertUsageUrlPathname(url: string, errPrefix: string): void;
+declare function assertUsageUrlPathnameAbsolute(url: string, errPrefix: string): void;
+declare function assertUsageUrlRedirectTarget(url: string, errPrefix: string, isUnresolved?: true): void;