@whitesev/utils 1.0.5 → 1.0.8

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"]

package/dist/src/Dictionary/Dictionary.d.ts

@@ -1,85 +0,0 @@
-export class UtilsDictionary {
-    items: {};
-    /**
-     * 检查是否有某一个键
-     * @param {string} key 键
-     * @returns {boolean}
-     */
-    has(key: string): boolean;
-    /**
-     * 检查已有的键中是否以xx开头
-     * @param {string} key 需要匹配的键
-     * @returns {boolean}
-     */
-    startsWith(key: string): boolean;
-    /**
-     * 获取以xx开头的键的值
-     * @param {string} key 需要匹配的键
-     * @returns {any}
-     */
-    getStartsWith(key: string): any;
-    /**
-     * 为字典添加某一个值
-     * @param {string} key 键
-     * @param {any} val 值，默认为""
-     */
-    set(key: string, val?: any): void;
-    /**
-     * 删除某一个键
-     * @param {string} key 键
-     * @returns {boolean}
-     */
-    delete(key: string): boolean;
-    /**
-     * 获取某个键的值
-     * @param {string} key 键
-     * @returns {any}
-     */
-    get(key: string): any;
-    /**
-     * 返回字典中的所有值
-     * @returns {any[]}
-     */
-    values(): any[];
-    /**
-     * 清空字典
-     */
-    clear(): void;
-    /**
-     * 获取字典的长度
-     * @returns {number}
-     */
-    size(): number;
-    /**
-     * 获取字典所有的键
-     */
-    keys(): string[];
-    /**
-     * 返回字典本身
-     * @returns {object}
-     */
-    getItems(): object;
-    /**
-     * 合并另一个字典
-     * @param {object} data 需要合并的字典
-     */
-    concat(data: object): void;
-    forEach(callbackfn: any): void;
-    /**
-     * 获取字典的长度，同this.size
-     * @returns {number}
-     */
-    get length(): number;
-    /**
-     * 迭代器
-     */
-    get entries(): () => Generator<any[], void, unknown>;
-    /**
-     * 是否可遍历
-     */
-    get [Symbol.iterator](): () => Generator<any[], void, unknown>;
-    /**
-     * .toString()和.toLocaleString()输出的字符串
-     */
-    get [Symbol.toStringTag](): string;
-}

package/dist/src/Hooks/Hooks.d.ts

@@ -1,5 +0,0 @@
-export function Hooks(): void;
-export class Hooks {
-    initEnv: () => void;
-    cleanEnv: () => boolean;
-}

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

@@ -1,50 +0,0 @@
-export function Httpx(__xmlHttpRequest__: any): void;
-export class Httpx {
-    constructor(__xmlHttpRequest__: any);
-    /**
-     * 覆盖当前配置
-     * @param {HttpxDetailsConfig} details
-     */
-    config: (details?: HttpxDetailsConfig) => void;
-    /**
-     * 修改xmlHttpRequest
-     * @param {Function} httpRequest 网络请求函数
-     */
-    setXMLHttpRequest: (httpRequest: Function) => void;
-    /**
-     * GET 请求
-     * @param {...HttpxDetails|string} args
-     * @returns {Promise< HttpxAsyncResult >}
-     */
-    get: (...args: (HttpxDetails | string)[]) => Promise<HttpxAsyncResult<any>>;
-    /**
-     * POST 请求
-     * @param {...HttpxDetails|string} args
-     * @returns {Promise< HttpxAsyncResult >}
-     */
-    post: (...args: (HttpxDetails | string)[]) => Promise<HttpxAsyncResult<any>>;
-    /**
-     * HEAD 请求
-     * @param {...HttpxDetails|string} args
-     * @returns {Promise< HttpxAsyncResult >}
-     */
-    head: (...args: (HttpxDetails | string)[]) => Promise<HttpxAsyncResult<any>>;
-    /**
-     * OPTIONS 请求
-     * @param {...HttpxDetails|string} args
-     * @returns {Promise< HttpxAsyncResult >}
-     */
-    options: (...args: (HttpxDetails | string)[]) => Promise<HttpxAsyncResult<any>>;
-    /**
-     * DELETE 请求
-     * @param {...HttpxDetails|string} args
-     * @returns {Promise< HttpxAsyncResult >}
-     */
-    delete: (...args: (HttpxDetails | string)[]) => Promise<HttpxAsyncResult<any>>;
-    /**
-     * PUT 请求
-     * @param {...HttpxDetails|string} args
-     * @returns {Promise< HttpxAsyncResult >}
-     */
-    put: (...args: (HttpxDetails | string)[]) => Promise<HttpxAsyncResult<any>>;
-}

package/dist/src/LockFunction/LockFunction.d.ts

@@ -1,16 +0,0 @@
-export function LockFunction(callback: any, context: any, delayTime?: number): void;
-export class LockFunction {
-    constructor(callback: any, context: any, delayTime?: number);
-    /**
-     * 锁
-     */
-    lock: () => void;
-    /**
-     * 解锁
-     */
-    unlock: () => void;
-    /**
-     * 执行
-     */
-    run: (...args: any[]) => Promise<void>;
-}