@whitesev/utils 1.4.6 → 1.4.7

package/dist/index.umd.js

@@ -1429,17 +1429,147 @@
         }
     }
 
+    const GenerateUUID = () => {
+        return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function (c) {
+            var r = (Math.random() * 16) | 0, v = c == "x" ? r : (r & 0x3) | 0x8;
+            return v.toString(16);
+        });
+    };
     class Httpx {
         GM_Api = {
             xmlHttpRequest: null,
         };
         HttpxRequestHook = {
+            /**
+             * @private
+             */
+            $config: {
+                configList: [],
+            },
             /**
              * 发送请求前的回调
              * 如果返回false则阻止本次返回
              * @param details 当前的请求配置
+             * @private
+             */
+            beforeRequestCallBack(details) {
+                for (let index = 0; index < this.$config.configList.length; index++) {
+                    let item = this.$config.configList[index];
+                    if (typeof item.fn === "function") {
+                        let result = item.fn(details);
+                        if (result == null) {
+                            return;
+                        }
+                    }
+                }
+                return details;
+            },
+            /**
+             * 添加请求前的回调处理配置
+             */
+            addBeforeRequestCallBack(fn) {
+                if (typeof fn === "function") {
+                    let uuid = GenerateUUID();
+                    this.$config.configList.push({
+                        id: uuid,
+                        fn: fn,
+                    });
+                    return uuid;
+                }
+                else {
+                    console.warn("HttpxRequestHook.addBeforeRequestCallBack: fn is not a function");
+                }
+            },
+            /**
+             * 删除请求前的回调处理配置
+             * @param id
+             */
+            deleteBeforeRequestCallBack(id) {
+                if (typeof id === "string") {
+                    let findIndex = this.$config.configList.findIndex((item) => item.id === id);
+                    if (findIndex !== -1) {
+                        this.$config.configList.splice(findIndex, 1);
+                        return true;
+                    }
+                }
+                return false;
+            },
+            /**
+             * 清空设置的请求前的回调处理配置
+             */
+            clearBeforeRequestCallBack() {
+                this.$config.configList = [];
+            },
+        };
+        HttpxResponseHook = {
+            /**
+             * @private
+             */
+            $config: {
+                configList: [],
+            },
+            /**
+             * 成功的回调
+             * @param response
+             */
+            successResponseCallBack(response) {
+                for (let index = 0; index < this.$config.configList.length; index++) {
+                    let item = this.$config.configList[index];
+                    if (typeof item.successFn === "function") {
+                        if (item.successFn(response) == null) {
+                            return;
+                        }
+                    }
+                }
+                return response;
+            },
+            /**
+             * 失败的回调
+             * @param response
+             */
+            errorResponseCallBack(response) {
+                for (let index = 0; index < this.$config.configList.length; index++) {
+                    let item = this.$config.configList[index];
+                    if (typeof item.errorFn === "function") {
+                        if (item.errorFn(response) == null) {
+                            return;
+                        }
+                    }
+                }
+                return response;
+            },
+            /**
+             * 添加请求前的回调处理配置
              */
-            beforeRequestCallBack(details) { },
+            addAfterResponseCallBack(successFn, errorFn) {
+                let id = GenerateUUID();
+                this.$config.configList.push({
+                    id: id,
+                    successFn: successFn,
+                    errorFn: errorFn,
+                });
+                return id;
+            },
+            /**
+             * 删除请求前的回调处理配置
+             * @param id
+             */
+            deleteAfterResponseCallBack(id) {
+                if (typeof id === "string") {
+                    let findIndex = this.$config.configList.findIndex((item) => item.id === id);
+                    if (findIndex !== -1) {
+                        this.$config.configList.splice(findIndex, 1);
+                        return true;
+                    }
+                }
+                return false;
+            },
+            /**
+             * 清空设置的请求前的回调处理配置
+             */
+            clearAfterResponseCallBack() {
+                this.$config.configList = [];
+            },
         };
         HttpxRequestDetails = {
             context: this,
@@ -1831,7 +1961,7 @@
                 if (typeof this.context.HttpxRequestHook.beforeRequestCallBack ===
                     "function") {
                     let hookResult = this.context.HttpxRequestHook.beforeRequestCallBack(details);
-                    if (typeof hookResult === "boolean" && !hookResult) {
+                    if (hookResult == null) {
                         return;
                     }
                 }
@@ -1999,6 +2129,8 @@
             if (typeof __xmlHttpRequest__ !== "function") {
                 console.warn("Httpx未传入GM_xmlhttpRequest函数或传入的GM_xmlhttpRequest不是Function，强制使用window.fetch");
             }
+            this.interceptors.request = this;
+            this.interceptors.response = this;
             this.GM_Api.xmlHttpRequest = __xmlHttpRequest__;
         }
         /**
@@ -2011,6 +2143,58 @@
             }
             this.#defaultDetails = utils.assign(this.#defaultDetails, details);
         }
+        /**
+         * 拦截器
+         */
+        interceptors = {
+            /**
+             * 请求拦截器
+             */
+            request: {
+                context: null,
+                /**
+                 * 添加拦截器
+                 * @param fn 设置的请求前回调函数，如果返回配置，则使用返回的配置，如果返回null|undefined，则阻止请求
+                 */
+                use(fn) {
+                    return this.context.HttpxRequestHook.addBeforeRequestCallBack(fn);
+                },
+                /**
+                 * 移除拦截器
+                 * @param id 通过use返回的id
+                 */
+                eject(id) {
+                    return this.context.HttpxRequestHook.deleteBeforeRequestCallBack(id);
+                },
+            },
+            /**
+             * 响应拦截器
+             */
+            response: {
+                context: null,
+                /**
+                 * 添加拦截器
+                 * @param successFn 设置的响应后回调函数，如果返回响应，则使用返回的响应，如果返回null|undefined，则阻止响应
+                 * + 2xx 范围内的状态码都会触发该函数
+                 * @param errorFn 设置的响应后回调函数，如果返回响应，则使用返回的响应，如果返回null|undefined，则阻止响应
+                 * + 超出 2xx 范围的状态码都会触发该函数
+                 */
+                use(successFn, errorFn) {
+                    if (typeof successFn !== "function" && typeof errorFn !== "function") {
+                        console.warn("[Httpx] 请传入拦截器函数");
+                        return;
+                    }
+                    return this.context.HttpxResponseHook.addAfterResponseCallBack(successFn, errorFn);
+                },
+                /**
+                 * 移除拦截器
+                 * @param id 通过use返回的id
+                 */
+                eject(id) {
+                    return this.context.HttpxResponseHook.deleteAfterResponseCallBack(id);
+                },
+            },
+        };
         /**
          * 修改xmlHttpRequest
          * @param httpRequest 网络请求函数