@whitesev/utils 2.5.8 → 2.5.9

package/dist/index.system.js

@@ -4536,6 +4536,454 @@ System.register('Utils', [], (function (exports) {
                 }
             }
 
+            // ==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) {
@@ -4662,10 +5110,18 @@ System.register('Utils', [], (function (exports) {
                  * 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元素");