@esmx/router 3.0.0-rc.13 → 3.0.0-rc.16

package/dist/history/abstract.d.ts

@@ -22,7 +22,7 @@ export declare class AbstractHistory extends BaseRouterHistory {
      */
     replaceWindow(location: RouterRawLocation): Promise<void>;
     jump(location: RouterRawLocation, replace?: boolean): Promise<void>;
-    private _jump;
+    _jump(location: RouterRawLocation, replace?: boolean, isTriggerWithWindow?: boolean): Promise<void>;
     go(delta: number): void;
     forward(): void;
     back(): void;

package/dist/history/abstract.mjs

@@ -7,7 +7,6 @@ export class AbstractHistory extends BaseRouterHistory {
     super(router);
     this.index = -1;
     this.stack = [];
-    this.init();
   }
   async init({ replace } = { replace: true }) {
     const { initUrl } = this.router.options;
@@ -35,7 +34,8 @@ export class AbstractHistory extends BaseRouterHistory {
   }
   // 处理外站跳转逻辑
   handleOutside(location, replace = false, isTriggerWithWindow = false) {
-    const { flag, route } = isPathWithProtocolOrDomain(location);
+    const base = this.router.base;
+    const { flag, route } = isPathWithProtocolOrDomain(location, base);
     if (!flag) {
       return false;
     }

package/dist/history/html.d.ts

@@ -1,4 +1,4 @@
-import { type RouterInstance, type RouterRawLocation } from '../types';
+import type { RouterInstance, RouterRawLocation } from '../types';
 import { BaseRouterHistory } from './base';
 export declare class HtmlHistory extends BaseRouterHistory {
     constructor(router: RouterInstance);

package/dist/history/html.mjs

@@ -94,7 +94,8 @@ export class HtmlHistory extends BaseRouterHistory {
   }
   // 处理外站跳转逻辑
   handleOutside(location, replace = false, isTriggerWithWindow = false) {
-    const { flag, route } = isPathWithProtocolOrDomain(location);
+    const base = this.router.base;
+    const { flag, route } = isPathWithProtocolOrDomain(location, base);
     const router = this.router;
     const { handleOutside, validateOutside } = router.options;
     const isSameHost = !flag || window.location.hostname === route.hostname;
@@ -103,13 +104,14 @@ export class HtmlHistory extends BaseRouterHistory {
         return false;
       }
     }
-    if (handleOutside == null ? void 0 : handleOutside({
+    const res = handleOutside == null ? void 0 : handleOutside({
       router,
       route,
       replace,
       isTriggerWithWindow,
       isSameHost
-    })) {
+    });
+    if (res === false) {
       return true;
     }
     if (replace) {

package/dist/utils/path.d.ts

@@ -48,7 +48,7 @@ export declare function normalizeLocation(rawLocation: RouterRawLocation, base?:
 /**
  * 判断路径是否以协议或域名开头
  */
-export declare function isPathWithProtocolOrDomain(location: RouterRawLocation): {
+export declare function isPathWithProtocolOrDomain(location: RouterRawLocation, base?: RouterBase): {
     /**
      * 是否以协议或域名开头
      */

package/dist/utils/path.mjs

@@ -1,3 +1,4 @@
+import normalizeUrl from "normalize-url";
 import URLParse from "url-parse";
 import {
   decode,
@@ -7,7 +8,7 @@ import {
   encodeQueryValue
 } from "./encoding.mjs";
 import { isValidValue } from "./utils.mjs";
-import { warn } from "./warn.mjs";
+import { assert } from "./warn.mjs";
 export const regexDomain = /^(?:https?:\/\/|[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z0-9][a-z0-9-]{0,61}[a-z0-9](\/.*)?/i;
 export const regexScheme = /^(?:[a-z][a-z\d+.-]*:.+)/i;
 export const regexHttpScheme = /^(http(s)?:\/\/)/;
@@ -153,9 +154,20 @@ export function normalizeLocation(rawLocation, base = "") {
   if (params) res.params = params;
   return res;
 }
-export function isPathWithProtocolOrDomain(location) {
+export function isPathWithProtocolOrDomain(location, base = "") {
   let url = "";
   let state = {};
+  let baseString = "";
+  if (typeof base === "string") {
+    baseString = base;
+  } else {
+    baseString = base({
+      fullPath: "",
+      query: {},
+      queryArray: {},
+      hash: ""
+    });
+  }
   if (typeof location === "string") {
     url = location;
   } else {
@@ -175,49 +187,54 @@ export function isPathWithProtocolOrDomain(location) {
       hash: hash2
     });
   }
-  if (regexScheme.test(url) && !regexHttpScheme.test(url)) {
+  try {
+    url = normalizeUrl(url, {
+      stripWWW: false,
+      removeQueryParameters: false
+    });
+  } catch (error) {
     try {
-      const {
-        hash: hash2,
-        host: host2,
-        hostname: hostname2,
-        href: href2,
-        origin: origin2,
-        pathname: pathname2,
-        port: port2,
-        protocol: protocol2,
-        search: search2
-      } = new URL(url);
-      const route2 = {
-        hash: hash2,
-        host: host2,
-        hostname: hostname2,
-        href: href2,
-        origin: origin2,
-        pathname: pathname2,
-        port: port2,
-        protocol: protocol2,
-        search: search2,
-        params: {},
-        query: {},
-        queryArray: {},
-        state,
-        meta: {},
-        path: pathname2,
-        fullPath: url,
-        base: "",
-        matched: []
-      };
-      return {
-        flag: true,
-        route: route2
-      };
-    } catch (error) {
-      warn(error);
+      url = new URL(url, baseString).href;
+    } catch (error2) {
+      assert(false, `Invalid URL: ${url}`);
     }
   }
-  if (!/^https?:\/\//i.test(url)) {
-    url = `http://${url}`;
+  if (regexScheme.test(url) && !regexHttpScheme.test(url)) {
+    const {
+      hash: hash2,
+      host: host2,
+      hostname: hostname2,
+      href: href2,
+      origin: origin2,
+      pathname: pathname2,
+      port: port2,
+      protocol: protocol2,
+      search: search2
+    } = new URL(url);
+    const route2 = {
+      hash: hash2,
+      host: host2,
+      hostname: hostname2,
+      href: href2,
+      origin: origin2,
+      pathname: pathname2,
+      port: port2,
+      protocol: protocol2,
+      search: search2,
+      params: {},
+      query: {},
+      queryArray: {},
+      state,
+      meta: {},
+      path: pathname2,
+      fullPath: url,
+      base: "",
+      matched: []
+    };
+    return {
+      flag: true,
+      route: route2
+    };
   }
   const {
     hash,

package/dist/utils/path.spec.mjs

@@ -1,8 +1,5 @@
 import { describe, it } from "vitest";
-import {
-  normalizeLocation,
-  normalizePath
-} from "./path.mjs";
+import { normalizeLocation, normalizePath } from "./path.mjs";
 describe("testing normalizeLocation", () => {
   it("testing normal domain", ({ expect }) => {
     expect(

package/package.json

@@ -28,12 +28,13 @@
         }
     ],
     "dependencies": {
+        "normalize-url": "^8.0.1",
         "path-to-regexp": "^6.2.2",
         "url-parse": "^1.5.10"
     },
     "devDependencies": {
         "@biomejs/biome": "1.9.4",
-        "@esmx/lint": "3.0.0-rc.13",
+        "@esmx/lint": "3.0.0-rc.16",
         "@gez/lint": "3.0.0-rc.9",
         "@types/node": "22.13.10",
         "@types/url-parse": "^1.4.11",
@@ -43,7 +44,7 @@
         "unbuild": "2.0.0",
         "vitest": "3.0.8"
     },
-    "version": "3.0.0-rc.13",
+    "version": "3.0.0-rc.16",
     "type": "module",
     "private": false,
     "exports": {
@@ -62,5 +63,5 @@
         "template",
         "public"
     ],
-    "gitHead": "801082f89364db5e1137431e3cc1121f689fa7ca"
+    "gitHead": "4d3c88e6751289b4045bffd496859afeb52a5901"
 }

package/src/history/abstract.ts

@@ -15,7 +15,6 @@ export class AbstractHistory extends BaseRouterHistory {
         super(router);
         this.index = -1;
         this.stack = [];
-        this.init();
     }
 
     async init({ replace }: { replace?: boolean } = { replace: true }) {
@@ -55,7 +54,8 @@ export class AbstractHistory extends BaseRouterHistory {
         replace = false,
         isTriggerWithWindow = false
     ) {
-        const { flag, route } = isPathWithProtocolOrDomain(location);
+        const base = this.router.base;
+        const { flag, route } = isPathWithProtocolOrDomain(location, base);
         if (!flag) {
             // 如果不以域名开头则跳出
             return false;
@@ -111,7 +111,7 @@ export class AbstractHistory extends BaseRouterHistory {
         await this._jump(location, replace);
     }
 
-    private async _jump(
+    async _jump(
         location: RouterRawLocation,
         replace = false,
         isTriggerWithWindow = false

package/src/history/html.ts

@@ -1,8 +1,4 @@
-import {
-    type RouterInstance,
-    type RouterRawLocation,
-    StateLayerConfigKey
-} from '../types';
+import type { RouterInstance, RouterRawLocation } from '../types';
 import {
     computeScrollPosition,
     getKeepScrollPosition,
@@ -119,7 +115,8 @@ export class HtmlHistory extends BaseRouterHistory {
         // 是否是 pushWindow/replaceWindow 触发的
         isTriggerWithWindow = false
     ) {
-        const { flag, route } = isPathWithProtocolOrDomain(location);
+        const base = this.router.base;
+        const { flag, route } = isPathWithProtocolOrDomain(location, base);
         const router = this.router;
         const { handleOutside, validateOutside } = router.options;
 
@@ -136,15 +133,15 @@ export class HtmlHistory extends BaseRouterHistory {
 
         // 如果有配置跳转外站函数，则执行配置函数
         // 如果配置函数返回 true 则认为其处理了打开逻辑，跳出
-        if (
-            handleOutside?.({
-                router,
-                route,
-                replace,
-                isTriggerWithWindow,
-                isSameHost
-            })
-        ) {
+        const res = handleOutside?.({
+            router,
+            route,
+            replace,
+            isTriggerWithWindow,
+            isSameHost
+        });
+        if (res === false) {
+            // 如果配置函数返回 false 则跳出
             return true;
         }
 

package/src/utils/path.spec.ts

@@ -1,18 +1,6 @@
 import { describe, it } from 'vitest';
 
-import {
-    isPathWithProtocolOrDomain,
-    normalizeLocation,
-    normalizePath
-} from './path';
-
-// console.log(normalizeLocation({ path: '/' }));
-
-// console.log(isPathWithProtocolOrDomain('/'));
-// console.log(isPathWithProtocolOrDomain('www.a.b'));
-// console.log(isPathWithProtocolOrDomain('a.b.cm'));
-// console.log(isPathWithProtocolOrDomain('http://a.cn'));
-// console.log(isPathWithProtocolOrDomain('a.b/path'));
+import { normalizeLocation, normalizePath } from './path';
 
 describe('testing normalizeLocation', () => {
     it('testing normal domain', ({ expect }) => {

package/src/utils/path.ts

@@ -1,3 +1,4 @@
+import normalizeUrl from 'normalize-url';
 import URLParse from 'url-parse';
 
 import type {
@@ -15,7 +16,7 @@ import {
     encodeQueryValue
 } from './encoding';
 import { isValidValue } from './utils';
-import { warn } from './warn';
+import { assert, warn } from './warn';
 
 /**
  * 判断路径是否以 http 或 https 开头 或者直接是域名开头
@@ -270,7 +271,10 @@ export function normalizeLocation(
 /**
  * 判断路径是否以协议或域名开头
  */
-export function isPathWithProtocolOrDomain(location: RouterRawLocation): {
+export function isPathWithProtocolOrDomain(
+    location: RouterRawLocation,
+    base: RouterBase = ''
+): {
     /**
      * 是否以协议或域名开头
      */
@@ -282,6 +286,17 @@ export function isPathWithProtocolOrDomain(location: RouterRawLocation): {
 } {
     let url = '';
     let state = {};
+    let baseString = '';
+    if (typeof base === 'string') {
+        baseString = base;
+    } else {
+        baseString = base({
+            fullPath: '',
+            query: {},
+            queryArray: {},
+            hash: ''
+        });
+    }
 
     if (typeof location === 'string') {
         url = location;
@@ -303,51 +318,56 @@ export function isPathWithProtocolOrDomain(location: RouterRawLocation): {
         });
     }
 
-    // 如果以 scheme 协议开头 并且不是 http(s) 协议开头 则认为是外站跳转
-    if (regexScheme.test(url) && !regexHttpScheme.test(url)) {
+    try {
+        url = normalizeUrl(url, {
+            stripWWW: false,
+            removeQueryParameters: false
+        });
+    } catch (error) {
         try {
-            const {
-                hash,
-                host,
-                hostname,
-                href,
-                origin,
-                pathname,
-                port,
-                protocol,
-                search
-            } = new URL(url);
-            const route: Route = {
-                hash,
-                host,
-                hostname,
-                href,
-                origin,
-                pathname,
-                port,
-                protocol,
-                search,
-                params: {},
-                query: {},
-                queryArray: {},
-                state,
-                meta: {},
-                path: pathname,
-                fullPath: url,
-                base: '',
-                matched: []
-            };
-            return {
-                flag: true,
-                route
-            };
+            url = new URL(url, baseString).href;
         } catch (error) {
-            warn(error);
+            assert(false, `Invalid URL: ${url}`);
         }
     }
 
-    if (!/^https?:\/\//i.test(url)) {
-        url = `http://${url}`;
+    // 如果以 scheme 协议开头 并且不是 http(s) 协议开头 则认为是外站跳转
+    if (regexScheme.test(url) && !regexHttpScheme.test(url)) {
+        const {
+            hash,
+            host,
+            hostname,
+            href,
+            origin,
+            pathname,
+            port,
+            protocol,
+            search
+        } = new URL(url);
+        const route: Route = {
+            hash,
+            host,
+            hostname,
+            href,
+            origin,
+            pathname,
+            port,
+            protocol,
+            search,
+            params: {},
+            query: {},
+            queryArray: {},
+            state,
+            meta: {},
+            path: pathname,
+            fullPath: url,
+            base: '',
+            matched: []
+        };
+        return {
+            flag: true,
+            route
+        };
     }
 
     const {