@whitesev/utils 2.5.8 → 2.5.9

package/dist/index.umd.js

@@ -4537,6 +4537,454 @@
         }
     }
 
+    // ==UserScript==
+    // @name         ajaxHooker
+    // @author       cxxjackie
+    // @version      1.2.4
+    // @supportURL   https://bbs.tampermonkey.net.cn/thread-3284-1-1.html
+    // ==/UserScript==
+
+    const AjaxHooker1_2_4 = function () {
+    	return (function () {
+    		const win = window.unsafeWindow || document.defaultView || window;
+    		const hookFns = [];
+    		const realXhr = win.XMLHttpRequest;
+    		const resProto = win.Response.prototype;
+    		const toString = Object.prototype.toString;
+    		const realFetch = win.fetch;
+    		const xhrResponses = ["response", "responseText", "responseXML"];
+    		const fetchResponses = ["arrayBuffer", "blob", "formData", "json", "text"];
+    		const xhrAsyncEvents = ["readystatechange", "load", "loadend"];
+    		let filter;
+    		function emptyFn() {}
+    		function errorFn(err) {
+    			console.error(err);
+    		}
+    		function defineProp(obj, prop, getter, setter) {
+    			Object.defineProperty(obj, prop, {
+    				configurable: true,
+    				enumerable: true,
+    				get: getter,
+    				set: setter,
+    			});
+    		}
+    		function readonly(obj, prop, value = obj[prop]) {
+    			defineProp(obj, prop, () => value, emptyFn);
+    		}
+    		function writable(obj, prop, value = obj[prop]) {
+    			Object.defineProperty(obj, prop, {
+    				configurable: true,
+    				enumerable: true,
+    				writable: true,
+    				value: value,
+    			});
+    		}
+    		function toFilterObj(obj) {
+    			return {
+    				type: obj.type,
+    				url: obj.url,
+    				method: obj.method && obj.method.toUpperCase(),
+    			};
+    		}
+    		function shouldFilter(type, url, method) {
+    			return (
+    				filter &&
+    				!filter.find(
+    					(obj) =>
+    						(!obj.type || obj.type === type) &&
+    						(!obj.url ||
+    							(toString.call(obj.url) === "[object String]"
+    								? url.includes(obj.url)
+    								: obj.url.test(url))) &&
+    						(!obj.method || obj.method === method.toUpperCase())
+    				)
+    			);
+    		}
+    		function lookupGetter(obj, prop) {
+    			let getter;
+    			let proto = obj;
+    			while (proto) {
+    				const descriptor = Object.getOwnPropertyDescriptor(proto, prop);
+    				getter = descriptor && descriptor.get;
+    				if (getter) break;
+    				proto = Object.getPrototypeOf(proto);
+    			}
+    			return getter ? getter.bind(obj) : emptyFn;
+    		}
+    		function waitForHookFns(request) {
+    			return Promise.all(
+    				hookFns.map((fn) => Promise.resolve(fn(request)).then(emptyFn, errorFn))
+    			);
+    		}
+    		function waitForRequestKeys(request, requestClone) {
+    			return Promise.all(
+    				["url", "method", "abort", "headers", "data"].map((key) => {
+    					return Promise.resolve(request[key]).then(
+    						(val) => (request[key] = val),
+    						() => (request[key] = requestClone[key])
+    					);
+    				})
+    			);
+    		}
+    		function fakeEventSIP() {
+    			this.ajaxHooker_stopped = true;
+    		}
+    		function xhrDelegateEvent(e) {
+    			const xhr = e.target;
+    			e.stopImmediatePropagation = fakeEventSIP;
+    			xhr.__ajaxHooker.hookedEvents[e.type].forEach(
+    				(fn) => !e.ajaxHooker_stopped && fn.call(xhr, e)
+    			);
+    			const onEvent = xhr.__ajaxHooker.hookedEvents["on" + e.type];
+    			typeof onEvent === "function" && onEvent.call(xhr, e);
+    		}
+    		function xhrReadyStateChange(e) {
+    			if (e.target.readyState === 4) {
+    				e.target.dispatchEvent(
+    					new CustomEvent("ajaxHooker_responseReady", { detail: e })
+    				);
+    			} else {
+    				e.target.__ajaxHooker.delegateEvent(e);
+    			}
+    		}
+    		function xhrLoadAndLoadend(e) {
+    			e.target.__ajaxHooker.delegateEvent(e);
+    		}
+    		function fakeXhrOpen(method, url, ...args) {
+    			const ah = this.__ajaxHooker;
+    			ah.url = url.toString();
+    			ah.method = method.toUpperCase();
+    			ah.openArgs = args;
+    			ah.headers = {};
+    			return ah.originalMethods.open(method, url, ...args);
+    		}
+    		function fakeXhr() {
+    			const xhr = new realXhr();
+    			let ah = xhr.__ajaxHooker;
+    			if (!ah) {
+    				ah = xhr.__ajaxHooker = {
+    					headers: {},
+    					hookedEvents: {
+    						readystatechange: new Set(),
+    						load: new Set(),
+    						loadend: new Set(),
+    					},
+    					delegateEvent: xhrDelegateEvent,
+    					originalGetters: {},
+    					originalMethods: {},
+    				};
+    				xhr.addEventListener("readystatechange", xhrReadyStateChange);
+    				xhr.addEventListener("load", xhrLoadAndLoadend);
+    				xhr.addEventListener("loadend", xhrLoadAndLoadend);
+    				for (const key of xhrResponses) {
+    					ah.originalGetters[key] = lookupGetter(xhr, key);
+    				}
+    				for (const method of [
+    					"open",
+    					"setRequestHeader",
+    					"addEventListener",
+    					"removeEventListener",
+    				]) {
+    					ah.originalMethods[method] = xhr[method].bind(xhr);
+    				}
+    				xhr.open = fakeXhrOpen;
+    				xhr.setRequestHeader = (header, value) => {
+    					ah.originalMethods.setRequestHeader(header, value);
+    					if (xhr.readyState === 1) {
+    						if (ah.headers[header]) {
+    							ah.headers[header] += ", " + value;
+    						} else {
+    							ah.headers[header] = value;
+    						}
+    					}
+    				};
+    				xhr.addEventListener = function (...args) {
+    					if (xhrAsyncEvents.includes(args[0])) {
+    						ah.hookedEvents[args[0]].add(args[1]);
+    					} else {
+    						ah.originalMethods.addEventListener(...args);
+    					}
+    				};
+    				xhr.removeEventListener = function (...args) {
+    					if (xhrAsyncEvents.includes(args[0])) {
+    						ah.hookedEvents[args[0]].delete(args[1]);
+    					} else {
+    						ah.originalMethods.removeEventListener(...args);
+    					}
+    				};
+    				xhrAsyncEvents.forEach((evt) => {
+    					const onEvt = "on" + evt;
+    					defineProp(
+    						xhr,
+    						onEvt,
+    						() => {
+    							return ah.hookedEvents[onEvt] || null;
+    						},
+    						(val) => {
+    							ah.hookedEvents[onEvt] = typeof val === "function" ? val : null;
+    						}
+    					);
+    				});
+    			}
+    			const realSend = xhr.send.bind(xhr);
+    			xhr.send = function (data) {
+    				if (xhr.readyState !== 1) return realSend(data);
+    				ah.delegateEvent = xhrDelegateEvent;
+    				xhrResponses.forEach((prop) => {
+    					delete xhr[prop]; // delete descriptor
+    				});
+    				if (shouldFilter("xhr", ah.url, ah.method)) {
+    					xhr.addEventListener("ajaxHooker_responseReady", (e) => {
+    						ah.delegateEvent(e.detail);
+    					});
+    					return realSend(data);
+    				}
+    				try {
+    					const request = {
+    						type: "xhr",
+    						url: ah.url,
+    						method: ah.method,
+    						abort: false,
+    						headers: ah.headers,
+    						data: data,
+    						response: null,
+    					};
+    					const requestClone = { ...request };
+    					waitForHookFns(request).then(() => {
+    						waitForRequestKeys(request, requestClone).then(() => {
+    							if (request.abort) return;
+    							ah.originalMethods.open(
+    								request.method,
+    								request.url,
+    								...ah.openArgs
+    							);
+    							for (const header in request.headers) {
+    								ah.originalMethods.setRequestHeader(
+    									header,
+    									request.headers[header]
+    								);
+    							}
+    							data = request.data;
+    							xhr.addEventListener("ajaxHooker_responseReady", (e) => {
+    								try {
+    									if (typeof request.response === "function") {
+    										const arg = {
+    											finalUrl: xhr.responseURL,
+    											status: xhr.status,
+    											responseHeaders: {},
+    										};
+    										for (const line of xhr
+    											.getAllResponseHeaders()
+    											.trim()
+    											.split(/[\r\n]+/)) {
+    											const parts = line.split(/:\s*/);
+    											if (parts.length === 2) {
+    												const lheader = parts[0].toLowerCase();
+    												if (arg.responseHeaders[lheader]) {
+    													arg.responseHeaders[lheader] += ", " + parts[1];
+    												} else {
+    													arg.responseHeaders[lheader] = parts[1];
+    												}
+    											}
+    										}
+    										xhrResponses.forEach((prop) => {
+    											defineProp(
+    												arg,
+    												prop,
+    												() => {
+    													return (arg[prop] = ah.originalGetters[prop]());
+    												},
+    												(val) => {
+    													delete arg[prop];
+    													arg[prop] = val;
+    												}
+    											);
+    											defineProp(xhr, prop, () => {
+    												const val = ah.originalGetters[prop]();
+    												xhr.dispatchEvent(
+    													new CustomEvent("ajaxHooker_readResponse", {
+    														detail: { prop, val },
+    													})
+    												);
+    												return val;
+    											});
+    										});
+    										xhr.addEventListener("ajaxHooker_readResponse", (e) => {
+    											arg[e.detail.prop] = e.detail.val;
+    										});
+    										const resPromise = Promise.resolve(
+    											request.response(arg)
+    										).then(() => {
+    											const task = [];
+    											xhrResponses.forEach((prop) => {
+    												const descriptor = Object.getOwnPropertyDescriptor(
+    													arg,
+    													prop
+    												);
+    												if (descriptor && "value" in descriptor) {
+    													task.push(
+    														Promise.resolve(descriptor.value).then((val) => {
+    															arg[prop] = val;
+    															defineProp(xhr, prop, () => {
+    																xhr.dispatchEvent(
+    																	new CustomEvent("ajaxHooker_readResponse", {
+    																		detail: { prop, val },
+    																	})
+    																);
+    																return val;
+    															});
+    														}, emptyFn)
+    													);
+    												}
+    											});
+    											return Promise.all(task);
+    										}, errorFn);
+    										const eventsClone = {};
+    										xhrAsyncEvents.forEach((type) => {
+    											eventsClone[type] = new Set([...ah.hookedEvents[type]]);
+    											eventsClone["on" + type] = ah.hookedEvents["on" + type];
+    										});
+    										ah.delegateEvent = (event) =>
+    											resPromise.then(() => {
+    												event.stopImmediatePropagation = fakeEventSIP;
+    												eventsClone[event.type].forEach(
+    													(fn) =>
+    														!event.ajaxHooker_stopped && fn.call(xhr, event)
+    												);
+    												const onEvent = eventsClone["on" + event.type];
+    												typeof onEvent === "function" &&
+    													onEvent.call(xhr, event);
+    											});
+    									}
+    								} catch (err) {
+    									console.error(err);
+    								}
+    								ah.delegateEvent(e.detail);
+    							});
+    							realSend(data);
+    						});
+    					});
+    				} catch (err) {
+    					console.error(err);
+    					realSend(data);
+    				}
+    			};
+    			return xhr;
+    		}
+    		function hookFetchResponse(response, arg, callback) {
+    			fetchResponses.forEach((prop) => {
+    				response[prop] = () =>
+    					new Promise((resolve, reject) => {
+    						resProto[prop].call(response).then((res) => {
+    							if (prop in arg) {
+    								resolve(arg[prop]);
+    							} else {
+    								try {
+    									arg[prop] = res;
+    									Promise.resolve(callback(arg)).then(() => {
+    										if (prop in arg) {
+    											Promise.resolve(arg[prop]).then(
+    												(val) => resolve((arg[prop] = val)),
+    												() => resolve(res)
+    											);
+    										} else {
+    											resolve(res);
+    										}
+    									}, errorFn);
+    								} catch (err) {
+    									console.error(err);
+    									resolve(res);
+    								}
+    							}
+    						}, reject);
+    					});
+    			});
+    		}
+    		function fakeFetch(url, init) {
+    			if (url && typeof url.toString === "function") {
+    				url = url.toString();
+    				init = init || {};
+    				init.method = init.method || "GET";
+    				init.headers = init.headers || {};
+    				if (shouldFilter("fetch", url, init.method))
+    					return realFetch.call(win, url, init);
+    				const request = {
+    					type: "fetch",
+    					url: url,
+    					method: init.method.toUpperCase(),
+    					abort: false,
+    					headers: {},
+    					data: init.body,
+    					response: null,
+    				};
+    				if (toString.call(init.headers) === "[object Headers]") {
+    					for (const [key, val] of init.headers) {
+    						request.headers[key] = val;
+    					}
+    				} else {
+    					request.headers = { ...init.headers };
+    				}
+    				const requestClone = { ...request };
+    				return new Promise((resolve, reject) => {
+    					try {
+    						waitForHookFns(request).then(() => {
+    							waitForRequestKeys(request, requestClone).then(() => {
+    								if (request.abort) return reject("aborted");
+    								url = request.url;
+    								init.method = request.method;
+    								init.headers = request.headers;
+    								init.body = request.data;
+    								realFetch.call(win, url, init).then((response) => {
+    									if (typeof request.response === "function") {
+    										const arg = {
+    											finalUrl: response.url,
+    											status: response.status,
+    											responseHeaders: {},
+    										};
+    										for (const [key, val] of response.headers) {
+    											arg.responseHeaders[key] = val;
+    										}
+    										hookFetchResponse(response, arg, request.response);
+    										response.clone = () => {
+    											const resClone = resProto.clone.call(response);
+    											hookFetchResponse(resClone, arg, request.response);
+    											return resClone;
+    										};
+    									}
+    									resolve(response);
+    								}, reject);
+    							});
+    						});
+    					} catch (err) {
+    						console.error(err);
+    						return realFetch.call(win, url, init);
+    					}
+    				});
+    			} else {
+    				return realFetch.call(win, url, init);
+    			}
+    		}
+    		win.XMLHttpRequest = fakeXhr;
+    		Object.keys(realXhr).forEach((key) => (fakeXhr[key] = realXhr[key]));
+    		fakeXhr.prototype = realXhr.prototype;
+    		win.fetch = fakeFetch;
+    		return {
+    			hook: (fn) => hookFns.push(fn),
+    			filter: (arr) => {
+    				filter = Array.isArray(arr) && arr.map(toFilterObj);
+    			},
+    			protect: () => {
+    				readonly(win, "XMLHttpRequest", fakeXhr);
+    				readonly(win, "fetch", fakeFetch);
+    			},
+    			unhook: () => {
+    				writable(win, "XMLHttpRequest", realXhr);
+    				writable(win, "fetch", realFetch);
+    			},
+    		};
+    	})();
+    };
+
     class Utils {
         windowApi;
         constructor(option) {
@@ -4663,10 +5111,18 @@
          * ajax劫持库，支持xhr和fetch劫持。
          * + 来源：https://bbs.tampermonkey.net.cn/thread-3284-1-1.html
          * + 作者：cxxjackie
-         * + 版本：1.4.1
+         * + 版本：1.4.3
          * + 文档：https://scriptcat.org/zh-CN/script-show-page/637/
+         * @param useOldVersion 是否使用旧版本，默认false
          */
-        ajaxHooker = AjaxHooker;
+        ajaxHooker = (useOldVersion = false) => {
+            if (useOldVersion) {
+                return AjaxHooker1_2_4();
+            }
+            else {
+                return AjaxHooker();
+            }
+        };
         canvasClickByPosition(canvasElement, clientX = 0, clientY = 0, view = globalThis) {
             if (!(canvasElement instanceof HTMLCanvasElement)) {
                 throw new Error("Utils.canvasClickByPosition 参数canvasElement必须是canvas元素");