vike 0.4.180 → 0.4.181-commit-ddcbf7d

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/PROJECT_VERSION.d.ts

@@ -0,0 +1 @@
+export declare const PROJECT_VERSION: "0.4.181-commit-ddcbf7d";

package/dist/esm/utils/PROJECT_VERSION.js

@@ -0,0 +1 @@
+export const PROJECT_VERSION = '0.4.181-commit-ddcbf7d';

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;

package/dist/esm/utils/parseUrl.js

@@ -3,38 +3,21 @@
 //  - It doesn't support the tauri:// protocol
 // Unit tests at ./parseUrl.spec.ts
 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 };
 import { slice } from './slice.js';
 import { assert, assertUsage } from './assert.js';
 import pc from '@brillout/picocolors';
-function isParsable(url) {
-    // `parseUrl()` works with these URLs
-    return (isUrlWithProtocol(url) ||
-        url.startsWith('/') ||
-        url.startsWith('.') ||
-        url.startsWith('?') ||
-        url.startsWith('#') ||
-        url === '');
-}
-function assertUsageUrl(url, errPrefix) {
-    assert(errPrefix.includes(' but '));
-    assertUsage(typeof url === 'string', `${errPrefix} should be a string`);
-    if (isParsable(url))
-        return;
-    if (!url.startsWith('/') && !url.includes(':')) {
-        assertUsage(false, `${errPrefix} is ${pc.cyan(url)} and it should be /${pc.cyan(url)} instead (URL pathnames should start with a leading slash)`);
-    }
-    else {
-        assertUsage(false, `${errPrefix} isn't a valid URL`);
-    }
-}
 function parseUrl(url, baseServer) {
-    assert(isParsable(url));
+    assert(isUrl(url), url);
     assert(baseServer.startsWith('/'));
     // Hash
     const [urlWithoutHash, ...hashList] = url.split('#');
@@ -54,18 +37,24 @@ function parseUrl(url, baseServer) {
         searchAll[key] = [...(searchAll.hasOwnProperty(key) ? searchAll[key] : []), val];
     });
     // Origin + pathname
-    const { origin, pathname: pathnameResolved } = getPathname(urlWithoutHashNorSearch, baseServer);
-    assert(origin === null || origin === decodeSafe(origin)); // AFAICT decoding the origin is useless
-    assert(pathnameResolved.startsWith('/'));
-    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);
     assert(pathname.startsWith('/'));
     return {
+        href,
+        protocol,
+        hostname,
+        port,
         origin,
         pathname,
         pathnameOriginal: pathnameOriginal,
@@ -96,20 +85,20 @@ function decodePathname(urlPathname) {
         .join('/');
     return urlPathname;
 }
-function getPathname(url, baseServer) {
+function getPathnameAbsoluteWithBase(url, baseServer) {
     // Search and hash already extracted
     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 };
         }
         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
@@ -124,21 +113,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)) {
-        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);
+        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) {
+        assert(rest.length === 1, url);
+        const portStr = rest[0];
+        const port = parseInt(portStr, 10);
+        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) {
@@ -169,34 +207,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) {
-    assert(urlPathname.startsWith('/'));
-    assert(!urlPathname.includes('?'));
-    assert(!urlPathname.includes('#'));
-}
-function analyzeBaseServer(urlPathnameWithBase, baseServer) {
-    assertPathname(urlPathnameWithBase);
+function removeBaseServer(pathnameAbsoluteWithBase, baseServer) {
+    assert(pathnameAbsoluteWithBase.startsWith('/'));
     assert(isBaseServer(baseServer));
     // Mutable
-    let urlPathname = urlPathnameWithBase;
+    let urlPathname = pathnameAbsoluteWithBase;
     assert(urlPathname.startsWith('/'));
     assert(baseServer.startsWith('/'));
     if (baseServer === '/') {
-        const pathname = urlPathnameWithBase;
+        const pathname = pathnameAbsoluteWithBase;
         return { pathname, hasBaseServer: true };
     }
     // Support `url === '/some-base-url' && baseServer === '/some-base-url/'`
@@ -206,7 +225,7 @@ function analyzeBaseServer(urlPathnameWithBase, baseServer) {
         assert(urlPathname === baseServerNormalized);
     }
     if (!urlPathname.startsWith(baseServerNormalized)) {
-        const pathname = urlPathnameWithBase;
+        const pathname = pathnameAbsoluteWithBase;
         return { pathname, hasBaseServer: false };
     }
     assert(urlPathname.startsWith('/') || urlPathname.startsWith('http'));
@@ -220,27 +239,89 @@ function analyzeBaseServer(urlPathnameWithBase, baseServer) {
 function isBaseServer(baseServer) {
     return baseServer.startsWith('/');
 }
-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);
     assert(url === urlRecreated);
 }
-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;
 }
-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);
-}
-// 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);
+}
+function isUrlRedirectTarget(url) {
+    return url.startsWith('/') || isUri(url) || isUrlWithProtocol(url);
+}
+function isUrlPathnameRelative(url) {
+    return ['.', '?', '#'].some((c) => url.startsWith(c)) || url === '';
+}
+function isUrlExternal(url) {
+    return !url.startsWith('/') && !isUrlPathnameRelative(url);
+}
+/*
+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);
+}
+function assertUsageUrlPathname(url, errPrefix) {
+    assertUsageUrl(url, errPrefix, { allowRelative: true });
+}
+function assertUsageUrlPathnameAbsolute(url, errPrefix) {
+    assertUsageUrl(url, errPrefix);
+}
+function assertUsageUrlRedirectTarget(url, errPrefix, isUnresolved) {
+    assertUsageUrl(url, errPrefix, { isRedirectTarget: isUnresolved ? 'unresolved' : true });
+}
+function assertUsageUrl(url, errPrefix, { allowRelative, isRedirectTarget } = {}) {
+    if (url.startsWith('/'))
+        return;
+    let errMsg = `${errPrefix} is ${pc.string(url)} but it should start with ${pc.string('/')}`;
+    if (isRedirectTarget) {
+        if (isUrlRedirectTarget(url))
+            return;
+        errMsg += ` or a protocol (${pc.string('http://')}, ${pc.string('mailto:')}, ...)`;
+        if (isRedirectTarget === 'unresolved') {
+            if (url === '*')
+                return;
+            errMsg += `, or be ${pc.string('*')}`;
+        }
+    }
+    if (allowRelative) {
+        if (isUrlPathnameRelative(url))
+            return;
+        errMsg += ', or be a relative URL';
+    }
+    assertUsage(false, errMsg);
 }

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

@@ -1,7 +1,4 @@
-export { projectInfo };
-export { PROJECT_VERSION };
-declare const PROJECT_VERSION: "0.4.180";
-declare const projectInfo: {
+export declare const projectInfo: {
     projectName: "Vike";
-    projectVersion: "0.4.180";
+    projectVersion: "0.4.181-commit-ddcbf7d";
 };

package/dist/esm/utils/projectInfo.js

@@ -1,7 +1,5 @@
-export { projectInfo };
-export { PROJECT_VERSION };
-const PROJECT_VERSION = '0.4.180';
-const projectInfo = {
+import { PROJECT_VERSION } from './PROJECT_VERSION.js';
+export const projectInfo = {
     projectName: 'Vike',
     projectVersion: PROJECT_VERSION
 };

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

@@ -0,0 +1 @@
+export declare function redirectHard(url: string): void;

package/dist/esm/utils/redirectHard.js

@@ -0,0 +1,3 @@
+export function redirectHard(url) {
+    window.location.href = url;
+}

package/dist/esm/utils/urlToFile.js

@@ -4,7 +4,7 @@ import { assert } from './assert.js';
 import { parseUrl } from './parseUrl.js';
 import { slice } from './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 = '/';
 function urlToFile(url, fileExtension, doNotCreateExtraDirectory) {
     const { pathnameOriginal, searchOriginal, hashOriginal } = parseUrl(url, baseServer);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.180",
+  "version": "0.4.181-commit-ddcbf7d",
   "scripts": {
     "dev": "tsc --watch",
     "build": "rimraf dist/ && pnpm run build:esm && pnpm run build:cjs",
@@ -15,7 +15,7 @@
   "dependencies": {
     "@brillout/import": "^0.2.3",
     "@brillout/json-serializer": "^0.5.13",
-    "@brillout/picocolors": "^1.0.13",
+    "@brillout/picocolors": "^1.0.14",
     "@brillout/require-shim": "^0.1.2",
     "@brillout/vite-plugin-server-entry": "^0.4.5",
     "acorn": "^8.0.0",
@@ -116,6 +116,15 @@
       "types": "./dist/esm/shared/getPageContext.d.ts",
       "default": "./dist/esm/shared/getPageContext.js"
     },
+    "./modifyUrl": {
+      "worker": "./dist/esm/shared/modifyUrl.js",
+      "edge-light": "./dist/esm/shared/modifyUrl.js",
+      "require": "./dist/cjs/shared/modifyUrl.js",
+      "node": "./dist/esm/shared/modifyUrl.js",
+      "browser": "./dist/esm/shared/modifyUrl.js",
+      "types": "./dist/esm/shared/modifyUrl.d.ts",
+      "default": "./dist/esm/shared/modifyUrl.js"
+    },
     "./__internal": {
       "require": "./dist/cjs/__internal/index.js",
       "node": "./dist/esm/__internal/index.js",
@@ -180,6 +189,12 @@
       "abort": [
         "./dist/esm/shared/abort.d.ts"
       ],
+      "getPageContext": [
+        "./dist/esm/shared/getPageContext.d.ts"
+      ],
+      "modifyUrl": [
+        "./dist/esm/shared/modifyUrl.d.ts"
+      ],
       "__internal": [
         "./dist/esm/__internal/index.d.ts"
       ],
@@ -196,7 +211,7 @@
     "@brillout/import": "^0.2.3",
     "@brillout/json-serializer": "^0.5.8",
     "@brillout/picocolors": "^1.0.13",
-    "@brillout/release-me": "^0.3.8",
+    "@brillout/release-me": "^0.4.0",
     "@brillout/require-shim": "^0.1.2",
     "@brillout/vite-plugin-server-entry": "^0.4.0",
     "@types/estree": "^1.0.5",

package/dist/cjs/utils/isExternalLink.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isExternalLink = void 0;
-function isExternalLink(url) {
-    return !url.startsWith('/') && !url.startsWith('.') && !url.startsWith('?') && url !== '';
-}
-exports.isExternalLink = isExternalLink;

package/dist/cjs/utils/serverSideRouteTo.js

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

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

@@ -1,2 +0,0 @@
-export { isExternalLink };
-declare function isExternalLink(url: string): boolean;

package/dist/esm/utils/isExternalLink.js

@@ -1,4 +0,0 @@
-export { isExternalLink };
-function isExternalLink(url) {
-    return !url.startsWith('/') && !url.startsWith('.') && !url.startsWith('?') && url !== '';
-}

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

@@ -1,2 +0,0 @@
-export { serverSideRouteTo };
-declare function serverSideRouteTo(url: string): void;

package/dist/esm/utils/serverSideRouteTo.js

@@ -1,4 +0,0 @@
-export { serverSideRouteTo };
-function serverSideRouteTo(url) {
-    window.location.href = url;
-}