refactor(tests): update test descriptions to English and improve normalization logic in location functions

Author: lzxb

packages/router/src/location.test.ts

@@ -24,7 +24,7 @@ expect.extend({
         // biome-ignore lint/correctness/noSelfAssign:
         expected.hash = expected.hash;
         return {
-            message: () => `输出 ${received.href} 应该为 ${expected.href}`,
+            message: () => `expected ${received.href} to be ${expected.href}`,
             pass: received.href === expected.href
         };
     }
@@ -41,37 +41,39 @@ describe('normalizeURL', () => {
             input: '//example.com/path',
             base: 'https://github.com',
             expected: 'http://example.com/path',
-            description: '应该处理协议相对路径(以//开头)'
+            description:
+                'should handle protocol-relative URLs (starting with //)'
         },
         {
             input: 'http://github.com/path?a#h',
             base: 'http://example.com',
             expected: 'http://github.com/path?a#h',
-            description: '应该处理绝对URL'
+            description: 'should handle absolute URLs'
         },
         {
             input: '/path',
             base: 'http://example.com/en/',
             expected: 'http://example.com/en/path',
-            description: '应该处理带基URL的相对路径'
+            description: 'should handle relative paths with a base URL'
         },
         {
             input: 'github.com',
             base: 'http://example.com',
             expected: 'http://example.com/github.com',
-            description: '裸域名应该当做相对路径处理'
+            description: 'should treat bare domains as relative paths'
         },
         {
             input: new URL('http://example.com/path'),
             base: 'http://example.com',
             expected: 'http://example.com/path',
-            description: '应该处理URL对象'
+            description: 'should handle URL objects'
         },
         {
             input: '-a://example.com',
             base: 'http://example.com',
             expected: 'http://example.com/-a://example.com',
-            description: '协议开头但解析失败后应该当做相对路径'
+            description:
+                'should treat strings that fail to parse as a protocol as relative paths'
         }
     ];
 
@@ -94,19 +96,19 @@ describe('parseLocation', () => {
             input: '/products',
             base: 'http://example.com',
             expected: 'http://example.com/products',
-            description: '应该处理字符串路径'
+            description: 'should handle string paths'
         },
         {
             input: { path: '/products' },
             base: 'http://example.com',
             expected: 'http://example.com/products',
-            description: '应该处理带path属性的对象'
+            description: 'should handle objects with a path property'
         },
         {
             input: { url: '/products' },
             base: 'http://example.com',
             expected: 'http://example.com/products',
-            description: '应该处理带url属性的对象'
+            description: 'should handle objects with a url property'
         },
         {
             input: {
@@ -115,19 +117,19 @@ describe('parseLocation', () => {
             },
             base: 'http://example.com',
             expected: 'http://example.com/products?id=123&category=electronics',
-            description: '应该处理带query参数的对象'
+            description: 'should handle objects with query parameters'
         },
         {
             input: { path: '/products', query: { id: '123' }, hash: 'details' },
             base: 'http://example.com',
             expected: 'http://example.com/products?id=123#details',
-            description: '应该处理带hash的对象'
+            description: 'should handle objects with a hash'
         },
         {
             input: { path: '/products', queryArray: { tag: ['new', 'sale'] } },
             base: 'http://example.com',
             expected: 'http://example.com/products?tag=new&tag=sale',
-            description: '应该处理带queryArray的对象'
+            description: 'should handle objects with queryArray'
         },
         {
             input: {
@@ -139,7 +141,7 @@ describe('parseLocation', () => {
             base: 'http://example.com',
             expected:
                 'http://example.com/products?id=123&category=electronics&tag=new&tag=sale#details',
-            description: '应该处理带所有属性的复杂对象'
+            description: 'should handle complex objects with all properties'
         },
         {
             input: {
@@ -148,7 +150,7 @@ describe('parseLocation', () => {
             },
             base: 'http://example.com',
             expected: 'http://example.com/products#a?a',
-            description: '特殊 hash 字符应该被正确处理'
+            description: 'should handle special hash characters correctly'
         },
         {
             input: {
@@ -157,7 +159,7 @@ describe('parseLocation', () => {
             },
             base: 'http://example.com',
             expected: 'http://example.com/products#a?a#b',
-            description: '特殊 hash 字符应该被正确处理'
+            description: 'should handle special hash characters correctly'
         },
         {
             input: {
@@ -180,13 +182,14 @@ describe('parseLocation', () => {
             expected: `http://example.com/products?symbol=Symbol()&fn=${String(
                 async () => ''
             )}&obj=${String({})}&big=12345678901234567891234567890123456789&b&c=0&d=0&e=1`,
-            description: '应该忽略null、undefined和NaN的query参数'
+            description:
+                'should ignore null, undefined, and NaN query parameters'
         },
         {
             input: { path: '/products', queryArray: { tag: [] } },
             base: 'http://example.com',
             expected: 'http://example.com/products',
-            description: '应该处理空queryArray'
+            description: 'should handle empty queryArray'
         },
         {
             input: {
@@ -195,7 +198,7 @@ describe('parseLocation', () => {
             },
             base: 'http://example.com',
             expected: 'http://example.com/products?id=query&a',
-            description: 'query的值应覆盖path中的query参数'
+            description: 'query value should override query parameter in path'
         },
         {
             input: {
@@ -205,7 +208,8 @@ describe('parseLocation', () => {
             },
             base: 'http://example.com',
             expected: 'http://example.com/products?id=queryArray&a',
-            description: 'queryArray的值应覆盖query和path中的query参数'
+            description:
+                'queryArray value should override query and path parameters'
         },
         {
             input: {
@@ -214,7 +218,8 @@ describe('parseLocation', () => {
             },
             base: 'http://example.com',
             expected: 'http://example.com/products?id=queryArray&a',
-            description: 'queryArray的值应覆盖path中的query参数'
+            description:
+                'queryArray value should override query parameter in path'
         },
         {
             input: {
@@ -224,7 +229,8 @@ describe('parseLocation', () => {
             },
             base: 'http://example.com',
             expected: 'http://example.com?a&a',
-            description: '应正确处理空字符串和重复的query参数'
+            description:
+                'should handle empty strings and duplicate query parameters correctly'
         },
         {
             input: { path: '/products?id=123', url: '/products?id=456' },

packages/router/src/location.ts

@@ -1,42 +1,75 @@
 import type { RouteLocationInput } from './types';
 import { isNotNullish } from './util';
 
+/**
+ * Normalizes a URL input into a URL object.
+ * @param url - The URL or string to normalize.
+ * @param base - The base URL to resolve against if the input is relative.
+ * @returns A URL object.
+ */
 export function normalizeURL(url: string | URL, base: URL): URL {
-    if (typeof url === 'string') {
-        // 处理协议相对路径（以//开头）
-        if (url.startsWith('//')) {
-            return new URL(`http:${url}`);
-        }
-        // 相对于根的路径（根为 base）
-        if (url.startsWith('/')) {
-            base = new URL('.', base);
-            const parsed = new URL(url, base);
-            parsed.pathname = base.pathname.slice(0, -1) + parsed.pathname; // 确保路径正确
-            return parsed;
-        }
+    if (url instanceof URL) {
+        return url;
+    }
+
+    // Handle protocol-relative URLs (e.g., //example.com)
+    if (url.startsWith('//')) {
+        // Using http: as a default protocol for protocol-relative URLs.
+        return new URL(`http:${url}`);
+    }
+
+    // Handle root-relative paths
+    if (url.startsWith('/')) {
+        const newBase = new URL('.', base);
+        const parsed = new URL(url, newBase);
+        // This ensures that the path is resolved relative to the base's path directory.
+        parsed.pathname = newBase.pathname.slice(0, -1) + parsed.pathname;
+        return parsed;
+    }
+
+    try {
+        // Try to parse as an absolute URL.
+        // This is the WHATWG standard approach (new URL()) and works consistently across all modern browsers and Node.js.
+        // We use a try-catch block because the standard URL constructor throws an error for invalid URLs.
+        //
+        // NOTE: While `URL.parse()` might be observed in Chromium-based browsers (e.g., Chrome, Edge),
+        // it is a non-standard, legacy feature implemented by the V8 engine for Node.js compatibility.
+        // It is not part of the WHATWG URL Standard and is not supported by other browsers like Firefox or Safari.
+        // Therefore, relying on it would compromise cross-browser compatibility.
+        return new URL(url);
+    } catch (e) {
+        // Otherwise, parse as a relative URL
+        return new URL(url, base);
     }
-    return URL.parse(url) || new URL(url, base);
 }
 
+/**
+ * Parses a RouteLocationInput object into a full URL.
+ * @param toInput - The route location input.
+ * @param baseURL - The base URL to resolve against.
+ * @returns The parsed URL object.
+ */
 export function parseLocation(toInput: RouteLocationInput, baseURL: URL): URL {
     if (typeof toInput === 'string') {
         return normalizeURL(toInput, baseURL);
     }
     const url = normalizeURL(toInput.path ?? toInput.url ?? '', baseURL);
     const searchParams = url.searchParams;
 
-    // 优先级 queryArray > query > path中的query
+    // Priority: queryArray > query > query in path
     Object.entries<string | (string | undefined)[]>(
         Object.assign({}, toInput.query, toInput.queryArray)
     ).forEach(([key, value]) => {
-        searchParams.delete(key); // 清除之前的同名参数
+        searchParams.delete(key); // Clear previous params with the same name
         value = Array.isArray(value) ? value : [value];
-        value.filter(isNotNullish).forEach((v) => {
-            searchParams.append(key, String(v));
-        });
+        value
+            .filter((v) => isNotNullish(v) && !Number.isNaN(v))
+            .forEach((v) => {
+                searchParams.append(key, String(v));
+            });
     });
 
-    // 设置hash值（URL片段标识符）
+    // Set the hash (URL fragment identifier)
     if (toInput.hash) {
         url.hash = toInput.hash;
     }