@whitesev/utils 2.2.9 → 2.3.1

package/dist/index.iife.js

@@ -1580,7 +1580,7 @@ var Utils = (function () {
                     return uuid;
                 }
                 else {
-                    console.warn("HttpxRequestHook.addBeforeRequestCallBack: fn is not a function");
+                    console.warn("[Httpx-HttpxRequestHook.addBeforeRequestCallBack] fn is not a function");
                 }
             },
             /**
@@ -2059,65 +2059,81 @@ var Utils = (function () {
              */
             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",
@@ -2162,7 +2178,7 @@ var Utils = (function () {
              */
             request(details) {
                 if (this.context.#LOG_DETAILS) {
-                    console.log("Httpx请求配置👇", details);
+                    console.log("[Httpx-HttpxRequest.request] 请求前的配置👇", details);
                 }
                 if (typeof this.context.HttpxRequestHook.beforeRequestCallBack ===
                     "function") {
@@ -2195,33 +2211,38 @@ var Utils = (function () {
              */
             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);
@@ -2233,42 +2254,57 @@ var Utils = (function () {
                     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({
@@ -2279,7 +2315,7 @@ var Utils = (function () {
                         statusText: "",
                         responseHeaders: "",
                         responseText: "",
-                        error: err,
+                        error: error,
                     });
                 });
                 details.onloadstart({
@@ -2342,7 +2378,7 @@ var Utils = (function () {
          */
         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;
@@ -3648,6 +3684,245 @@ var Utils = (function () {
         }
     }
 
+    const VueUtils = {
+        /** 标签 */
+        ReactiveFlags: {
+            IS_REACTIVE: Symbol("isReactive"),
+        },
+        /**
+         * 判断是否是对象
+         * @param value
+         */
+        isObject(value) {
+            return typeof value === "object" && value !== null;
+        },
+        /**
+         * 判断是否是函数
+         * @param val
+         */
+        isFunction(val) {
+            return typeof val === "function";
+        },
+        /**
+         * 处理对象再次代理，可以直接返回
+         * @param value
+         */
+        isReactive(value) {
+            return !!(value && value[VueUtils.ReactiveFlags.IS_REACTIVE]);
+        },
+        /**
+         * 判断是否是数组
+         * @param value
+         */
+        isArray(value) {
+            return Array.isArray(value);
+        },
+    };
+    class ReactiveEffect {
+        deps = [];
+        active = true;
+        fn;
+        // @ts-ignore
+        scheduler;
+        constructor(fn, scheduler) {
+            this.fn = fn;
+            this.scheduler = scheduler;
+        }
+        run(cb) {
+            if (!this.active) {
+                this.fn();
+            }
+            try {
+                if (typeof cb === "function") {
+                    cb(this);
+                }
+                return this.fn();
+            }
+            finally {
+                if (typeof cb === "function") {
+                    cb(undefined);
+                }
+            }
+        }
+    }
+    class RefImpl {
+        _value;
+        _isRef = true;
+        _rawValue;
+        _vue;
+        constructor(vueIns, rawValue) {
+            this._vue = vueIns;
+            this._rawValue = rawValue;
+            this._value = this._vue.toReactive(rawValue);
+        }
+        get value() {
+            return this._value;
+        }
+        set value(newValue) {
+            if (newValue !== this._rawValue) {
+                this._value = this._vue.toReactive(newValue);
+                this._rawValue = newValue;
+            }
+        }
+    }
+    class ObjectRefImpl {
+        object;
+        key;
+        constructor(object, key) {
+            this.object = object;
+            this.key = key;
+        }
+        get value() {
+            return this.object[this.key];
+        }
+        set value(newValue) {
+            this.object[this.key] = newValue;
+        }
+    }
+    class Vue {
+        reactMap = new WeakMap();
+        targetMap = new WeakMap();
+        activeEffect = undefined;
+        constructor() {
+            // 将数据转化成响应式的数据，只能做对象的代理
+        }
+        /**
+         * 生成一个被代理的对象
+         * @param target 需要代理的对象
+         */
+        reactive(target) {
+            const that = this;
+            if (!(typeof target === "object" && target !== null)) {
+                // @ts-ignore
+                return;
+            }
+            if (VueUtils.isReactive(target)) {
+                return target;
+            }
+            let exisProxy = this.reactMap.get(target);
+            if (exisProxy) {
+                return exisProxy;
+            }
+            const proxy = new Proxy(target, {
+                get(target, key, receiver) {
+                    if (key === VueUtils.ReactiveFlags.IS_REACTIVE) {
+                        return true;
+                    }
+                    that.track(target, "get", key);
+                    return Reflect.get(target, key, receiver);
+                },
+                set(target, key, value, receiver) {
+                    let oldValue = target[key];
+                    let result = Reflect.set(target, key, value, receiver);
+                    if (oldValue !== value) {
+                        that.trigger(target, "set", key, oldValue, value);
+                    }
+                    return result;
+                },
+            });
+            that.reactMap.set(target, proxy);
+            return proxy;
+        }
+        /**
+         * 观察被reactive的对象值改变
+         * @param source 被观察的对象，这里采用函数返回对象
+         * @param changeCallBack 值改变的回调
+         */
+        watch(source, changeCallBack) {
+            let getter;
+            if (VueUtils.isReactive(source)) {
+                getter = () => this.traversal(source);
+            }
+            else if (VueUtils.isFunction(source)) {
+                getter = source;
+            }
+            else {
+                return;
+            }
+            let oldValue;
+            const job = () => {
+                const newValue = effect.run((activeEffect) => {
+                    this.activeEffect = activeEffect;
+                });
+                changeCallBack(newValue, oldValue);
+                oldValue = newValue;
+            };
+            const effect = new ReactiveEffect(getter, job);
+            oldValue = effect.run((activeEffect) => {
+                this.activeEffect = activeEffect;
+            });
+        }
+        toReactive(value) {
+            return VueUtils.isObject(value) ? this.reactive(value) : value;
+        }
+        ref(value) {
+            return new RefImpl(this, value);
+        }
+        toRef(object, key) {
+            return new ObjectRefImpl(object, key);
+        }
+        toRefs(object) {
+            const result = VueUtils.isArray(object) ? new Array(object.length) : {};
+            for (let key in object) {
+                // @ts-ignore
+                result[key] = this.toRef(object, key);
+            }
+            return result;
+        }
+        trigger(target, type, key, oldValue, value) {
+            const depsMap = this.targetMap.get(target);
+            if (!depsMap)
+                return;
+            const effects = depsMap.get(key);
+            this.triggerEffect(effects, "effects");
+        }
+        triggerEffect(effects, name) {
+            effects &&
+                effects.forEach((effect) => {
+                    if (effect.scheduler) {
+                        effect.scheduler();
+                    }
+                    else {
+                        effect.run();
+                    }
+                });
+        }
+        track(target, type, key) {
+            if (!this.activeEffect)
+                return;
+            let depsMap = this.targetMap.get(target);
+            if (!depsMap) {
+                this.targetMap.set(target, (depsMap = new Map()));
+            }
+            let dep = depsMap.get(key);
+            if (!dep) {
+                depsMap.set(key, (dep = new Set()));
+            }
+            this.trackEffect(dep);
+        }
+        trackEffect(dep) {
+            if (this.activeEffect) {
+                let shouldTrack = !dep.has(this.activeEffect);
+                if (shouldTrack) {
+                    dep.add(this.activeEffect);
+                    this.activeEffect.deps.push(dep);
+                }
+            }
+        }
+        traversal(value, set = new Set()) {
+            if (!VueUtils.isObject(value))
+                return value;
+            if (set.has(value)) {
+                return value;
+            }
+            set.add(value);
+            for (let key in value) {
+                this.traversal(value[key], set);
+            }
+            return value;
+        }
+    }
+
     class Utils {
         windowApi;
         constructor(option) {
@@ -5767,7 +6042,6 @@ var Utils = (function () {
                 }
                 /**
                  * 申请剪贴板权限
-                 * @returns {Promise<boolean>}
                  */
                 requestClipboardPermission() {
                     return new Promise((resolve, reject) => {
@@ -5780,9 +6054,7 @@ var Utils = (function () {
                                 .then((permissionStatus) => {
                                 resolve(true);
                             })
-                                .catch(
-                            /** @param {TypeError} error */
-                            (error) => {
+                                .catch((error) => {
                                 console.error([
                                     "申请剪贴板权限失败，尝试直接写入👉",
                                     error.message ?? error.name ?? error.stack,
@@ -6715,6 +6987,10 @@ var Utils = (function () {
          * Utils.generateUUID()
          */
         generateUUID = GenerateUUID;
+        /**
+         * 自定义的动态响应对象
+         */
+        Vue = Vue;
     }
     let utils = new Utils();