vike 0.4.180 → 0.4.181

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,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PROJECT_VERSION = exports.projectInfo = void 0;
-const PROJECT_VERSION = '0.4.180';
+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/plugin/plugins/importUserCode/v1-design/getVikeConfig/crawlPlusFiles.js

@@ -153,6 +153,9 @@ async function fastGlob(userRootDir, outDirRelativeFromUserRootDir) {
         cwd: userRootDir,
         dot: false
     });
+    // Make build deterministic, in order to get a stable generated hash for dist/client/assets/entries/entry-client-routing.${hash}.js
+    // https://github.com/vikejs/vike/pull/1750
+    files.sort();
     return files;
 }
 // Same as getIgnoreAsFilterFn() but as glob pattern

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());