@whitesev/utils 2.11.10 → 2.11.12

package/dist/types/src/Utils.d.ts

@@ -45,14 +45,22 @@ declare class Utils {
     asyncReplaceAll(string: string, pattern: RegExp | string, asyncFn: (item: string) => Promise<string>): Promise<string>;
     /**
      * ajax劫持库，支持xhr和fetch劫持。
-     * + 来源：https://bbs.tampermonkey.net.cn/thread-3284-1-1.html
-     * + 作者：cxxjackie
-     * + 版本：1.4.8
-     * + 旧版本：1.2.4
-     * + 文档：https://scriptcat.org/zh-CN/script-show-page/637/
-     * @param useOldVersion 是否使用旧版本，默认false
+     * + 来源: https://bbs.tampermonkey.net.cn/thread-3284-1-1.html
+     * + 作者: cxxjackie
+     * + 实现方式: Proxy
+     * + 版本: `1.4.8`
+     * + 文档: https://scriptcat.org/zh-CN/script-show-page/637/
      */
-    ajaxHooker: (useOldVersion?: boolean) => UtilsAjaxHookResult;
+    ajaxHooker: () => UtilsAjaxHookResult;
+    /**
+     * ajax劫持库，支持xhr和fetch劫持。
+     * + 来源: https://bbs.tampermonkey.net.cn/thread-3284-1-1.html
+     * + 作者: cxxjackie
+     * + 实现方式: Object.defineProperty
+     * + 版本: `1.2.4`
+     * + 文档: https://scriptcat.org/zh-CN/script-show-page/637/
+     */
+    oldAjaxHooker: () => UtilsAjaxHookResult;
     /**
      * 根据坐标点击canvas元素的内部位置
      * @param canvasElement 画布元素
@@ -1002,9 +1010,14 @@ declare class Utils {
          */
         config?: MutationObserverInit;
         /**
-         * 是否主动触发一次
+         * （可选）是否主动触发一次
          */
         immediate?: boolean;
+        /**
+         * （可选）是否仅触发一次
+         * @default false
+         */
+        once?: boolean;
         /**
          * 触发的回调函数
          */
@@ -1012,7 +1025,7 @@ declare class Utils {
     }): MutationObserver;
     /**
      * 使用观察器观察元素出现在视图内，出现的话触发回调
-     * @param target 目标元素
+     * @param $el 目标元素
      * @param callback 触发的回调
      * @param options 观察器配置
      * @example
@@ -1020,7 +1033,12 @@ declare class Utils {
      *     console.log("该元素出现在视图内");
      * }))
      */
-    mutationVisible(target: Element | Element[], callback: (entries: IntersectionObserverEntry[], observer: IntersectionObserver) => void, options?: IntersectionObserverInit): void;
+    mutationVisible($el: Element | Element[], callback: (entries: IntersectionObserverEntry[], observer: IntersectionObserver) => void, options?: IntersectionObserverInit & {
+        /** （可选）是否主动触发一次，默认false */
+        immediate?: boolean;
+        /** （可选）是否仅触发一次，默认false */
+        once?: boolean;
+    }): IntersectionObserver;
     /**
      * 去除全局window下的Utils，返回控制权
      * @example
@@ -1346,8 +1364,16 @@ declare class Utils {
     toSearchParamsStr(obj: object | object[], addPrefix?: boolean): string;
     /**
      * 将UrlSearchParams格式的字符串转为对象
+     * @param searhParamsStr 字符串或对象
+     * @example
+     * Utils.searchParamStrToObj("xxx=xx&xx2=xx2")
+     * @example
+     * Utils.searchParamStrToObj(new URLSearchParams({
+     *   test1: 1,
+     *   test2: 2
+     * }))
      */
-    searchParamStrToObj<T>(searhParamsStr?: string | null | undefined): T;
+    searchParamStrToObj<T = any>(searhParamsStr?: string | null | undefined | URLSearchParams): T;
     /**
      * 提供一个封装了 try-catch 的函数，可以执行传入的函数并捕获其可能抛出的错误，并通过传入的错误处理函数进行处理。
      * @example

package/dist/types/src/ajaxHooker/ajaxHooker.d.ts

@@ -1,6 +1,12 @@
 export function ajaxHooker(): {
-    hook: (fn: any) => number;
-    filter: (arr: any) => void;
+    hook: (fn: any) => {
+        remove: () => boolean;
+    };
+    filter: (arr: any) => {
+        remove: () => void;
+    };
     protect: () => void;
     unhook: () => void;
+    removeHook: (fn: (request: import("./../types/ajaxHooker.d.ts").UtilsAjaxHookRequestOptions) => void | undefined | null | Promise<void | undefined | null>, onlyRemove: boolean) => boolean;
+    removeFilter: () => void;
 };

package/dist/types/src/ajaxHooker/ajaxHooker1.2.4.d.ts

@@ -1,6 +1,12 @@
 export function AjaxHooker1_2_4(): {
-    hook: (fn: any) => number;
-    filter: (arr: any) => void;
+    hook: (fn: any) => {
+        remove: () => boolean;
+    };
+    filter: (arr: any) => {
+        remove: () => void;
+    };
     protect: () => void;
     unhook: () => void;
+    removeHook: (fn: (request: import("./../types/ajaxHooker.d.ts").UtilsAjaxHookRequestOptions) => void | undefined | null | Promise<void | undefined | null>, onlyRemove: boolean) => boolean;
+    removeFilter: () => void;
 };

package/dist/types/src/types/Httpx.d.ts

@@ -1052,30 +1052,30 @@ export declare interface HttpxRequestOption {
    */
   data?: string | FormData | object;
   /**
-   * 是否自动对data进行处理
+   * 是否自动对`data`进行处理
    *
    * ## 处理以下请求类型
-   * + `GET` 自动进行`URLSearchParams`转换
-   * + `HEAD` 自动进行`URLSearchParams`转换
-   * + `POST` 处理`Content-Type`不为空的情况
+   * + 当请求类型为`GET`，自动进行`URLSearchParams`转换
+   * + 当请求类型为`HEAD`，自动进行`URLSearchParams`转换
+   * + 当请求类型为`POST`，根据下面的`Content-Type`类型来处理（`Content-Type`不为空才会处理）
    *
-   * ### `application/json`
+   * ### `POST` => `Content-Type` => `application/json`
    *
-   * + `string`: 不做处理
-   * + `FormData`: 转为`JSON`并进行`JSON.stringify`处理
-   * + `object`: 进行`JSON.stringify`处理
+   * + `data: string`: ignore
+   * + `data: object`: 进行`JSON.stringify`处理
+   * + `data: FormData`: 转为`JSON`并进行`JSON.stringify`处理
    *
-   * ### `application/x-www-form-urlencoded`
+   * ### `POST` => `Content-Type` => `application/x-www-form-urlencoded`
    *
-   * + `string`: 不做处理
-   * + `FormData`: 转为`URLSearchParams`，再转为`string`
-   * + `object`: 转为`URLSearchParams`，再转为`string`
+   * + `data: string`: ignore
+   * + `data: object`: 转为`URLSearchParams`，再转为`string`
+   * + `data: FormData`: 转为`URLSearchParams`，再转为`string`
    *
-   * ### `multipart/form-data`（上传文件专用）
+   * ### `POST` => `Content-Type` => `multipart/form-data`（上传文件专用）
    *
-   * + `string`: 不做处理
-   * + `FormData`: 移除`Content-Type`
-   * + `object`: 不做处理
+   * + `data: string`: ignore
+   * + `data: object`: ignore
+   * + `data: FormData`: 移除`Content-Type`
    * @default true
    */
   processData?: boolean;

package/dist/types/src/types/ajaxHooker.d.ts

@@ -89,67 +89,103 @@ export declare interface UtilsAjaxHookFilterOptions {
 /** Utils.ajaxHooker */
 export declare interface UtilsAjaxHookResult {
   /**
-     * 劫持xhr和fetch
-     * 
-     * 提示：如果多次调用.hook方法，将会多次处理同一个请求
-     * @example
-        ajaxHooker.hook(request => {
-            if (request.url === 'https://www.example.com/') {
-                request.response = res => {
-                    console.log(res);
-                    res.responseText += 'test';
-                };
-            }
-        });
-      * @example
-        // 异步特性无法作用于同步请求，但同步修改仍然有效
-        // 你可以将以上所有可修改属性赋值为Promise，原请求将被阻塞直至Promise完成（若发生reject，数据将不会被修改）
-        // 此特性可用于异步劫持。以下是一个异步修改响应数据的例子
-        ajaxHooker.hook(request => {
-            request.response = res => {
-                const responseText = res.responseText; // 注意保存原数据
-                res.responseText = new Promise(resolve => {
-                    setTimeout(() => {
-                        resolve(responseText + 'test');
-                    }, 3000);
-                });
-            };
-        });
-
-        // 也可以传入async回调函数以实现异步
-        ajaxHooker.hook(async request => {
-            request.data = await modifyData(request.data);
-            request.response = async res => {
-                res.responseText = await modifyResponse(res.responseText);
-            };
-        });
-     */
+   * 劫持xhr和fetch
+   *
+   * 提示：如果多次调用.hook方法，将会多次处理同一个请求
+   * @example
+   *   ajaxHooker.hook(request => {
+   *       if (request.url === 'https://www.example.com/') {
+   *           request.response = res => {
+   *               console.log(res);
+   *               res.responseText += 'test';
+   *           };
+   *       }
+   *   });
+   * * @example
+   *   // 异步特性无法作用于同步请求，但同步修改仍然有效
+   *   // 你可以将以上所有可修改属性赋值为Promise，原请求将被阻塞直至Promise完成（若发生reject，数据将不会被修改）
+   *   // 此特性可用于异步劫持。以下是一个异步修改响应数据的例子
+   *   ajaxHooker.hook(request => {
+   *       request.response = res => {
+   *           const responseText = res.responseText; // 注意保存原数据
+   *           res.responseText = new Promise(resolve => {
+   *               setTimeout(() => {
+   *                   resolve(responseText + 'test');
+   *               }, 3000);
+   *           });
+   *       };
+   *   });
+   *   // 也可以传入async回调函数以实现异步
+   *   ajaxHooker.hook(async request => {
+   *       request.data = await modifyData(request.data);
+   *       request.response = async res => {
+   *           res.responseText = await modifyResponse(res.responseText);
+   *       };
+   *   });
+   */
   hook(
-    callback: (request: UtilsAjaxHookRequestOptions) => void | undefined | null | Promise<void | undefined | null>
-  ): void;
-  /**
-     * 过滤
-     * @example
-        // 应于hook方法之前执行，此方法若尽早执行，有助于提升性能。
-        // 为hook方法设置过滤规则，只有符合规则的请求才会触发hook。过滤规则是一个对象数组，参考下例
-        ajaxHooker.filter([
-            {type: 'xhr', url: 'www.example.com', method: 'GET', async: true},
-            {url: /^http/},
-        ]);
+    callback: (
+      /**
+       * hook请求的配置
+       */
+      request: UtilsAjaxHookRequestOptions,
+      /**
+       * 当前的`callback`的索引下标
+       */
+      index: number
+    ) => void | undefined | null | Promise<void | undefined | null>
+  ): {
+    /**
+     * 该函数是额外添加的，原版仅返回空值
      */
-  filter(filterOptions: UtilsAjaxHookFilterOptions[]): void;
+    remove: () => boolean;
+  };
   /**
-     * 阻止xhr和fetch被改写
-     * @example
-        // 如果库劫持失败，可能是其他代码对xhr/fetch进行了二次劫持，protect方法会尝试阻止xhr和fetch被改写。应于document-start阶段尽早执行，部分网页下可能引发错误，谨慎使用。
-        ajaxHooker.protect();
+   * 过滤
+   *
+   * 注意：重复调用`.filter`设置规则会覆盖之前设置的规则
+   * @example
+   *   // 应于hook方法之前执行，此方法若尽早执行，有助于提升性能。
+   *   // 为hook方法设置过滤规则，只有符合规则的请求才会触发hook。过滤规则是一个对象数组，参考下例
+   *   ajaxHooker.filter([
+   *       {type: 'xhr', url: 'www.example.com', method: 'GET', async: true},
+   *       {url: /^http/},
+   *   ]);
+   */
+  filter(filterOptions: UtilsAjaxHookFilterOptions[]): {
+    /**
+     * 该函数是额外添加的，原版仅返回空值
      */
+    remove: () => void;
+  };
+  /**
+   * 阻止xhr和fetch被改写
+   * @example
+   *  // 如果库劫持失败，可能是其他代码对xhr/fetch进行了二次劫持，protect方法会尝试阻止xhr和fetch被改写。应于document-start阶段尽早执行，部分网页下可能引发错误，谨慎使用。
+   *   ajaxHooker.protect();
+   */
   protect(): void;
   /**
-     * 取消劫持
-     * @example
-        // 将xhr和fetch恢复至劫持前的状态，调用此方法后，hook方法不再生效。
-        ajaxHooker.unhook();
-     */
+   * 取消劫持
+   * @example
+   *   // 将xhr和fetch恢复至劫持前的状态，调用此方法后，hook方法不再生效。
+   *   ajaxHooker.unhook();
+   */
   unhook(): void;
+  /**
+   * 移除通过`.hook`添加的函数
+   *
+   * @description 此函数为额外添加的增强函数
+   * @param fn `.hook`添加的函数
+   * @param onlyRemove （可选）是否仅移除一个（如果命中的话），默认false
+   */
+  removeHook(
+    fn: (request: UtilsAjaxHookRequestOptions) => void | undefined | null | Promise<void | undefined | null>,
+    onlyRemove: boolean
+  ): boolean;
+  /**
+   * 重置通过`.filter`设置的规则
+   * @description 此函数为额外添加的增强函数
+   */
+  removeFilter(): void;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@whitesev/utils",
-  "version": "2.11.10",
+  "version": "2.11.12",
   "description": "一个常用的工具库",
   "keywords": [
     "ScriptCat",
@@ -53,9 +53,8 @@
     "eslint-plugin-compat": "^6.0.2",
     "eslint-plugin-prettier": "^5.5.4",
     "globals": "^16.5.0",
-    "oxfmt": "^0.32.0",
-    "oxlint": "1.46.0",
-    "rolldown": "1.0.0-beta.55",
+    "oxfmt": "^0.37.0",
+    "oxlint": "1.55.0",
     "rollup": "^4.53.5",
     "rollup-plugin-clear": "^2.0.7",
     "tslib": "^2.8.1",

package/src/Httpx.ts

@@ -465,39 +465,39 @@ export class Httpx {
           const method = requestOption.method;
           if (method === "GET" || method === "HEAD") {
             // GET类型，data如果有，那么需要转为searchParams
-            const urlObj = new URL(requestOption.url);
+            const urlInst = new URL(requestOption.url);
             let urlSearch = "";
-            let isHandler = false;
+            let deleteData = false;
             if (typeof requestOption.data === "string") {
-              isHandler = true;
+              deleteData = true;
               urlSearch = requestOption.data;
             } else if (typeof requestOption.data === "object") {
-              isHandler = true;
+              deleteData = true;
               // URLSearchParams参数可以转普通的string:string，包括FormData
               const searchParams = new URLSearchParams(requestOption.data as Record<string, string>);
               urlSearch = searchParams.toString();
             }
-            if (isHandler) {
+            if (deleteData) {
               // GET/HEAD请求不支持data参数
               // 对data进行处理了才可以删除
               Reflect.deleteProperty(requestOption, "data");
             }
-            if (urlSearch != "") {
-              if (urlObj.search === "") {
+            if (urlSearch.trim() != "") {
+              if (urlInst.search.trim() === "") {
                 // url没有search参数，直接覆盖
-                urlObj.search = urlSearch;
+                urlInst.search = urlSearch;
               } else {
                 // 有search参数
-                if (urlObj.search.endsWith("&")) {
+                if (urlInst.search.trim().endsWith("&")) {
                   // xxx=xxx&
-                  urlObj.search = urlObj.search + urlSearch;
+                  urlInst.search = urlInst.search + urlSearch;
                 } else {
                   // xxx=xxx&xxx=
-                  urlObj.search = `${urlObj.search}&${urlSearch}`;
+                  urlInst.search = `${urlInst.search}&${urlSearch}`;
                 }
               }
             }
-            requestOption.url = urlObj.toString();
+            requestOption.url = urlInst.toString();
           } else if (method === "POST" && requestOption.headers != null) {
             // POST类型，data如果是FormData，那么需要转为string
             const headersKeyList = Object.keys(requestOption.headers);
@@ -508,10 +508,10 @@ export class Httpx {
               );
             });
             if (ContentTypeIndex !== -1) {
-              const ContentTypeKey = headersKeyList[ContentTypeIndex];
-              const ContentType = requestOption.headers[ContentTypeKey] as string;
+              const contentTypeKey = headersKeyList[ContentTypeIndex];
+              const contentType = (<string>requestOption.headers[contentTypeKey]).toLowerCase();
               // 设置了Content-Type
-              if (ContentType.includes("application/json")) {
+              if (contentType.includes("application/json")) {
                 // application/json
                 if (requestOption.data instanceof FormData) {
                   const entries: { [key: string]: any } = {};
@@ -522,15 +522,15 @@ export class Httpx {
                 } else if (typeof requestOption.data === "object") {
                   requestOption.data = JSON.stringify(requestOption.data);
                 }
-              } else if (ContentType.includes("application/x-www-form-urlencoded")) {
+              } else if (contentType.includes("application/x-www-form-urlencoded")) {
                 // application/x-www-form-urlencoded
                 if (typeof requestOption.data === "object") {
                   requestOption.data = new URLSearchParams(requestOption.data as Record<string, string>).toString();
                 }
-              } else if (ContentType.includes("multipart/form-data")) {
+              } else if (contentType.includes("multipart/form-data")) {
                 // multipart/form-data
                 if (requestOption.data instanceof FormData) {
-                  Reflect.deleteProperty(requestOption.headers, ContentTypeKey);
+                  Reflect.deleteProperty(requestOption.headers, contentTypeKey);
                 }
               }
             }

package/src/LockFunction.ts

@@ -37,12 +37,9 @@ export class LockFunction<K extends (...args: any[]) => any | Promise<any> | voi
      * 解锁
      */
     this.unlock = function () {
-      that.#timeId = setTimeout(
-        () => {
-          that.#flag = false;
-        },
-        that.#delayTime
-      );
+      that.#timeId = setTimeout(() => {
+        that.#flag = false;
+      }, that.#delayTime);
     };
     /**
      * 判断是否被锁