hifun-tools 1.3.22 → 1.3.24

package/dist/init/__tests/utils.test.js

@@ -1,7 +1,7 @@
 /**
  * @jest-environment jsdom
  */
-import { isIPv4, extractRootDomain, isDomainMatch, toStandardUrl, getOptimalDecodedString, } from "../utils";
+import { isIPv4, isDomainMatch, toStandardUrl, getOptimalDecodedString, } from "../utils";
 // --------------------- isIPv4 -------------------------
 describe("isIPv4", () => {
     test("纯 IPv4", () => {
@@ -17,21 +17,6 @@ describe("isIPv4", () => {
         expect(isIPv4("localhost")).toBe(false);
     });
 });
-// --------------------- extractRootDomain -------------------------
-describe("extractRootDomain", () => {
-    test("普通域名", () => {
-        expect(extractRootDomain("https://sub.example.com")).toBe("example.com");
-    });
-    test("多级后缀", () => {
-        expect(extractRootDomain("a.b.example.com.cn")).toBe("example.com.cn");
-    });
-    test("无协议", () => {
-        expect(extractRootDomain("www.test.co.uk")).toBe("test.co.uk");
-    });
-    test("非法 URL 返回空", () => {
-        expect(extractRootDomain("%%%--非法")).toBe("");
-    });
-});
 // --------------------- isDomainMatch -------------------------
 describe("isDomainMatch", () => {
     test("匹配根域", () => {

package/dist/init/getResource.d.ts

@@ -1,5 +1,5 @@
 /**
- * 通用资源加载函数（支持 Vite 与 Webpack）
+ * 通用资源加载函数（支持 Vite / Webpack / Rspack）
  * @param path - 相对路径，如 "tenant/config.json" 或 "tenant/logo.png"
  */
 export declare function getResource(path: string): any;

package/dist/init/getResource.js

@@ -1,15 +1,38 @@
 /**
- * 通用资源加载函数（支持 Vite 与 Webpack）
+ * 通用资源加载函数（支持 Vite / Webpack / Rspack）
  * @param path - 相对路径，如 "tenant/config.json" 或 "tenant/logo.png"
  */
 export function getResource(path) {
     const isVite = typeof import.meta !== "undefined" && !!import.meta.env;
-    const isWebpack = typeof __webpack_require__ === "function" ||
-        (typeof require !== "undefined" &&
-            typeof require.context === "function");
-    if (isVite) {
-        // ---------------- VITE ----------------
-        const modules = import.meta.glob([
+    // ---------------- 新增 RSPACK 检测 ----------------
+    const isRspack = typeof __rspack_require__ === "function" ||
+        (typeof __webpack_require__ === "function" &&
+            !!__webpack_require__.s && // Rspack 专属字段
+            !__webpack_require__.m); // Webpack 有 m，Rspack 不一定有
+    const isWebpack = !isRspack && // 不冲突：优先识别 Rspack
+        (typeof __webpack_require__ === "function" ||
+            (typeof require !== "undefined" &&
+                typeof require.context === "function"));
+    // ---------------- RSPACK ----------------
+    if (isRspack) {
+        try {
+            const ctx = require.context("/config", true, /\.(json|png|jpg|jpeg|svg|webp)$/);
+            const files = ctx.keys();
+            const match = files.find((key) => key.endsWith(path));
+            if (!match) {
+                console.warn(`[getResource] 未找到文件: ${path}`);
+                return null;
+            }
+            return ctx(match);
+        }
+        catch (e) {
+            console.error("[getResource] Rspack context 加载失败", e);
+        }
+    }
+    // ---------------- VITE ----------------
+    else if (isVite) {
+        const { glob } = import.meta;
+        const modules = glob([
             "/config/**/*.json",
             "/config/**/*.png",
             "/config/**/*.jpg",
@@ -25,11 +48,10 @@ export function getResource(path) {
             console.warn(`[getResource] 未找到文件: ${path}`);
             return null;
         }
-        const [, mod] = match;
-        return mod;
+        return match[1];
     }
-    if (isWebpack) {
-        // ---------------- WEBPACK ----------------
+    // ---------------- WEBPACK ----------------
+    else if (isWebpack) {
         const ctx = require.context("/config", true, /\.(json|png|jpg|jpeg|svg|webp)$/);
         const files = ctx.keys();
         const match = files.find((key) => key.endsWith(path));
@@ -39,6 +61,6 @@ export function getResource(path) {
         }
         return ctx(match);
     }
-    console.error("[getResource] 不支持的构建环境（需要 Vite 或 Webpack）");
+    console.error("[getResource] 不支持的构建环境（需要 Vite/Webpack/Rspack）");
     return null;
 }

package/dist/init/index.js

@@ -70,7 +70,7 @@ class InitCls {
             }
             // 默认租户匹配
             if (host.includes("iggame") || host.includes("localhost")) {
-                console.info(`🏠 iggame匹配到默认租户`);
+                console.info(`🏠 iggame匹配到默认租户2`);
                 return { tenant: "iggame" };
             }
             throw new Error("未找到匹配租户");
@@ -80,8 +80,9 @@ class InitCls {
             const host = location.host;
             if (host.includes("iggame") ||
                 host.includes("localhost") ||
-                location.origin.includes(this.localPath.replace(/\/+$/, ""))) {
-                console.info(`🏠 iggame匹配到默认租户`);
+                (!!this.localPath &&
+                    location.origin.includes(this.localPath.replace(/\/+$/, "")))) {
+                console.info(`🏠 iggame匹配到默认租户1`);
                 return { tenant: "iggame" };
             }
             throw new Error("无法获取有效的租户信息");
@@ -153,10 +154,12 @@ class InitCls {
             return this.domainBaseUrl;
         }
         catch (error) {
+            console.error(error);
             if ((this.defaultBaseUrl &&
                 (location.host.includes("iggame") ||
                     location.host.includes("localhost"))) ||
-                location.origin.includes(this.localPath.replace(/\/+$/, ""))) {
+                (!!this.localPath &&
+                    location.origin.includes(this.localPath.replace(/\/+$/, "")))) {
                 console.info(`🏠 iggame匹配到默认链接`, this.defaultBaseUrl);
                 this.domainBaseUrl = toStandardUrl(this.defaultBaseUrl);
                 return this.domainBaseUrl;

package/dist/init/utils.d.ts

@@ -6,23 +6,7 @@ export type TenantDict = {
 };
 export declare function isIPv4(str: string): boolean;
 export declare function getOptimalDecodedString(encodedArray: string[]): Promise<string>;
-/**
- * 提取主域名（支持多级 TLD）
- */
-export declare function extractRootDomain(url: string): string;
-/**
- * 判断 b 是否匹配 a[] 中任意一个域名
- */
 export declare function isDomainMatch(list: string[], target: string): boolean;
 export declare function toStandardUrl(input: string): string;
-/**
- * 匹配规则：模糊 + 正则 + 不区分大小写
- */
 export declare function matchBrowser(checkItem: string, currentBrowser: string): boolean;
-/**
- * 1. 过滤 browserCheck
- * 2. 按 tenant 过滤
- * 3. 按 groupType（可为空）过滤
- * 4. 与 list2 求交集
- */
 export declare function filterSmartLines(list1: TenantDict[], list2: string[], groupType?: string, tenant?: string): string[];

package/dist/init/utils.js

@@ -18,7 +18,6 @@ export async function getOptimalDecodedString(encodedArray) {
         throw new Error("输入数组为空或无效");
     const hostname = window.location.hostname;
     const isIp = isIPv4(hostname);
-    // ✨ 关键增强：先 trim 再过滤
     const decodedList = encodedArray
         .filter(Boolean)
         .map((v) => v.trim());
@@ -30,7 +29,6 @@ export async function getOptimalDecodedString(encodedArray) {
             return;
         }
         const currentProtocol = window.location.protocol;
-        // 过滤协议
         const filteredArr = arr.filter((url) => url.startsWith("http") ? url.startsWith(currentProtocol) : true);
         const targetArr = filteredArr.length ? filteredArr : arr;
         if (targetArr.length === 1)
@@ -62,77 +60,70 @@ export async function getOptimalDecodedString(encodedArray) {
     return isIp ? await getOptimal(ipList) : await getOptimal(domainList);
 }
 /**
- * 常见多级后缀（Public Suffix List 的子集，可按需扩展）
- * 如 .co.uk、.com.cn、.gov.cn、.org.cn 等
+ * normalizeHost：保留端口，只清理协议
  */
-const MULTI_LEVEL_TLDS = new Set([
-    "co.uk",
-    "org.uk",
-    "gov.uk",
-    "com.cn",
-    "net.cn",
-    "gov.cn",
-    "org.cn",
-    "co.jp",
-    "ne.jp",
-    "or.jp",
-    "go.jp",
-    "com.au",
-    "net.au",
-    "org.au",
-    "co.kr",
-    "ne.kr",
-    "or.kr",
-]);
-/**
- * 提取主域名（支持多级 TLD）
- */
-export function extractRootDomain(url) {
+function normalizeHost(hostname) {
+    hostname = hostname.trim().toLowerCase();
+    // 如果没有协议，加上 http:// 方便 URL 解析
+    let urlStr = hostname;
+    if (!/^https?:\/\//i.test(hostname)) {
+        urlStr = "http://" + hostname;
+    }
     try {
-        url = url.trim(); // ✨ 增加
-        if (!/^https?:\/\//i.test(url)) {
-            url = "http://" + url;
-        }
-        const { hostname } = new URL(url);
-        const parts = hostname.split(".").filter(Boolean);
-        if (parts.length < 2)
-            return hostname;
-        const last2 = parts.slice(-2).join(".");
-        if (MULTI_LEVEL_TLDS.has(last2)) {
-            if (parts.length >= 3) {
-                return parts.slice(-3).join(".");
-            }
-        }
-        return last2;
+        const url = new URL(urlStr);
+        // 保留 hostname + port
+        return url.port ? `${url.hostname}:${url.port}` : url.hostname;
     }
-    catch (e) {
-        return "";
+    catch (_) {
+        return hostname; // 保留原始字符串
     }
 }
 /**
- * 判断 b 是否匹配 a[] 中任意一个域名
+ * 域名严格匹配，允许 www 特例
  */
+function isDomainStrictEqual(a, b) {
+    a = normalizeHost(a);
+    b = normalizeHost(b);
+    if (a === b)
+        return true;
+    const stripWww = (h) => (h.startsWith("www.") ? h.slice(4) : h);
+    return stripWww(a) === stripWww(b);
+}
 export function isDomainMatch(list, target) {
-    const normalizedList = list.map(extractRootDomain).filter(Boolean);
-    const targetDomain = extractRootDomain(target);
-    return normalizedList.includes(targetDomain);
+    const t = normalizeHost(target);
+    return list.some((item) => {
+        const h = normalizeHost(item);
+        return isDomainStrictEqual(h, t);
+    });
 }
 export function toStandardUrl(input) {
     try {
-        input = input.trim(); // ✨ 增加
+        if (!input)
+            return "";
+        input = input.trim();
         let protocol = window?.location?.protocol || "https:";
         if (!/^https?:\/\//i.test(input)) {
             input = protocol + "//" + input;
         }
         const url = new URL(input);
-        return `${url.protocol}//${url.hostname}`;
+        const hostname = url.hostname;
+        const port = url.port;
+        const isHostnameValid = hostname === "localhost" ||
+            (/^[a-zA-Z0-9.-]+$/.test(hostname) &&
+                (hostname.includes(".") || isIPv4(hostname)));
+        if (!isHostnameValid) {
+            return "";
+        }
+        return port
+            ? `${url.protocol}//${hostname}:${port}`
+            : `${url.protocol}//${hostname}`;
     }
     catch (e) {
-        return input;
+        return "";
     }
 }
 /**
- * 浏览器识别：返回一个归一化的浏览器类型字符串
+ * 浏览器识别
  */
 function detectBrowser() {
     const ua = navigator.userAgent.toLowerCase();
@@ -165,17 +156,11 @@ function detectBrowser() {
     }
     return "unknown";
 }
-/**
- * 匹配规则：模糊 + 正则 + 不区分大小写
- */
 export function matchBrowser(checkItem, currentBrowser) {
-    if (!checkItem)
-        return false;
-    if (!currentBrowser)
+    if (!checkItem || !currentBrowser)
         return false;
     const normalized = checkItem.toString().toLowerCase();
     const browser = currentBrowser.toLowerCase();
-    // 正则格式，如 "/uc/i"
     if (normalized.startsWith("/") && normalized.endsWith("/")) {
         try {
             const body = normalized.slice(1, -1);
@@ -184,15 +169,8 @@ export function matchBrowser(checkItem, currentBrowser) {
         }
         catch (_) { }
     }
-    // 字符串模糊匹配
     return browser.includes(normalized);
 }
-/**
- * 1. 过滤 browserCheck
- * 2. 按 tenant 过滤
- * 3. 按 groupType（可为空）过滤
- * 4. 与 list2 求交集
- */
 export function filterSmartLines(list1, list2, groupType, tenant) {
     if (!Array.isArray(list1) || !Array.isArray(list2)) {
         throw new Error("前两个参数必须是数组");
@@ -203,12 +181,10 @@ export function filterSmartLines(list1, list2, groupType, tenant) {
         const blocked = checks.some((checkItem) => matchBrowser(checkItem, currentBrowser));
         return !blocked;
     });
-    if (tenant) {
+    if (tenant)
         result = result.filter((item) => item.tenant === tenant);
-    }
-    if (groupType) {
+    if (groupType)
         result = result.filter((item) => item.lineGroup === groupType);
-    }
     const lines = result.map((item) => toStandardUrl(item.line));
-    return list2.map(toStandardUrl).filter((v) => isDomainMatch(lines, v)); // ✨ 使用域名匹配
+    return list2.map(toStandardUrl).filter((v) => isDomainMatch(lines, v));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hifun-tools",
-  "version": "1.3.22",
+  "version": "1.3.24",
   "main": "dist/index.js",
   "module": "dist/index.js",
   "types": "dist/index.d.ts",