@whitesev/utils 2.3.0 → 2.3.2

package/dist/index.system.js

@@ -1582,7 +1582,7 @@ System.register('Utils', [], (function (exports) {
                             return uuid;
                         }
                         else {
-                            console.warn("HttpxRequestHook.addBeforeRequestCallBack: fn is not a function");
+                            console.warn("[Httpx-HttpxRequestHook.addBeforeRequestCallBack] fn is not a function");
                         }
                     },
                     /**
@@ -2061,65 +2061,81 @@ System.register('Utils', [], (function (exports) {
                      */
                     onLoad(details, resolve, reject, argumentsList) {
                         /* X浏览器会因为设置了responseType导致不返回responseText */
-                        let Response = argumentsList[0];
+                        let originResponse = argumentsList[0];
                         /* responseText为空，response不为空的情况 */
-                        if (utils.isNull(Response["responseText"]) &&
-                            utils.isNotNull(Response["response"])) {
-                            if (typeof Response["response"] === "object") {
+                        if (utils.isNull(originResponse["responseText"]) &&
+                            utils.isNotNull(originResponse["response"])) {
+                            if (typeof originResponse["response"] === "object") {
                                 utils.tryCatch().run(() => {
-                                    Response["responseText"] = JSON.stringify(Response["response"]);
+                                    originResponse["responseText"] = JSON.stringify(originResponse["response"]);
                                 });
                             }
                             else {
-                                Response["responseText"] = Response["response"];
+                                originResponse["responseText"] = originResponse["response"];
                             }
                         }
                         /* response为空，responseText不为空的情况 */
-                        if (Response["response"] == null &&
-                            typeof Response["responseText"] === "string" &&
-                            Response["responseText"].trim() !== "") {
-                            let newResponse = Response["responseText"];
+                        if (originResponse["response"] == null &&
+                            typeof originResponse["responseText"] === "string" &&
+                            originResponse["responseText"].trim() !== "") {
+                            /** 原始的请求text */
+                            let httpxResponseText = originResponse.responseText;
+                            // 自定义个新的response
+                            let httpxResponse = httpxResponseText;
                             if (details.responseType === "json") {
-                                newResponse = utils.toJSON(Response["responseText"]);
+                                httpxResponse = utils.toJSON(httpxResponseText);
                             }
                             else if (details.responseType === "document") {
                                 let parser = new DOMParser();
-                                newResponse = parser.parseFromString(Response["responseText"], "text/html");
+                                httpxResponse = parser.parseFromString(httpxResponseText, "text/html");
                             }
                             else if (details.responseType === "arraybuffer") {
                                 let encoder = new TextEncoder();
-                                let arrayBuffer = encoder.encode(Response["responseText"]);
-                                newResponse = arrayBuffer;
+                                let arrayBuffer = encoder.encode(httpxResponseText);
+                                httpxResponse = arrayBuffer;
                             }
                             else if (details.responseType === "blob") {
                                 let encoder = new TextEncoder();
-                                let arrayBuffer = encoder.encode(Response["responseText"]);
-                                newResponse = new Blob([arrayBuffer]);
-                            }
-                            else {
-                                newResponse = Response["responseText"];
+                                let arrayBuffer = encoder.encode(httpxResponseText);
+                                httpxResponse = new Blob([arrayBuffer]);
                             }
+                            // 尝试覆盖原response
                             try {
-                                Response["response"] = newResponse;
+                                let setStatus = Reflect.set(originResponse, "response", httpxResponse);
+                                if (!setStatus) {
+                                    console.warn("[Httpx-HttpxCallBack.oonLoad] 覆盖原始 response 失败，尝试添加新的httpxResponse");
+                                    try {
+                                        Reflect.set(originResponse, "httpxResponse", httpxResponse);
+                                    }
+                                    catch (error) {
+                                        console.warn("[Httpx-HttpxCallBack.oonLoad] httpxResponse 无法被覆盖");
+                                    }
+                                }
                             }
                             catch (error) {
-                                console.warn("response 无法被覆盖");
+                                console.warn("[Httpx-HttpxCallBack.oonLoad] 原始 response 无法被覆盖，尝试添加新的httpxResponse");
+                                try {
+                                    Reflect.set(originResponse, "httpxResponse", httpxResponse);
+                                }
+                                catch (error) {
+                                    console.warn("[Httpx-HttpxCallBack.oonLoad] httpxResponse 无法被覆盖");
+                                }
                             }
                         }
                         /* Stay扩展中没有finalUrl，对应的是responseURL */
-                        if (Response["finalUrl"] == null &&
-                            Response["responseURL"] != null) {
-                            Response["finalUrl"] = Response["responseURL"];
+                        let originResponseURL = Reflect.get(originResponse, "responseURL");
+                        if (originResponse["finalUrl"] == null && originResponseURL != null) {
+                            Reflect.set(originResponse, "finalUrl", originResponseURL);
                         }
                         /* 状态码2xx都是成功的 */
-                        if (Math.floor(Response.status / 100) === 2) {
-                            if (this.context.HttpxResponseHook.successResponseCallBack(Response, details) == null) {
+                        if (Math.floor(originResponse.status / 100) === 2) {
+                            if (this.context.HttpxResponseHook.successResponseCallBack(originResponse, details) == null) {
                                 // reject(new TypeError("response is intercept with onloada"));
                                 return;
                             }
                             resolve({
                                 status: true,
-                                data: Response,
+                                data: originResponse,
                                 details: details,
                                 msg: "请求完毕",
                                 type: "onload",
@@ -2164,7 +2180,7 @@ System.register('Utils', [], (function (exports) {
                      */
                     request(details) {
                         if (this.context.#LOG_DETAILS) {
-                            console.log("Httpx请求配置👇", details);
+                            console.log("[Httpx-HttpxRequest.request] 请求前的配置👇", details);
                         }
                         if (typeof this.context.HttpxRequestHook.beforeRequestCallBack ===
                             "function") {
@@ -2197,33 +2213,38 @@ System.register('Utils', [], (function (exports) {
                      */
                     fetch(details, fetchRequestInit, abortController) {
                         fetch(details.url, fetchRequestInit)
-                            .then(async (resp) => {
-                            /**
-                             * @type {HttpxAsyncResultData}
-                             */
+                            .then(async (fetchResponse) => {
+                            /** 自定义的response */
                             let httpxResponse = {
                                 isFetch: true,
-                                finalUrl: resp.url,
+                                finalUrl: fetchResponse.url,
                                 readyState: 4,
-                                status: resp.status,
-                                statusText: resp.statusText,
+                                // @ts-ignore
+                                status: fetchResponse.status,
+                                statusText: fetchResponse.statusText,
                                 response: void 0,
-                                responseFetchHeaders: resp.headers,
+                                responseFetchHeaders: fetchResponse.headers,
                                 responseHeaders: "",
+                                // @ts-ignore
                                 responseText: void 0,
                                 responseType: details.responseType,
                                 responseXML: void 0,
                             };
                             Object.assign(httpxResponse, details.context || {});
-                            for (const [key, value] of resp.headers.entries()) {
+                            // 把headers转为字符串
+                            for (const [key, value] of fetchResponse.headers.entries()) {
                                 httpxResponse.responseHeaders += `${key}: ${value}\n`;
                             }
-                            /* 如果是流式传输，直接返回 */
+                            /** 请求返回的类型 */
+                            const fetchResponseType = fetchResponse.headers.get("Content-Type");
+                            /* 如果需要stream，且获取到的是stream，那直接返回 */
                             if (details.responseType === "stream" ||
-                                (resp.headers.has("Content-Type") &&
-                                    resp.headers.get("Content-Type").includes("text/event-stream"))) {
-                                httpxResponse["isStream"] = true;
-                                httpxResponse.response = resp.body;
+                                (fetchResponse.headers.has("Content-Type") &&
+                                    fetchResponse.headers
+                                        .get("Content-Type")
+                                        .includes("text/event-stream"))) {
+                                Reflect.set(httpxResponse, "isStream", true);
+                                Reflect.set(httpxResponse, "response", fetchResponse.body);
                                 Reflect.deleteProperty(httpxResponse, "responseText");
                                 Reflect.deleteProperty(httpxResponse, "responseXML");
                                 details.onload(httpxResponse);
@@ -2235,42 +2256,57 @@ System.register('Utils', [], (function (exports) {
                             let responseText = "";
                             /** 响应xml文档 */
                             let responseXML = "";
-                            let arrayBuffer = await resp.arrayBuffer();
+                            /** 先获取二进制数据 */
+                            let arrayBuffer = await fetchResponse.arrayBuffer();
+                            /** 数据编码 */
                             let encoding = "utf-8";
-                            if (resp.headers.has("Content-Type")) {
-                                let charsetMatched = resp.headers
+                            if (fetchResponse.headers.has("Content-Type")) {
+                                let charsetMatched = fetchResponse.headers
                                     .get("Content-Type")
                                     ?.match(/charset=(.+)/);
                                 if (charsetMatched) {
                                     encoding = charsetMatched[1];
+                                    encoding = encoding.toLowerCase();
                                 }
                             }
+                            // Failed to construct 'TextDecoder': The encoding label provided ('"UTF-8"') is invalid.
+                            // 去除引号
+                            encoding = encoding.replace(/('|")/gi, "");
+                            // 编码
                             let textDecoder = new TextDecoder(encoding);
                             responseText = textDecoder.decode(arrayBuffer);
                             response = responseText;
                             if (details.responseType === "arraybuffer") {
+                                // response返回格式是二进制流
                                 response = arrayBuffer;
                             }
                             else if (details.responseType === "blob") {
+                                // response返回格式是blob
                                 response = new Blob([arrayBuffer]);
                             }
+                            else if (details.responseType === "json" ||
+                                (typeof fetchResponseType === "string" &&
+                                    fetchResponseType.includes("application/json"))) {
+                                // response返回格式是JSON格式
+                                response = utils.toJSON(responseText);
+                            }
                             else if (details.responseType === "document" ||
                                 details.responseType == null) {
+                                // response返回格式是文档格式
                                 let parser = new DOMParser();
                                 response = parser.parseFromString(responseText, "text/html");
                             }
-                            else if (details.responseType === "json") {
-                                response = utils.toJSON(responseText);
-                            }
+                            // 转为XML结构
                             let parser = new DOMParser();
                             responseXML = parser.parseFromString(responseText, "text/xml");
-                            httpxResponse.response = response;
-                            httpxResponse.responseText = responseText;
-                            httpxResponse.responseXML = responseXML;
+                            Reflect.set(httpxResponse, "response", response);
+                            Reflect.set(httpxResponse, "responseText", responseText);
+                            Reflect.set(httpxResponse, "responseXML", responseXML);
+                            // 执行回调
                             details.onload(httpxResponse);
                         })
-                            .catch((err) => {
-                            if (err.name === "AbortError") {
+                            .catch((error) => {
+                            if (error.name === "AbortError") {
                                 return;
                             }
                             details.onerror({
@@ -2281,7 +2317,7 @@ System.register('Utils', [], (function (exports) {
                                 statusText: "",
                                 responseHeaders: "",
                                 responseText: "",
-                                error: err,
+                                error: error,
                             });
                         });
                         details.onloadstart({
@@ -2344,7 +2380,7 @@ System.register('Utils', [], (function (exports) {
                  */
                 constructor(__xmlHttpRequest__) {
                     if (typeof __xmlHttpRequest__ !== "function") {
-                        console.warn("Httpx未传入GM_xmlhttpRequest函数或传入的GM_xmlhttpRequest不是Function，强制使用window.fetch");
+                        console.warn("[Httpx-constructor] 未传入GM_xmlhttpRequest函数或传入的GM_xmlhttpRequest不是Function，将默认使用window.fetch");
                     }
                     this.interceptors.request.context = this;
                     this.interceptors.response.context = this;
@@ -6408,13 +6444,29 @@ System.register('Utils', [], (function (exports) {
                  * > ()=>{throw new Error('测试错误')}出现错误
                  */
                 tryCatch = TryCatch;
-                uniqueArray(uniqueArrayData = [], compareArrayData = [], compareFun = (item, item2) => {
-                    // @ts-ignore
+                uniqueArray(uniqueArrayData = [], compareArrayData, compareFun = (item, item2) => {
                     return item === item2;
                 }) {
-                    return Array.from(uniqueArrayData).filter((item) => !Array.from(compareArrayData).some(function (item2) {
-                        return compareFun(item, item2);
-                    }));
+                    if (typeof compareArrayData === "function") {
+                        const compareFn = compareArrayData;
+                        const seen = new Set();
+                        const result = [];
+                        for (const item of uniqueArrayData) {
+                            // 使用compareFn函数来获取当前对象的唯一标识
+                            const identfier = compareFn(item);
+                            // 如果Set中还没有这个标识，则添加到结果数组中，并将其标识存入Set
+                            if (!seen.has(identfier)) {
+                                seen.add(identfier);
+                                result.push(item);
+                            }
+                        }
+                        return result;
+                    }
+                    else {
+                        return Array.from(uniqueArrayData).filter((item) => !Array.from(compareArrayData).some(function (item2) {
+                            return compareFun(item, item2);
+                        }));
+                    }
                 }
                 waitArrayLoopToEnd(data, handleFunc) {
                     let UtilsContext = this;