@whitesev/utils 2.8.2 → 2.9.0

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

@@ -1,151 +1,151 @@
-import type { HttpxHeaders, HttpxMethod, HttpxStatus } from "./Httpx";
-
-/** 请求的response配置 */
-export declare interface UtilsAjaxHookResponseOptions {
-  /**
-   * （重定向后的）Url
-   */
-  finalUrl: string;
-  /**
-   * 响应码
-   */
-  status: HttpxStatus;
-  /**
-   * 响应头
-   */
-  responseHeaders: HttpxHeaders;
-  /**
-   * 响应内容
-   */
-  response?: string | Blob | ArrayBuffer | XMLDocument | FormData;
-  /**
-   * 响应内容文本
-   */
-  responseText?: string;
-}
-
-/** hook请求的配置 */
-export declare interface UtilsAjaxHookRequestOptions {
-  /**
-   * 只读属性。一个字符串，表明请求类型是xhr还是fetch
-   */
-  type: "xhr";
-  /**
-   * 请求的Url
-   */
-  url: string;
-  /**
-   * 请求的url和method，可以直接修改
-   */
-  method: HttpxMethod;
-  /**
-   * 是否取消请求，设置为true即可取消本次请求
-   */
-  abort: boolean;
-  /**
-   * 请求头，可以直接修改
-   */
-  headers: HttpxHeaders;
-  /**
-   * 请求携带的数据，可以直接修改
-   */
-  data?: any;
-  /**
-   * 响应内容，必须通过一个回调函数进行读取和修改。
-   *
-   * 响应内容为一个对象，包含finalUrl、status、responseHeaders和被读取的响应数据，除响应数据可修改，其他属性是只读的。
-   *
-   * 响应数据是哪个属性取决于哪个属性被读取，xhr可能的属性为response、responseText、responseXML，fetch可能的属性为arrayBuffer、blob、formData、json、text。
-   *
-   * 在控制台输出时，xhr响应将包含所有属性，但只有被读取过的属性具有明确的值。修改对应属性即可影响读取结果，进而实现响应数据的修改。
-   */
-  response?: (res: Required<UtilsAjaxHookResponseOptions>) => void;
-  /**
-   * 只读属性。异步请求为true，同步请求为false，异步特性无法作用于同步请求
-   */
-  async: boolean;
-}
-
-/** 过滤规则配置 */
-export declare interface UtilsAjaxHookFilterOptions {
-  /**
-   * 应是xhr或fetch
-   */
-  type?: "xhr" | "fetch";
-  /**
-   * 字符串或正则表达式，无需完全匹配
-   */
-  url?: string;
-  /**
-   * 请求方法
-   */
-  method?: HttpxMethod;
-  /**
-   * 是否异步
-   */
-  async?: boolean;
-}
-
-/** Utils.ajaxHooker */
-export declare interface UtilsAjaxHookResult {
-  /**
-     * 劫持
-     * @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 | Promise<undefined>): void;
-  /**
-     * 过滤
-     * @example
-        // 应于hook方法之前执行，此方法若尽早执行，有助于提升性能。
-        // 为hook方法设置过滤规则，只有符合规则的请求才会触发hook。过滤规则是一个对象数组，参考下例
-        ajaxHooker.filter([
-            {type: 'xhr', url: 'www.example.com', method: 'GET', async: true},
-            {url: /^http/},
-        ]);
-     */
-  filter(filterOptions: UtilsAjaxHookFilterOptions[]): void;
-  /**
-     * 阻止xhr和fetch被改写
-     * @example
-        // 如果库劫持失败，可能是其他代码对xhr/fetch进行了二次劫持，protect方法会尝试阻止xhr和fetch被改写。应于document-start阶段尽早执行，部分网页下可能引发错误，谨慎使用。
-        ajaxHooker.protect();
-     */
-  protect(): void;
-  /**
-     * 取消劫持
-     * @example
-        // 将xhr和fetch恢复至劫持前的状态，调用此方法后，hook方法不再生效。
-        ajaxHooker.unhook();
-     */
-  unhook(): void;
-}
+import type { HttpxHeaders, HttpxMethod, HttpxStatus } from "./Httpx";
+
+/** 请求的response配置 */
+export declare interface UtilsAjaxHookResponseOptions {
+  /**
+   * （重定向后的）Url
+   */
+  finalUrl: string;
+  /**
+   * 响应码
+   */
+  status: HttpxStatus;
+  /**
+   * 响应头
+   */
+  responseHeaders: HttpxHeaders;
+  /**
+   * 响应内容
+   */
+  response?: string | Blob | ArrayBuffer | XMLDocument | FormData;
+  /**
+   * 响应内容文本
+   */
+  responseText?: string;
+}
+
+/** hook请求的配置 */
+export declare interface UtilsAjaxHookRequestOptions {
+  /**
+   * 只读属性。一个字符串，表明请求类型是xhr还是fetch
+   */
+  type: "xhr";
+  /**
+   * 请求的Url
+   */
+  url: string;
+  /**
+   * 请求的url和method，可以直接修改
+   */
+  method: HttpxMethod;
+  /**
+   * 是否取消请求，设置为true即可取消本次请求
+   */
+  abort: boolean;
+  /**
+   * 请求头，可以直接修改
+   */
+  headers: HttpxHeaders;
+  /**
+   * 请求携带的数据，可以直接修改
+   */
+  data?: any;
+  /**
+   * 响应内容，必须通过一个回调函数进行读取和修改。
+   *
+   * 响应内容为一个对象，包含finalUrl、status、responseHeaders和被读取的响应数据，除响应数据可修改，其他属性是只读的。
+   *
+   * 响应数据是哪个属性取决于哪个属性被读取，xhr可能的属性为response、responseText、responseXML，fetch可能的属性为arrayBuffer、blob、formData、json、text。
+   *
+   * 在控制台输出时，xhr响应将包含所有属性，但只有被读取过的属性具有明确的值。修改对应属性即可影响读取结果，进而实现响应数据的修改。
+   */
+  response?: (res: Required<UtilsAjaxHookResponseOptions>) => void;
+  /**
+   * 只读属性。异步请求为true，同步请求为false，异步特性无法作用于同步请求
+   */
+  async: boolean;
+}
+
+/** 过滤规则配置 */
+export declare interface UtilsAjaxHookFilterOptions {
+  /**
+   * 应是xhr或fetch
+   */
+  type?: "xhr" | "fetch";
+  /**
+   * 字符串或正则表达式，无需完全匹配
+   */
+  url?: string;
+  /**
+   * 请求方法
+   */
+  method?: HttpxMethod;
+  /**
+   * 是否异步
+   */
+  async?: boolean;
+}
+
+/** Utils.ajaxHooker */
+export declare interface UtilsAjaxHookResult {
+  /**
+     * 劫持
+     * @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 | Promise<undefined>): void;
+  /**
+     * 过滤
+     * @example
+        // 应于hook方法之前执行，此方法若尽早执行，有助于提升性能。
+        // 为hook方法设置过滤规则，只有符合规则的请求才会触发hook。过滤规则是一个对象数组，参考下例
+        ajaxHooker.filter([
+            {type: 'xhr', url: 'www.example.com', method: 'GET', async: true},
+            {url: /^http/},
+        ]);
+     */
+  filter(filterOptions: UtilsAjaxHookFilterOptions[]): void;
+  /**
+     * 阻止xhr和fetch被改写
+     * @example
+        // 如果库劫持失败，可能是其他代码对xhr/fetch进行了二次劫持，protect方法会尝试阻止xhr和fetch被改写。应于document-start阶段尽早执行，部分网页下可能引发错误，谨慎使用。
+        ajaxHooker.protect();
+     */
+  protect(): void;
+  /**
+     * 取消劫持
+     * @example
+        // 将xhr和fetch恢复至劫持前的状态，调用此方法后，hook方法不再生效。
+        ajaxHooker.unhook();
+     */
+  unhook(): void;
+}

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

@@ -1,7 +1,7 @@
-/* eslint-disable no-var */
-declare var jQuery: any;
-declare var unsafeWindow: Window;
-
-declare var mozIndexedDB: IDBFactory | null;
-declare var webkitIndexedDB: IDBFactory | null;
-declare var msIndexedDB: IDBFactory | null;
+/* eslint-disable no-var */
+declare var jQuery: any;
+declare var unsafeWindow: Window;
+
+declare var mozIndexedDB: IDBFactory | null;
+declare var webkitIndexedDB: IDBFactory | null;
+declare var msIndexedDB: IDBFactory | null;

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

@@ -1,31 +1,31 @@
-export type JSTypeMap = {
-  string: string;
-  number: number;
-  boolean: boolean;
-  object: object;
-  symbol: symbol;
-  bigint: bigint;
-  undefined: undefined;
-  null: null;
-};
-
-export type JSTypeNames = keyof JSTypeMap;
-
-export type ArgsType<T extends JSTypeNames[]> = {
-  [I in keyof T]: JSTypeMap[T[I]];
-};
-
-export declare interface UtilsOwnObject<V> {
-  [key: string]: V | UtilsOwnObject<V>;
-}
-
-export declare interface AnyObject {
-  [key: string]: any | AnyObject;
-  toString(): string;
-}
-
-export type PartialKeys<T, K extends keyof T> = {
-  [P in K]?: T[P];
-};
-
-export type Values<T> = T[keyof T];
+export type JSTypeMap = {
+  string: string;
+  number: number;
+  boolean: boolean;
+  object: object;
+  symbol: symbol;
+  bigint: bigint;
+  undefined: undefined;
+  null: null;
+};
+
+export type JSTypeNames = keyof JSTypeMap;
+
+export type ArgsType<T extends JSTypeNames[]> = {
+  [I in keyof T]: JSTypeMap[T[I]];
+};
+
+export declare interface UtilsOwnObject<V> {
+  [key: string]: V | UtilsOwnObject<V>;
+}
+
+export declare interface AnyObject {
+  [key: string]: any | AnyObject;
+  toString(): string;
+}
+
+export type PartialKeys<T, K extends keyof T> = {
+  [P in K]?: T[P];
+};
+
+export type Values<T> = T[keyof T];

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@whitesev/utils",
-  "version": "2.8.2",
+  "version": "2.9.0",
   "type": "module",
   "description": "一个常用的工具库",
   "main": "dist/index.cjs.js",
@@ -36,28 +36,32 @@
   "author": "WhiteSev",
   "license": "MIT",
   "dependencies": {
-    "worker-timers": "^8.0.21"
+    "worker-timers": "^8.0.25"
   },
   "devDependencies": {
-    "@eslint/js": "^9.35.0",
+    "@eslint/js": "^9.36.0",
     "@rollup/plugin-commonjs": "^28.0.6",
     "@rollup/plugin-json": "^6.1.0",
     "@rollup/plugin-node-resolve": "^16.0.1",
-    "@rollup/plugin-typescript": "^12.1.2",
+    "@rollup/plugin-terser": "^0.4.4",
+    "@rollup/plugin-typescript": "^12.1.4",
     "browserslist": "^4.26.2",
-    "caniuse-lite": "^1.0.30001743",
-    "eslint": "^9.35.0",
+    "caniuse-lite": "^1.0.30001745",
+    "eslint": "^9.36.0",
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-compat": "^6.0.2",
     "eslint-plugin-prettier": "^5.5.4",
     "globals": "^16.4.0",
-    "rollup": "^4.44.1",
+    "rollup": "^4.52.3",
     "rollup-plugin-clear": "^2.0.7",
     "tslib": "^2.8.1",
-    "typescript": "^5.8.3",
-    "typescript-eslint": "^8.44.0"
+    "typescript": "^5.9.2",
+    "typescript-eslint": "^8.44.1"
   },
   "scripts": {
+    "install": "pnpm install --ignore-workspace",
+    "outdated": "pnpm outdated --ignore-workspace",
+    "update": "pnpm update --latest --ignore-workspace",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
     "format": "prettier . --write",

package/src/ColorConversion.ts

@@ -1,105 +1,105 @@
-export class ColorConversion {
-  /**
-   * 判断是否是16进制颜色
-   * @param str
-   */
-  isHex(str: string): boolean {
-    if (typeof str !== "string") {
-      return false;
-    }
-    if (!str.match(/^(#|)[0-9a-fA-F]{6}$/)) {
-      return false;
-    }
-    return true;
-  }
-  /**
-   * 16进制颜色转rgba
-   *
-   * 例如：`#ff0000` 转为 `rgba(123,123,123, 0.4)`
-   * @param hex
-   * @param opacity
-   */
-  hexToRgba(hex: string, opacity: number): string {
-    if (!this.isHex(hex)) {
-      throw new TypeError(`输入错误的hex：${hex}`);
-    }
-    return hex && hex.replace(/\s+/g, "").length === 7
-      ? `rgba(${parseInt(`0x${hex.slice(1, 3)}`)},${parseInt(`0x${hex.slice(3, 5)}`)},${parseInt(
-          `0x${hex.slice(5, 7)}`
-        )},${opacity})`
-      : "";
-  }
-  /**
-   * hex转rgb
-   * @param str
-   */
-  hexToRgb(str: string) {
-    if (!this.isHex(str)) {
-      throw new TypeError(`输入错误的hex：${str}`);
-    }
-    /* replace替换查找的到的字符串 */
-    str = str.replace("#", "");
-    /* match得到查询数组 */
-    const hxs = str.match(/../g)!;
-    for (let index = 0; index < 3; index++) {
-      const value = parseInt(hxs[index], 16);
-      Reflect.set(hxs, index, value);
-    }
-
-    return hxs;
-  }
-  /**
-   * rgb转hex
-   * @param redValue
-   * @param greenValue
-   * @param blueValue
-   */
-  rgbToHex(redValue: string | number, greenValue: string | number, blueValue: string | number): string {
-    /* 验证输入的rgb值是否合法 */
-    const validPattern = /^\d{1,3}$/;
-    if (
-      !validPattern.test(redValue.toString()) ||
-      !validPattern.test(greenValue.toString()) ||
-      !validPattern.test(blueValue.toString())
-    )
-      throw new TypeError("输入错误的rgb颜色值");
-    const hexs = [redValue.toString(16), greenValue.toString(16), blueValue.toString(16)];
-    for (let index = 0; index < 3; index++) if (hexs[index].length == 1) hexs[index] = `0${hexs[index]}`;
-    return `#${hexs.join("")}`;
-  }
-  /**
-   * 获取颜色变暗或亮
-   * @param color 颜色
-   * @param level 0~1.0
-   */
-  getDarkColor(color: string, level: string): string {
-    if (!this.isHex(color)) {
-      throw new TypeError(`输入错误的hex：${color}`);
-    }
-    const rgbc = this.hexToRgb(color);
-    for (let index = 0; index < 3; index++) {
-      const rgbcItemValue = rgbc[index];
-      const value = Math.floor(Number(rgbcItemValue) * (1 - Number(level)));
-      Reflect.set(rgbc, index, value);
-    }
-
-    return this.rgbToHex(rgbc[0], rgbc[1], rgbc[2]);
-  }
-  /**
-   * 获取颜色变亮
-   * @param color 颜色
-   * @param level 0~1.0
-   */
-  getLightColor(color: string, level: number): string {
-    if (!this.isHex(color)) {
-      throw new TypeError(`输入错误的hex：${color}`);
-    }
-    const rgbc = this.hexToRgb(color);
-    for (let index = 0; index < 3; index++) {
-      const rgbcItemValue = Number(rgbc[index]);
-      const value = Math.floor(255 - rgbcItemValue * level + rgbcItemValue);
-      Reflect.set(rgbc, index, value);
-    }
-    return this.rgbToHex(rgbc[0], rgbc[1], rgbc[2]);
-  }
-}
+export class ColorConversion {
+  /**
+   * 判断是否是16进制颜色
+   * @param str
+   */
+  isHex(str: string): boolean {
+    if (typeof str !== "string") {
+      return false;
+    }
+    if (!str.match(/^(#|)[0-9a-fA-F]{6}$/)) {
+      return false;
+    }
+    return true;
+  }
+  /**
+   * 16进制颜色转rgba
+   *
+   * 例如：`#ff0000` 转为 `rgba(123,123,123, 0.4)`
+   * @param hex
+   * @param opacity
+   */
+  hexToRgba(hex: string, opacity: number): string {
+    if (!this.isHex(hex)) {
+      throw new TypeError(`输入错误的hex：${hex}`);
+    }
+    return hex && hex.replace(/\s+/g, "").length === 7
+      ? `rgba(${parseInt(`0x${hex.slice(1, 3)}`)},${parseInt(`0x${hex.slice(3, 5)}`)},${parseInt(
+          `0x${hex.slice(5, 7)}`
+        )},${opacity})`
+      : "";
+  }
+  /**
+   * hex转rgb
+   * @param str
+   */
+  hexToRgb(str: string) {
+    if (!this.isHex(str)) {
+      throw new TypeError(`输入错误的hex：${str}`);
+    }
+    /* replace替换查找的到的字符串 */
+    str = str.replace("#", "");
+    /* match得到查询数组 */
+    const hxs = str.match(/../g)!;
+    for (let index = 0; index < 3; index++) {
+      const value = parseInt(hxs[index], 16);
+      Reflect.set(hxs, index, value);
+    }
+
+    return hxs;
+  }
+  /**
+   * rgb转hex
+   * @param redValue
+   * @param greenValue
+   * @param blueValue
+   */
+  rgbToHex(redValue: string | number, greenValue: string | number, blueValue: string | number): string {
+    /* 验证输入的rgb值是否合法 */
+    const validPattern = /^\d{1,3}$/;
+    if (
+      !validPattern.test(redValue.toString()) ||
+      !validPattern.test(greenValue.toString()) ||
+      !validPattern.test(blueValue.toString())
+    )
+      throw new TypeError("输入错误的rgb颜色值");
+    const hexs = [redValue.toString(16), greenValue.toString(16), blueValue.toString(16)];
+    for (let index = 0; index < 3; index++) if (hexs[index].length == 1) hexs[index] = `0${hexs[index]}`;
+    return `#${hexs.join("")}`;
+  }
+  /**
+   * 获取颜色变暗或亮
+   * @param color 颜色
+   * @param level 0~1.0
+   */
+  getDarkColor(color: string, level: string): string {
+    if (!this.isHex(color)) {
+      throw new TypeError(`输入错误的hex：${color}`);
+    }
+    const rgbc = this.hexToRgb(color);
+    for (let index = 0; index < 3; index++) {
+      const rgbcItemValue = rgbc[index];
+      const value = Math.floor(Number(rgbcItemValue) * (1 - Number(level)));
+      Reflect.set(rgbc, index, value);
+    }
+
+    return this.rgbToHex(rgbc[0], rgbc[1], rgbc[2]);
+  }
+  /**
+   * 获取颜色变亮
+   * @param color 颜色
+   * @param level 0~1.0
+   */
+  getLightColor(color: string, level: number): string {
+    if (!this.isHex(color)) {
+      throw new TypeError(`输入错误的hex：${color}`);
+    }
+    const rgbc = this.hexToRgb(color);
+    for (let index = 0; index < 3; index++) {
+      const rgbcItemValue = Number(rgbc[index]);
+      const value = Math.floor(255 - rgbcItemValue * level + rgbcItemValue);
+      Reflect.set(rgbc, index, value);
+    }
+    return this.rgbToHex(rgbc[0], rgbc[1], rgbc[2]);
+  }
+}