@whitesev/utils 1.0.5 → 1.0.6

package/src/index.ts

@@ -1,27 +1,18 @@
 /// <reference path="./ajaxHooker/index.d.ts" />
-/// <reference path="./Dictionary/index.d.ts" />
-/// <reference path="./Hooks/index.d.ts" />
-/// <reference path="./Httpx/index.d.ts" />
-/// <reference path="./indexedDB/index.d.ts" />
-/// <reference path="./LockFunction/index.d.ts" />
-/// <reference path="./Log/index.d.ts" />
-/// <reference path="./Progress/index.d.ts" />
-/// <reference path="./tryCatch/index.d.ts" />
-/// <reference path="./UtilsGMMenu/index.d.ts" />
 import { ColorConversion } from "./ColorConversion";
 import { GBKEncoder } from "./GBKEncoder";
 import { UtilsCore } from "./UtilsCore";
 import { UtilsGMCookie } from "./UtilsGMCookie";
 import { AjaxHooker } from "./ajaxHooker/ajaxHooker.js";
-import { GMMenu } from "./UtilsGMMenu/UtilsGMMenu";
-import { Hooks } from "./Hooks/Hooks";
-import { Httpx } from "./Httpx/Httpx";
-import { indexedDB } from "./indexedDB/indexedDB";
-import { LockFunction } from "./LockFunction/LockFunction";
-import { Log } from "./Log/Log";
-import { Progress } from "./Progress/Progress";
-import { TryCatch } from "./tryCatch/tryCatch";
-import { UtilsDictionary } from "./Dictionary/Dictionary";
+import { GMMenu } from "./UtilsGMMenu";
+import { Hooks } from "./Hooks";
+import { Httpx } from "./Httpx";
+import { indexedDB } from "./indexedDB";
+import { LockFunction } from "./LockFunction";
+import { Log } from "./Log";
+import { Progress } from "./Progress";
+import { TryCatch } from "./tryCatch";
+import { UtilsDictionary } from "./Dictionary";
 
 export declare var unsafeWindow: Window & typeof globalThis;
 
@@ -692,9 +683,7 @@ class Utils {
 	 * > true
 	 * dictionary.concat(dictionary2);
 	 **/
-	Dictionary: {
-		new <K, V>(): UtilsDictionaryConstructor<K, V>;
-	} = UtilsDictionary as any;
+	Dictionary = UtilsDictionary;
 	/**
 	 * 主动触发事件
 	 * @param element 元素
@@ -1845,7 +1834,7 @@ class Utils {
       // 删除键为menu_key的菜单
       GM_Menu.delete("menu_key");
      **/
-	GM_Menu: UtilsGMMenu = GMMenu as any;
+	GM_Menu = GMMenu;
 	/**
      * 基于Function prototype，能够勾住和释放任何函数
      * 
@@ -1870,7 +1859,7 @@ class Utils {
       }
       testFunction.hook(testFunction,myFunction,window);
      **/
-	Hooks: UtilsHooks = Hooks;
+	Hooks = Hooks;
 
 	/**
      * 为减少代码量和回调，把GM_xmlhttpRequest封装
@@ -1910,7 +1899,7 @@ class Utils {
       })
       // 优先级为 默认details < 全局details < 单独的details
      */
-	Httpx: UtilsHttpx = Httpx;
+	Httpx = Httpx;
 	/**
      * 浏览器端的indexedDB操作封装
      * @example
@@ -1936,7 +1925,7 @@ class Utils {
           console.log(resolve,'清除数据库---->>>>>>name')
       })
      **/
-	indexedDB: UtilsIndexedDB = indexedDB;
+	indexedDB = indexedDB;
 	/**
 	 * 判断目标函数是否是Native Code
 	 * @param target
@@ -2590,7 +2579,7 @@ class Utils {
       await lock.run();
       > 1
      **/
-	LockFunction: UtilsLockFunction = LockFunction;
+	LockFunction = LockFunction;
 	/**
      * 日志对象
      * @param _GM_info_ 油猴管理器的API GM_info，或者是一个对象，如{"script":{name:"Utils.Log"}}
@@ -2620,7 +2609,7 @@ class Utils {
       log.success("颜色为#31dc02");
       > 颜色为#31dc02
      */
-	Log: UtilsLog = Log;
+	Log = Log;
 	/**
 	 * 合并数组内的JSON的值字符串
 	 * @param data 需要合并的数组
@@ -3214,7 +3203,7 @@ class Utils {
       let progress = new Utils.Process({canvasNode:document.querySelector("canvas")});
       progress.draw();
      * **/
-	Progress: UtilsProgress = Progress;
+	Progress = Progress;
 	/**
 	 * 劫持Event的isTrust为true，注入时刻，ducument-start
 	 * @param isTrustValue （可选）让isTrusted为true
@@ -4030,7 +4019,6 @@ class Utils {
 	}
 	/**
 	 * 提供一个封装了 try-catch 的函数，可以执行传入的函数并捕获其可能抛出的错误，并通过传入的错误处理函数进行处理。
-	 * @returns 返回一个对象，其中包含 error 和 run 两个方法。
 	 * @example
 	 * Utils.tryCatch().error().run(()=>{console.log(1)});
 	 * > 1

package/src/indexedDB.ts

@@ -0,0 +1,421 @@
+import type { AnyObject } from ".";
+
+declare interface UtilsIDBOpenErrorResult {
+	code: number;
+	msg: string;
+	event: Event;
+}
+
+class indexedDB {
+	#dbName: string;
+	#storeName: string;
+	#dbVersion: number;
+	/* websql的版本号，由于ios的问题，版本号的写法不一样 */
+	#slqVersion = "1";
+	/* 监听IndexDB */
+	#indexedDB =
+		window.indexedDB ||
+		(window as any).mozIndexedDB ||
+		(window as any).webkitIndexedDB ||
+		(window as any).msIndexedDB;
+	/* 缓存数据库，避免同一个页面重复创建和销毁 */
+	#db: {
+		[key: string]: IDBDatabase;
+	} = {};
+	#store: IDBObjectStore = null as any;
+	#errorCode = {
+		/* 错误码 */
+		success: {
+			code: 200,
+			msg: "操作成功",
+		},
+		error: {
+			code: 401,
+			msg: "操作失败",
+		},
+		open: { code: 91001, msg: "打开数据库失败" },
+		save: { code: 91002, msg: "保存数据失败" },
+		get: { code: 91003, msg: "获取数据失败" },
+		delete: { code: 91004, msg: "删除数据失败" },
+		deleteAll: { code: 91005, msg: "清空数据库失败" },
+		regexpGet: { code: 91006, msg: "正则获取数据失败" },
+	};
+	/**
+	 * @param dbName 数据存储名，默认为：default_db
+	 * @param storeName 表名，默认为：default_form
+	 * @param dbVersion indexDB的版本号，默认为：1
+	 */
+	constructor(
+		dbName = "default_db",
+		storeName = "default_form",
+		dbVersion = 1
+	) {
+		this.#dbName = dbName;
+		this.#storeName = storeName;
+		this.#dbVersion = dbVersion;
+		if (!this.#indexedDB) {
+			alert("很抱歉，您的浏览器不支持indexedDB");
+			throw new TypeError("很抱歉，您的浏览器不支持indexedDB");
+			return;
+		}
+	}
+	/**
+	 * 创建 “表”
+	 * @param dbName 表名
+	 */
+	createStore(dbName: string) {
+		let txn, store;
+		txn = this.#db[dbName].transaction(
+			this.#storeName,
+			"readwrite"
+		) as IDBTransaction;
+		/* IndexDB的读写权限 */
+		store = txn.objectStore(this.#storeName) as IDBObjectStore;
+		this.#store = store;
+		return store;
+	}
+	/**
+	 * 打开数据库
+	 * @param callback  回调
+	 * @param dbName 数据库名
+	 */
+	private open(
+		callback: (
+			idbStore: IDBObjectStore | UtilsIDBOpenErrorResult,
+			success: boolean
+		) => void,
+		dbName: string
+	) {
+		let that = this;
+		/* 打开数据库 */
+		/* 如果支持IndexDB */
+		if (!that.#db[dbName]) {
+			/* 如果缓存中没有，则进行数据库的创建或打开，提高效率 */
+			let request = that.#indexedDB.open(dbName, that.#dbVersion);
+			request.onerror = function (event: Event) {
+				callback(
+					{
+						code: that.#errorCode.open.code,
+						msg: that.#errorCode.open.msg,
+						event: event,
+					},
+					false
+				);
+			};
+			request.onsuccess = function (event: Event) {
+				if (!that.#db[dbName]) {
+                    let target = event.target as IDBRequest;
+					that.#db[dbName] = target.result;
+				}
+				let store = that.createStore(dbName);
+				callback(store, true);
+			};
+			request.onupgradeneeded = function (event: Event) {
+                let target = event.target as IDBRequest;
+				that.#db[dbName] = target.result;
+				let store = that.#db[dbName].createObjectStore(that.#storeName, {
+					keyPath: "key",
+				});
+				store.transaction.oncomplete = function (event: Event) {
+					callback(store, true);
+				};
+			};
+		} else {
+			/* 如果缓存中已经打开了数据库，就直接使用 */
+			let store = that.createStore(dbName);
+			callback(store, true);
+		}
+	}
+	/**
+	 * 保存数据到数据库
+	 * @param key 数据key
+	 * @param value 数据值
+	 */
+	async save(
+		key: string,
+		value: any
+	): Promise<{
+		success: boolean;
+		code: number;
+		msg: string;
+
+		event?: Event;
+	}> {
+		let that = this;
+		return new Promise((resolve) => {
+			let dbName = that.#dbName;
+			let inData = {
+				key: key,
+				value: value,
+			};
+			that.open(function (idbStore, success) {
+				if (!success) {
+					resolve({
+						success: false,
+						code: that.#errorCode.save.code,
+						msg: that.#errorCode.save.msg,
+					});
+				} else {
+					idbStore = idbStore as IDBObjectStore;
+					let request = idbStore.put(inData);
+					request.onsuccess = function (event: Event) {
+						/* 保存成功有success 字段 */
+						let target = event.target as IDBRequest;
+						resolve({
+							success: true,
+							code: that.#errorCode.success.code,
+							msg: that.#errorCode.success.msg,
+
+							event: event,
+						});
+					};
+					request.onerror = function (event: Event) {
+						let target = event.target as IDBRequest;
+						resolve({
+							success: false,
+
+							code: that.#errorCode.save.code,
+							msg: that.#errorCode.save.msg,
+							event: event,
+						});
+					};
+				}
+			}, dbName);
+		});
+	}
+
+	/**
+	 * 根据key获取值
+	 * @param key 数据key
+	 */
+	async get<T extends any>(
+		key: string
+	): Promise<{
+		success: boolean;
+		code: number;
+		msg: string;
+		data: T;
+
+		event?: Event;
+		result?: any;
+	}> {
+		let that = this;
+		return new Promise((resolve) => {
+			let dbName = that.#dbName;
+			that.open(function (idbStore, success) {
+				/* 判断返回的数据中是否有error字段 */
+				if (!success) {
+					resolve({
+						success: false,
+						code: that.#errorCode.get.code,
+						msg: that.#errorCode.get.msg,
+						data: void 0 as any,
+					});
+				} else {
+					idbStore = idbStore as IDBObjectStore;
+					let request = idbStore.get(key);
+					request.onsuccess = function (event: any) {
+						let target = event.target as IDBRequest;
+						let result = target.result;
+						/* result 返回的是 {key: string, value: any} */
+						/* 键值对存储 */
+						let data: T = result ? result.value : void 0;
+						if (data) {
+							resolve({
+								success: true,
+								code: that.#errorCode.success.code,
+								msg: that.#errorCode.success.msg,
+								data: data,
+
+								event: event,
+								result: result,
+							});
+						} else {
+							resolve({
+								success: false,
+								code: that.#errorCode.error.code,
+								msg: that.#errorCode.error.msg,
+								data: void 0 as any,
+
+								event: event,
+								result: result,
+							});
+						}
+					};
+					request.onerror = function (event: any) {
+						let target = event.target as IDBRequest;
+						resolve({
+							success: false,
+							code: that.#errorCode.get.code,
+							msg: that.#errorCode.get.msg,
+							data: void 0 as any,
+
+							event: event,
+						});
+					};
+				}
+			}, dbName);
+		});
+	}
+
+	/**
+	 * 正则获取数据
+	 * @param key 数据键
+	 */
+	async regexpGet<T extends any>(
+		key: string
+	): Promise<{
+		success: boolean;
+		code: number;
+		msg: string;
+		data: T[];
+
+		event?: Event;
+	}> {
+		let list: T[] = [];
+		let that = this;
+		return new Promise((resolve) => {
+			/* 正则查询 */
+			let dbName = that.#dbName;
+			that.open(function (idbStore, success) {
+				/* 判断返回的数据中是否有error字段 */
+				if (!success) {
+					resolve({
+						success: false,
+						code: that.#errorCode.regexpGet.code,
+						msg: that.#errorCode.regexpGet.msg,
+						data: [],
+					});
+				} else {
+					idbStore = idbStore as IDBObjectStore;
+					let request = idbStore.getAll();
+					request.onsuccess = function (event: any) {
+						let target = event.target as IDBRequest;
+						let result = target.result;
+						if (result.length !== 0) {
+							result.forEach((item: any, index: any) => {
+								if (item["key"].match(key)) {
+									let concatList = item["value"];
+									concatList["key"] = item["key"];
+									list = [...list, concatList];
+								}
+							});
+						}
+						resolve({
+							success: true,
+							code: that.#errorCode.success.code,
+							msg: that.#errorCode.success.msg,
+							data: list,
+
+							event: event,
+						});
+					};
+					request.onerror = function (event: any) {
+						let target = event.target as IDBRequest;
+						resolve({
+							success: false,
+							code: that.#errorCode.get.code,
+							msg: that.#errorCode.get.msg,
+							data: [],
+
+							event: event,
+						});
+					};
+				}
+			}, dbName);
+		});
+	}
+
+	/**
+	 * 删除数据
+	 * @param {string} key 数据键
+	 */
+	async delete(key: string): Promise<{
+		success: boolean;
+		code: number;
+		msg: string;
+
+		event?: Event;
+	}> {
+		let that = this;
+		return new Promise((resolve) => {
+			/* 根据key删除某条数据 */
+			let dbName = that.#dbName;
+			that.open(function (idbStore, success) {
+				if (!success) {
+					resolve({
+						success: false,
+						code: that.#errorCode.delete.code,
+						msg: that.#errorCode.delete.msg,
+					});
+				} else {
+					idbStore = idbStore as IDBObjectStore;
+					let request = idbStore.get(key);
+					request.onsuccess = function (event: any) {
+						let target = event.target as IDBRequest;
+						let recode = target.result;
+						if (recode) {
+							/* 成功 */
+							request = (idbStore as IDBObjectStore).delete(key);
+							resolve({
+								success: true,
+								code: that.#errorCode.success.code,
+								msg: that.#errorCode.success.msg,
+							});
+						} else {
+							resolve({
+								success: false,
+								code: that.#errorCode.error.code,
+								msg: that.#errorCode.error.msg,
+							});
+						}
+					};
+					request.onerror = function (event: any) {
+						let target = event.target as IDBRequest;
+						resolve({
+							success: false,
+							code: that.#errorCode.delete.code,
+							msg: that.#errorCode.delete.msg,
+
+							event: event,
+						});
+					};
+				}
+			}, dbName);
+		});
+	}
+
+	/**
+	 * 删除所有数据
+	 */
+	async deleteAll(): Promise<{
+		success: boolean;
+		code: number;
+		msg: string;
+	}> {
+		let that = this;
+		return new Promise((resolve) => {
+			/* 清空数据库 */
+			let dbName = that.#dbName;
+			that.open(function (idbStore, success) {
+				if (!success) {
+					resolve({
+						success: false,
+						code: that.#errorCode.deleteAll.code,
+						msg: that.#errorCode.deleteAll.msg,
+					});
+				} else {
+					idbStore = idbStore as IDBObjectStore;
+					idbStore.clear();
+					resolve({
+						success: true,
+						code: that.#errorCode.success.code,
+						msg: that.#errorCode.success.msg,
+					});
+				}
+			}, dbName);
+		});
+	}
+}
+
+export { indexedDB };

package/src/tryCatch.ts

@@ -0,0 +1,107 @@
+import { Utils } from ".";
+
+export declare interface UtilsTryCatchConfig {
+	log: boolean;
+}
+/** tryCatch */
+export declare interface UtilsTryCatchType {
+	run: UtilsTryCatchType;
+	config: UtilsTryCatchType;
+	error: UtilsTryCatchType;
+}
+const TryCatch = function (...args: any) {
+	/* 定义变量和函数 */
+	let callbackFunction = null;
+	let context = null;
+	let handleError = (error: Error) => {};
+	let defaultDetails = {
+		log: true,
+	};
+
+	const TryCatchCore = {
+		/**
+		 *
+		 * @param paramDetails 配置
+		 * @returns
+		 */
+		config(paramDetails: UtilsTryCatchConfig) {
+			defaultDetails = Utils.assign(defaultDetails, paramDetails);
+			return TryCatchCore;
+		},
+		/**
+		 * 处理错误
+		 * @param handler
+		 */
+		error(handler: ((...args: any[]) => any) | string | Function) {
+			// @ts-ignore
+			handleError = handler;
+			return TryCatchCore;
+		},
+		/**
+		 * 执行传入的函数并捕获其可能抛出的错误，并通过传入的错误处理函数进行处理。
+		 * @param callback 待执行函数，可以是 function 或者 string 类型。如果是 string 类型，则会被当做代码进行执行。
+		 * @param __context__ 待执行函数的作用域，用于apply指定
+		 * @returns 如果函数有返回值，则返回该返回值；否则返回 tryCatchObj 函数以支持链式调用。
+		 * @throws {Error} 如果传入参数不符合要求，则会抛出相应类型的错误。
+		 */
+		run<A extends any[], R>(
+			callback: ((...args: A) => R) | string | Function,
+			__context__?: any
+		): UtilsTryCatchType {
+			callbackFunction = callback;
+			context = __context__ || this;
+			let result = executeTryCatch(callbackFunction, handleError, context);
+			// @ts-ignore
+			return result !== void 0 ? result : TryCatchCore;
+		},
+	};
+
+	/**
+	 * 执行传入的函数并捕获其可能抛出的错误，并通过传入的错误处理函数进行处理。
+	 * @param callback - 待执行函数，可以是 function 或者 string 类型。如果是 string 类型，则会被当做代码进行执行。
+	 * @param handleErrorFunc - 错误处理函数，可以是 function 或者 string 类型。如果是 string 类型，则会被当做代码进行执行。
+	 * @param funcThis - 待执行函数的作用域，用于apply指定
+	 * @returns 如果函数有返回值，则返回该返回值；否则返回 undefined。
+	 */
+	function executeTryCatch<A extends any[], R>(
+		callback: string | ((...args: A) => R) | Function,
+		handleErrorFunc: string | ((...args: any[]) => any),
+		funcThis?: any
+	) {
+		let result = void 0;
+		try {
+			if (typeof callback === "string") {
+				(function () {
+					eval(callback as string);
+				}).apply(funcThis, args);
+			} else {
+				result = (callback as Function).apply(funcThis, args);
+			}
+		} catch (error) {
+			if (defaultDetails.log) {
+				callback = callback as Function;
+				console.log(
+					`%c ${callback?.name ? callback?.name : callback + "出现错误"} `,
+					"color: #f20000"
+				);
+				console.log(`%c 错误原因：${error}`, "color: #f20000");
+				console.trace(callback);
+			}
+			if (handleErrorFunc) {
+				if (typeof handleErrorFunc === "string") {
+					result = function () {
+						return eval(handleErrorFunc);
+						// @ts-ignore
+					}.apply(funcThis, [...args, error]);
+				} else {
+					result = handleErrorFunc.apply(funcThis, [...args, error]);
+				}
+			}
+		}
+		return result;
+	}
+
+	return TryCatchCore;
+};
+
+export { TryCatch };

package/tsconfig.json

@@ -24,7 +24,7 @@
 		"outDir": "./dist",
 		// 输出.d.ts声明文件
 		"declaration": true,
-		"sourceMap": true,
+		"sourceMap": true
 	},
 	// 包含src下的所有文件
 	"include": ["src/**/*", "index.ts"]