vike 0.4.180 → 0.4.181-commit-ddcbf7d

package/dist/cjs/utils/parseUrl.js

@@ -6,35 +6,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isUriWithProtocol = exports.createUrlFromComponents = exports.assertUrlComponents = exports.isBaseServer = exports.assertUsageUrl = exports.isParsable = exports.parseUrl = void 0;
+exports.createUrlFromComponents = exports.assertUrlComponents = exports.isBaseServer = exports.isUrlExternal = exports.isUrlRedirectTarget = exports.isUri = exports.isUrl = exports.assertUsageUrlRedirectTarget = exports.assertUsageUrlPathnameAbsolute = exports.assertUsageUrlPathname = exports.parseUrl = void 0;
 const slice_js_1 = require("./slice.js");
 const assert_js_1 = require("./assert.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
-function isParsable(url) {
-    // `parseUrl()` works with these URLs
-    return (isUrlWithProtocol(url) ||
-        url.startsWith('/') ||
-        url.startsWith('.') ||
-        url.startsWith('?') ||
-        url.startsWith('#') ||
-        url === '');
-}
-exports.isParsable = isParsable;
-function assertUsageUrl(url, errPrefix) {
-    (0, assert_js_1.assert)(errPrefix.includes(' but '));
-    (0, assert_js_1.assertUsage)(typeof url === 'string', `${errPrefix} should be a string`);
-    if (isParsable(url))
-        return;
-    if (!url.startsWith('/') && !url.includes(':')) {
-        (0, assert_js_1.assertUsage)(false, `${errPrefix} is ${picocolors_1.default.cyan(url)} and it should be /${picocolors_1.default.cyan(url)} instead (URL pathnames should start with a leading slash)`);
-    }
-    else {
-        (0, assert_js_1.assertUsage)(false, `${errPrefix} isn't a valid URL`);
-    }
-}
-exports.assertUsageUrl = assertUsageUrl;
 function parseUrl(url, baseServer) {
-    (0, assert_js_1.assert)(isParsable(url));
+    (0, assert_js_1.assert)(isUrl(url), url);
     (0, assert_js_1.assert)(baseServer.startsWith('/'));
     // Hash
     const [urlWithoutHash, ...hashList] = url.split('#');
@@ -54,18 +31,24 @@ function parseUrl(url, baseServer) {
         searchAll[key] = [...(searchAll.hasOwnProperty(key) ? searchAll[key] : []), val];
     });
     // Origin + pathname
-    const { origin, pathname: pathnameResolved } = getPathname(urlWithoutHashNorSearch, baseServer);
-    (0, assert_js_1.assert)(origin === null || origin === decodeSafe(origin)); // AFAICT decoding the origin is useless
-    (0, assert_js_1.assert)(pathnameResolved.startsWith('/'));
-    (0, assert_js_1.assert)(origin === null || url.startsWith(origin));
-    // `pathnameOriginal`
+    let { protocol, origin, pathnameAbsoluteWithBase } = getPathnameAbsoluteWithBase(urlWithoutHashNorSearch, baseServer);
     const pathnameOriginal = urlWithoutHashNorSearch.slice((origin || '').length);
     assertUrlComponents(url, origin, pathnameOriginal, searchOriginal, hashOriginal);
     // Base URL
-    let { pathname, hasBaseServer } = analyzeBaseServer(pathnameResolved, baseServer);
+    let { pathname, hasBaseServer } = removeBaseServer(pathnameAbsoluteWithBase, baseServer);
+    // pageContext.urlParsed.href
+    const href = createUrlFromComponents(origin, pathname, searchOriginal, hashOriginal);
+    // pageContext.urlParsed.{hostname, port}
+    const host = !origin ? null : origin.slice(protocol.length);
+    const { hostname, port } = parseHost(host, url);
+    // decode after setting href
     pathname = decodePathname(pathname);
     (0, assert_js_1.assert)(pathname.startsWith('/'));
     return {
+        href,
+        protocol,
+        hostname,
+        port,
         origin,
         pathname,
         pathnameOriginal: pathnameOriginal,
@@ -97,20 +80,20 @@ function decodePathname(urlPathname) {
         .join('/');
     return urlPathname;
 }
-function getPathname(url, baseServer) {
+function getPathnameAbsoluteWithBase(url, baseServer) {
     // Search and hash already extracted
     (0, assert_js_1.assert)(!url.includes('?') && !url.includes('#'));
     // url has origin
     {
-        const { origin, pathname } = parseOrigin(url);
+        const { protocol, origin, pathname } = parseOrigin(url);
         if (origin) {
-            return { origin, pathname };
+            return { protocol, origin, pathnameAbsoluteWithBase: pathname };
         }
         (0, assert_js_1.assert)(pathname === url);
     }
     // url doesn't have origin
     if (url.startsWith('/')) {
-        return { origin: null, pathname: url };
+        return { protocol: null, origin: null, pathnameAbsoluteWithBase: url };
     }
     else {
         // url is a relative path
@@ -125,21 +108,70 @@ function getPathname(url, baseServer) {
         else {
             base = baseServer;
         }
-        const pathname = resolveUrlPathnameRelative(url, base);
-        return { origin: null, pathname };
+        const pathnameAbsoluteWithBase = resolveUrlPathnameRelative(url, base);
+        return { protocol: null, origin: null, pathnameAbsoluteWithBase: pathnameAbsoluteWithBase };
     }
 }
 function parseOrigin(url) {
     if (!isUrlWithProtocol(url)) {
-        (0, assert_js_1.assert)(!isUriWithProtocol(url));
-        return { pathname: url, origin: null };
+        return { pathname: url, origin: null, protocol: null };
     }
     else {
-        const [originPart1, originPart2, originPart3, ...pathnameParts] = url.split('/');
-        const origin = [originPart1, originPart2, originPart3].join('/');
-        const pathname = ['', ...pathnameParts].join('/') || '/';
-        return { origin, pathname };
+        const { protocol, uriWithoutProtocol } = parseProtocol(url);
+        (0, assert_js_1.assert)(protocol);
+        const [host, ...rest] = uriWithoutProtocol.split('/');
+        const origin = protocol + host;
+        const pathname = '/' + rest.join('/');
+        return { pathname, origin, protocol };
+    }
+}
+function parseHost(host, url) {
+    const ret = { hostname: null, port: null };
+    if (!host)
+        return ret;
+    // hostname
+    const [hostname, ...rest] = host.split(':');
+    ret.hostname = hostname;
+    // port
+    if (rest.length > 0) {
+        (0, assert_js_1.assert)(rest.length === 1, url);
+        const portStr = rest[0];
+        const port = parseInt(portStr, 10);
+        (0, assert_js_1.assert)(port || port === 0, url);
+        ret.port = port;
     }
+    return ret;
+}
+function parseProtocol(uri) {
+    const SEP = ':';
+    const [before, ...after] = uri.split(SEP);
+    if (after.length === 0 ||
+        // https://github.com/vikejs/vike/commit/886a99ff21e86a8ca699a25cee7edc184aa058e4#r143308934
+        // https://en.wikipedia.org/wiki/List_of_URI_schemes
+        // https://www.rfc-editor.org/rfc/rfc7595
+        !/^[a-z][a-z0-9\+\-]*$/i.test(before)) {
+        return { protocol: null, uriWithoutProtocol: uri };
+    }
+    let protocol = before + SEP;
+    let uriWithoutProtocol = after.join(SEP);
+    const SEP2 = '//';
+    if (uriWithoutProtocol.startsWith(SEP2)) {
+        protocol = protocol + SEP2;
+        uriWithoutProtocol = uriWithoutProtocol.slice(SEP2.length);
+    }
+    return { protocol, uriWithoutProtocol };
+}
+function isUrlProtocol(protocol) {
+    // Is there an altenrative to having a blacklist?
+    // - If the blacklist becomes too big, maybe use a whitelist instead ['tauri://', 'file://', 'capacitor://', 'http://', 'https://']
+    const blacklist = [
+        // https://docs.ipfs.tech/how-to/address-ipfs-on-web
+        'ipfs://',
+        'ipns://'
+    ];
+    if (blacklist.includes(protocol))
+        return false;
+    return protocol.endsWith('://');
 }
 // Adapted from https://stackoverflow.com/questions/14780350/convert-relative-path-to-absolute-using-javascript/14780463#14780463
 function resolveUrlPathnameRelative(pathnameRelative, base) {
@@ -170,34 +202,15 @@ function resolveUrlPathnameRelative(pathnameRelative, base) {
         pathnameAbsolute = '/' + pathnameAbsolute;
     return pathnameAbsolute;
 }
-/* Not needed anymore?
-function assertUsageBaseServer(baseServer: string, usageErrorMessagePrefix: string = '') {
-  assertUsage(
-    !baseServer.startsWith('http'),
-    usageErrorMessagePrefix +
-      '`base` is not allowed to start with `http`. Consider using `baseAssets` instead, see https://vike.dev/base-url'
-  )
-  assertUsage(
-    baseServer.startsWith('/'),
-    usageErrorMessagePrefix + 'Wrong `base` value `' + baseServer + '`; `base` should start with `/`.'
-  )
-  assert(isBaseServer(baseServer))
-}
-*/
-function assertPathname(urlPathname) {
-    (0, assert_js_1.assert)(urlPathname.startsWith('/'));
-    (0, assert_js_1.assert)(!urlPathname.includes('?'));
-    (0, assert_js_1.assert)(!urlPathname.includes('#'));
-}
-function analyzeBaseServer(urlPathnameWithBase, baseServer) {
-    assertPathname(urlPathnameWithBase);
+function removeBaseServer(pathnameAbsoluteWithBase, baseServer) {
+    (0, assert_js_1.assert)(pathnameAbsoluteWithBase.startsWith('/'));
     (0, assert_js_1.assert)(isBaseServer(baseServer));
     // Mutable
-    let urlPathname = urlPathnameWithBase;
+    let urlPathname = pathnameAbsoluteWithBase;
     (0, assert_js_1.assert)(urlPathname.startsWith('/'));
     (0, assert_js_1.assert)(baseServer.startsWith('/'));
     if (baseServer === '/') {
-        const pathname = urlPathnameWithBase;
+        const pathname = pathnameAbsoluteWithBase;
         return { pathname, hasBaseServer: true };
     }
     // Support `url === '/some-base-url' && baseServer === '/some-base-url/'`
@@ -207,7 +220,7 @@ function analyzeBaseServer(urlPathnameWithBase, baseServer) {
         (0, assert_js_1.assert)(urlPathname === baseServerNormalized);
     }
     if (!urlPathname.startsWith(baseServerNormalized)) {
-        const pathname = urlPathnameWithBase;
+        const pathname = pathnameAbsoluteWithBase;
         return { pathname, hasBaseServer: false };
     }
     (0, assert_js_1.assert)(urlPathname.startsWith('/') || urlPathname.startsWith('http'));
@@ -222,30 +235,98 @@ function isBaseServer(baseServer) {
     return baseServer.startsWith('/');
 }
 exports.isBaseServer = isBaseServer;
-function assertUrlComponents(url, origin, pathname, searchOriginal, hashOriginal) {
-    const urlRecreated = createUrlFromComponents(origin, pathname, searchOriginal, hashOriginal);
+function assertUrlComponents(url, origin, pathnameOriginal, searchOriginal, hashOriginal) {
+    const urlRecreated = createUrlFromComponents(origin, pathnameOriginal, searchOriginal, hashOriginal);
     (0, assert_js_1.assert)(url === urlRecreated);
 }
 exports.assertUrlComponents = assertUrlComponents;
-function createUrlFromComponents(origin, pathname, searchOriginal, hashOriginal) {
-    const urlRecreated = `${origin || ''}${pathname}${searchOriginal || ''}${hashOriginal || ''}`;
+function createUrlFromComponents(origin, pathname, search, hash) {
+    const urlRecreated = `${origin || ''}${pathname}${search || ''}${hash || ''}`;
     return urlRecreated;
 }
 exports.createUrlFromComponents = createUrlFromComponents;
-function isUriWithProtocol(str) {
-    // https://en.wikipedia.org/wiki/List_of_URI_schemes
-    // https://www.rfc-editor.org/rfc/rfc7595
-    // https://github.com/vikejs/vike/commit/886a99ff21e86a8ca699a25cee7edc184aa058e4#r143308934
-    // Examples:
-    //   http://
-    //   https://
-    //   tauri:// # [Tauri](https://tauri.app)
-    //   file:// # [Electron](https://github.com/vikejs/vike/issues/1557)
-    //   capacitor:// # [Capacitor](https://github.com/vikejs/vike/issues/1706)
-    return /^[a-z][a-z0-9\+\-]*:/i.test(str);
-}
-exports.isUriWithProtocol = isUriWithProtocol;
-// Same as isUriWithProtocol() but with trailing :// which is needed for parseOrigin()
-function isUrlWithProtocol(str) {
-    return /^[a-z][a-z0-9\+\-]*:\/\//i.test(str);
+function isUrl(url) {
+    // parseUrl() works with these URLs
+    return isUrlWithProtocol(url) || url.startsWith('/') || isUrlPathnameRelative(url);
+}
+exports.isUrl = isUrl;
+function isUrlRedirectTarget(url) {
+    return url.startsWith('/') || isUri(url) || isUrlWithProtocol(url);
+}
+exports.isUrlRedirectTarget = isUrlRedirectTarget;
+function isUrlPathnameRelative(url) {
+    return ['.', '?', '#'].some((c) => url.startsWith(c)) || url === '';
+}
+function isUrlExternal(url) {
+    return !url.startsWith('/') && !isUrlPathnameRelative(url);
+}
+exports.isUrlExternal = isUrlExternal;
+/*
+URL with protocol.
+
+  http://example.com
+  https://exmaple.com
+  tauri://localhost
+  file://example.com
+  capacitor://localhost/assets/chunks/chunk-DJBYDrsP.js
+
+[Tauri](https://github.com/vikejs/vike/issues/808)
+[Electron (`file://`)](https://github.com/vikejs/vike/issues/1557)
+[Capacitor](https://github.com/vikejs/vike/issues/1706)
+ */
+function isUrlWithProtocol(url) {
+    const { protocol } = parseProtocol(url);
+    return !!protocol && isUrlProtocol(protocol);
+}
+/*
+URIs that aren't URLs.
+
+  mailto:john@example.com
+
+  ipfs://bafybeiemxf5abjwjbikoz4mc3a3dla6ual3jsgpdr4cjr3oz3evfyavhwq/wiki/Vincent_van_Gogh.html
+
+  magnet:?xt=urn:btih:3a15e1ac49683d91b20c2ffc252ea612a6c01bd7&dn=The.Empire.Strikes.Back.1980.Remastered.1080p.BluRay.DDP.7.1.x265-EDGE2020.mkv&xl=3225443573&tr=udp://tracker.opentrackr.org:1337/announce&tr=udp://tracker.torrent.eu.org:451&tr=udp://open.stealth.si:80/announce&tr=udp://tracker.openbittorrent.com:6969&tr=udp://tracker.tiny-vps.com:6969/announce&tr=udp://open.demonii.com:1337
+
+We need to treat URIs differently than URLs.
+ - For example, we cannot parse URIs (their structure is unknown e.g. a `magnet:` URI is completely different than a `http://` URL).
+   - The protocols tauri:// file:// capacitor:// follow the same structure as http:// and https:// URLs.
+     - Thus we can parse them like http:// and https:// URLs.
+*/
+function isUri(uri) {
+    const { protocol } = parseProtocol(uri);
+    return !!protocol && !isUrlProtocol(uri);
+}
+exports.isUri = isUri;
+function assertUsageUrlPathname(url, errPrefix) {
+    assertUsageUrl(url, errPrefix, { allowRelative: true });
+}
+exports.assertUsageUrlPathname = assertUsageUrlPathname;
+function assertUsageUrlPathnameAbsolute(url, errPrefix) {
+    assertUsageUrl(url, errPrefix);
+}
+exports.assertUsageUrlPathnameAbsolute = assertUsageUrlPathnameAbsolute;
+function assertUsageUrlRedirectTarget(url, errPrefix, isUnresolved) {
+    assertUsageUrl(url, errPrefix, { isRedirectTarget: isUnresolved ? 'unresolved' : true });
+}
+exports.assertUsageUrlRedirectTarget = assertUsageUrlRedirectTarget;
+function assertUsageUrl(url, errPrefix, { allowRelative, isRedirectTarget } = {}) {
+    if (url.startsWith('/'))
+        return;
+    let errMsg = `${errPrefix} is ${picocolors_1.default.string(url)} but it should start with ${picocolors_1.default.string('/')}`;
+    if (isRedirectTarget) {
+        if (isUrlRedirectTarget(url))
+            return;
+        errMsg += ` or a protocol (${picocolors_1.default.string('http://')}, ${picocolors_1.default.string('mailto:')}, ...)`;
+        if (isRedirectTarget === 'unresolved') {
+            if (url === '*')
+                return;
+            errMsg += `, or be ${picocolors_1.default.string('*')}`;
+        }
+    }
+    if (allowRelative) {
+        if (isUrlPathnameRelative(url))
+            return;
+        errMsg += ', or be a relative URL';
+    }
+    (0, assert_js_1.assertUsage)(false, errMsg);
 }

package/dist/cjs/utils/projectInfo.js

@@ -1,10 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PROJECT_VERSION = exports.projectInfo = void 0;
-const PROJECT_VERSION = '0.4.180';
-exports.PROJECT_VERSION = PROJECT_VERSION;
-const projectInfo = {
+exports.projectInfo = void 0;
+const PROJECT_VERSION_js_1 = require("./PROJECT_VERSION.js");
+exports.projectInfo = {
     projectName: 'Vike',
-    projectVersion: PROJECT_VERSION
+    projectVersion: PROJECT_VERSION_js_1.PROJECT_VERSION
 };
-exports.projectInfo = projectInfo;

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';
@@ -20,12 +20,14 @@ import { getErrorPageId } from '../../shared/error-page.js';
 const globalObject = getGlobalObject('renderPageClientSide.ts', { renderCounter: 0 });
 async function renderPageClientSide(renderArgs) {
     const { scrollTarget, urlOriginal = getCurrentUrl(), overwriteLastHistoryEntry = false, isBackwardNavigation, pageContextsFromRewrite = [], redirectCount = 0, isUserLandPushStateNavigation, isClientSideNavigation = true } = renderArgs;
-    // isHydrationRender <=> the first render attempt
-    const { isRenderOutdated, setHydrationCanBeAborted, isHydrationRender } = getIsRenderOutdated();
-    assert(isClientSideNavigation === !isHydrationRender); // isHydrationRender === (renderNumber === 1)
+    const { isRenderOutdated, setHydrationCanBeAborted, isFirstRender } = getIsRenderOutdated();
+    // Note that pageContext.isHydration isn't equivalent to isFirstRender
+    // - Thus pageContext.isHydration isn't equivalent to !pageContext.isClientSideNavigation
+    // - `pageContext.isHydration === !isFirstRender && !isErrorPage`
+    assert(isClientSideNavigation === !isFirstRender);
     assertNoInfiniteAbortLoop(pageContextsFromRewrite.length, redirectCount);
     if (globalObject.clientRoutingIsDisabled) {
-        serverSideRouteTo(urlOriginal);
+        redirectHard(urlOriginal);
         return;
     }
     await renderPageNominal();
@@ -64,7 +66,7 @@ async function renderPageClientSide(renderArgs) {
         }
         // Route
         let pageContextRouted;
-        if (isHydrationRender) {
+        if (isFirstRender) {
             const pageContextSerialized = getPageContextFromHooks_serialized();
             pageContextRouted = pageContextSerialized;
         }
@@ -89,7 +91,7 @@ async function renderPageClientSide(renderArgs) {
                     return;
             }
             if (!isClientRoutable) {
-                serverSideRouteTo(urlOriginal);
+                redirectHard(urlOriginal);
                 return;
             }
             assert(hasProp(pageContextFromRoute, '_pageId', 'string')); // Help TS
@@ -108,7 +110,7 @@ async function renderPageClientSide(renderArgs) {
             objectAssign(pageContext, await loadUserFilesClientSide(pageContext._pageId, pageContext._pageFilesAll, pageContext._pageConfigs));
         }
         catch (err) {
-            if (handleErrorFetchingStaticAssets(err, pageContext, isHydrationRender)) {
+            if (handleErrorFetchingStaticAssets(err, pageContext, isFirstRender)) {
                 return;
             }
             else {
@@ -130,7 +132,7 @@ async function renderPageClientSide(renderArgs) {
         if (isRenderOutdated())
             return;
         // Get pageContext from hooks (fetched from server, and/or directly called on the client-side)
-        if (isHydrationRender) {
+        if (isFirstRender) {
             assert(hasProp(pageContext, '_hasPageContextFromServer', 'true'));
             let pageContextAugmented;
             try {
@@ -183,7 +185,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 +230,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 {
@@ -267,7 +269,7 @@ async function renderPageClientSide(renderArgs) {
             objectAssign(pageContext, await loadUserFilesClientSide(pageContext._pageId, pageContext._pageFilesAll, pageContext._pageConfigs));
         }
         catch (err) {
-            if (handleErrorFetchingStaticAssets(err, pageContext, isHydrationRender)) {
+            if (handleErrorFetchingStaticAssets(err, pageContext, isFirstRender)) {
                 return;
             }
             else {
@@ -341,7 +343,7 @@ async function renderPageClientSide(renderArgs) {
         */
         addLinkPrefetchHandlers(pageContext);
         // onHydrationEnd()
-        if (isHydrationRender && !onRenderClientError) {
+        if (isFirstRender && !onRenderClientError) {
             assertHook(pageContext, 'onHydrationEnd');
             const hook = getHook(pageContext, 'onHydrationEnd');
             if (hook) {
@@ -395,11 +397,11 @@ function changeUrl(url, overwriteLastHistoryEntry) {
     pushHistory(url, overwriteLastHistoryEntry);
     updateState();
 }
-function handleErrorFetchingStaticAssets(err, pageContext, isHydrationRender) {
+function handleErrorFetchingStaticAssets(err, pageContext, isFirstRender) {
     if (!isErrorFetchingStaticAssets(err)) {
         return false;
     }
-    if (isHydrationRender) {
+    if (isFirstRender) {
         disableClientRouting(err, false);
         // This may happen if the frontend was newly deployed during hydration.
         // Ideally: re-try a couple of times by reloading the page (not entirely trivial to implement since `localStorage` is needed.)
@@ -408,7 +410,7 @@ function handleErrorFetchingStaticAssets(err, pageContext, isHydrationRender) {
     else {
         disableClientRouting(err, true);
     }
-    serverSideRouteTo(pageContext.urlOriginal);
+    redirectHard(pageContext.urlOriginal);
     return true;
 }
 function disableClientRouting(err, log) {
@@ -438,10 +440,10 @@ function getIsRenderOutdated() {
     };
     /** Whether the rendering should be aborted because a new rendering has started. We should call this after each `await`. */
     const isRenderOutdated = (isRenderCleanup) => {
-        // Never abort hydration if `hydrationCanBeAborted` isn't `true`
+        // Never abort first render if `hydrationCanBeAborted` isn't `true`
         {
-            const isHydration = renderNumber === 1;
-            if (isHydration && !hydrationCanBeAborted && !isRenderCleanup) {
+            const isFirstRender = renderNumber === 1;
+            if (isFirstRender && !hydrationCanBeAborted && !isRenderCleanup) {
                 return false;
             }
         }
@@ -451,7 +453,7 @@ function getIsRenderOutdated() {
     return {
         isRenderOutdated,
         setHydrationCanBeAborted,
-        isHydrationRender: renderNumber === 1
+        isFirstRender: renderNumber === 1
     };
 }
 function getRenderCount() {

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) {