@whitesev/utils 1.0.0

package/src/indexedDB.js

@@ -0,0 +1,355 @@
+const indexedDB = function (
+	dbName = "default_db",
+	storeName = "default_form",
+	dbVersion = 1
+) {
+	this.dbName = dbName;
+	/* websql的版本号，由于ios的问题，版本号的写法不一样 */
+	this.slqVersion = "1";
+	this.dbVersion = dbVersion;
+	this.storeName = storeName;
+	/* 监听IndexDB */
+	this.indexedDB =
+		window.indexedDB ||
+		window.mozIndexedDB ||
+		window.webkitIndexedDB ||
+		window.msIndexedDB;
+	if (!this.indexedDB) {
+		alert("很抱歉，您的浏览器不支持indexedDB");
+	}
+	/* 缓存数据库，避免同一个页面重复创建和销毁 */
+	this.db = {};
+	this.store = null;
+	this.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: "清空数据库失败" },
+	};
+	let that = this;
+	/**
+	 * 创建 “表”
+	 * @param {string} dbName 表名
+	 * @returns
+	 */
+	this.createStore = function (dbName) {
+		let txn, store;
+		if (that.indexedDB) {
+			/* 如果是支持IndexDB的 */
+			txn = that.db[dbName].transaction(that.storeName, "readwrite");
+			/* IndexDB的读写权限 */
+			store = txn.objectStore(that.storeName);
+		}
+		return store;
+	};
+	/**
+	 * 打开数据库
+	 * @param {function} callback  回调
+	 * @param {string} dbName 数据库名
+	 */
+	this.open = function (callback, dbName) {
+		/* 打开数据库 */
+		if (that.indexedDB) {
+			/* 如果支持IndexDB */
+			if (!that.db[dbName]) {
+				/* 如果缓存中没有，则进行数据库的创建或打开，提高效率 */
+				let request = that.indexedDB.open(dbName, that.dbVersion);
+				request.onerror = function (e) {
+					callback({
+						code: that.errorCode.open.code,
+						msg: that.errorCode.open.msg,
+						error: e,
+					});
+				};
+				request.onsuccess = function (e) {
+					if (!that.db[dbName]) {
+						that.db[dbName] = e.target.result;
+					}
+					let store = that.createStore(dbName);
+					callback(store);
+				};
+				request.onupgradeneeded = function (e) {
+					that.db[dbName] = e.target.result;
+					let store = that.db[dbName].createObjectStore(that.storeName, {
+						keyPath: "key",
+					});
+					store.transaction.oncomplete = function (event) {
+						callback(store);
+					};
+				};
+			} else {
+				/* 如果缓存中已经打开了数据库，就直接使用 */
+				let store = that.createStore(dbName);
+				callback(store);
+			}
+		}
+	};
+	/**
+	 * 保存数据到数据库
+	 * @param {string} key 数据key
+	 * @param {any} value 数据值
+	 * @returns {Promise< {
+	 *    code: number,
+	 *    msg: string,
+	 *    success: boolean
+	 * }>}
+	 */
+	this.save = async function (key, value) {
+		if (that.indexedDB) {
+			return new Promise((resolve, reject) => {
+				let dbName = that.dbName;
+				let inData = {
+					key: key,
+					value: value,
+				};
+				that.open(function (result) {
+					let error = result.hasOwnProperty("error");
+					if (error) {
+						resolve(result);
+					} else {
+						let request = result.put(inData);
+						request.onsuccess = function (e) {
+							/* 保存成功有success 字段 */
+							resolve({
+								code: that.errorCode.success.code,
+								msg: that.errorCode.success.msg,
+								success: true,
+							});
+						};
+						request.onerror = function (e) {
+							resolve({
+								code: that.errorCode.save.code,
+								msg: that.errorCode.save.msg,
+								error: e,
+							});
+						};
+					}
+				}, dbName);
+			});
+		}
+	};
+	/**
+	 * 根据key获取值
+	 * @param {string} key 数据key
+	 * @returns {Promise< {
+	 *    code: number,
+	 *    msg: string,
+	 *    data: [...any],
+	 *    success: true
+	 * }| {
+	 *    code: number,
+	 *    msg: string,
+	 *    error: Error,
+	 *    result: any,
+	 * } >}
+	 */
+	this.get = async function (key) {
+		return new Promise((resolve, reject) => {
+			let dbName = that.dbName;
+			if (that.indexedDB) {
+				that.open(function (result) {
+					/* 判断返回的数据中是否有error字段 */
+					let error = result.hasOwnProperty("error");
+					if (error) {
+						reject({
+							code: that.errorCode.open.get,
+							msg: that.errorCode.get.msg,
+							error: error,
+							result: result,
+						});
+					} else {
+						let request = result.get(key);
+						request.onsuccess = function (e) {
+							let result = e.target.result;
+							let data = result ? result.value : void 0;
+							resolve({
+								code: data
+									? that.errorCode.success.code
+									: that.errorCode.error.code,
+								msg: data
+									? that.errorCode.success.msg
+									: that.errorCode.error.msg,
+								data: data || [],
+								success: true,
+							});
+						};
+						request.onerror = function (e) {
+							reject({
+								code: that.errorCode.get.code,
+								msg: that.errorCode.get.msg,
+								result: result,
+								error: e,
+							});
+						};
+					}
+				}, dbName);
+			}
+		});
+	};
+	/**
+	 * 正则获取数据
+	 * @param {string} key 数据键
+	 * @returns { Promise<{
+	 *    code: number,
+	 *    msg: string,
+	 *    data: [...any],
+	 *    success: true
+	 * }|{
+	 *    code: number,
+	 *    msg: string,
+	 *    error: Error,
+	 *    result: any,
+	 * }> }
+	 */
+	this.regexpGet = async function (key) {
+		let list = [];
+		return new Promise((resolve, reject) => {
+			/* 正则查询 */
+			let dbName = that.dbName;
+			if (that.indexedDB) {
+				that.open(function (result) {
+					/* 判断返回的数据中是否有error字段 */
+					let error = result.hasOwnProperty("error");
+					if (error) {
+						reject({
+							code: that.errorCode.open.get,
+							msg: that.errorCode.get.msg,
+							error: error,
+							result: result,
+						});
+					} else {
+						let request = result.getAll();
+						request.onsuccess = function (e) {
+							let result = e.target.result;
+							if (result.length !== 0) {
+								result.forEach((item, index) => {
+									if (item["key"].match(key)) {
+										let concatList = item["value"];
+										concatList["key"] = item["key"];
+										list = [...list, concatList];
+									}
+								});
+							}
+							resolve({
+								code: that.errorCode.success.code,
+								msg: that.errorCode.success.msg,
+								data: list,
+								success: true,
+							});
+						};
+						request.onerror = function (e) {
+							reject({
+								code: that.errorCode.get.code,
+								msg: that.errorCode.get.msg,
+								result: result,
+								error: e,
+							});
+						};
+					}
+				}, dbName);
+			}
+		});
+	};
+	/**
+	 * 删除数据
+	 * @param {string} key 数据键
+	 * @returns {Promise<{
+	 *    code: number,
+	 *    msg: string,
+	 *    success: true,
+	 * }|{
+	 *    code: number,
+	 *    msg: string,
+	 *    error: Error,
+	 * }>}
+	 */
+	this.delete = async function (key) {
+		return new Promise((resolve, reject) => {
+			/* 根据key删除某条数据 */
+			let dbName = that.dbName;
+			if (that.indexedDB) {
+				that.open(function (result) {
+					let error = result.hasOwnProperty("error");
+					if (error) {
+						resolve(result);
+					} else {
+						let request = result.get(key);
+						request.onsuccess = function (e) {
+							let recode = e.target.result;
+							if (recode) {
+								request = result.delete(key);
+							}
+							resolve({
+								code: recode
+									? that.errorCode.success.code
+									: that.errorCode.error.code,
+								msg: recode
+									? that.errorCode.success.msg
+									: that.errorCode.error.msg,
+								success: true,
+							});
+						};
+						request.onerror = function (e) {
+							resolve({
+								code: that.errorCode.delete.code,
+								msg: that.errorCode.delete.msg,
+								error: e,
+							});
+						};
+					}
+				}, dbName);
+			}
+		});
+	};
+	/**
+	 * 删除所有数据
+	 * @returns {Promise<{
+	 *    code: number,
+	 *    msg: string,
+	 *    error: Error,
+	 *    result: any,
+	 * }|{
+	 *    code: number,
+	 *    msg: string,
+	 *    success: true,
+	 * }>}
+	 */
+	this.deleteAll = async function () {
+		return new Promise((resolve, reject) => {
+			/* 清空数据库 */
+			let dbName = that.dbName;
+			if (that.indexedDB) {
+				that.open(function (result) {
+					let error = result.hasOwnProperty("error");
+					if (error) {
+						resolve({
+							code: that.errorCode.deleteAll.code,
+							msg: that.errorCode.deleteAll.msg,
+							error: error,
+							result: result,
+						});
+					} else {
+						result.clear();
+						resolve({
+							code: that.errorCode.success.code,
+							msg: that.errorCode.success.msg,
+							success: true,
+						});
+					}
+				}, dbName);
+			}
+		});
+	};
+};
+
+export { indexedDB };

package/src/tryCatch.js

@@ -0,0 +1,100 @@
+/**
+ * 
+ * @param  {...any} args 
+ * @returns 
+ */
+const TryCatch = function (...args) {
+	/* 定义变量和函数 */
+	let callbackFunction = null;
+	let context = null;
+	let handleError = null;
+	let defaultDetails = {
+		log: true,
+	};
+	/**
+	 * @function tryCatchObj
+	 * @description 空函数，用于链式调用。
+	 */
+	function tryCatchObj() {}
+
+	/**
+	 * 配置
+	 * @param {{
+	 * log: boolean
+	 * }} paramDetails
+	 */
+	tryCatchObj.config = function (paramDetails) {
+		defaultDetails = Utils.assign(defaultDetails, paramDetails);
+		return tryCatchObj;
+	};
+	/**
+	 * 设置错误处理函数。
+	 * @param {function|string} handler 错误处理函数，可以是 function 或者 string 类型。如果是 string 类型，则会被当做代码进行执行。
+	 * @returns 返回 tryCatchObj 函数。
+	 */
+	tryCatchObj.error = function (handler) {
+		handleError = handler;
+		return tryCatchObj;
+	};
+
+	/**
+	 * 执行传入的函数并捕获其可能抛出的错误，并通过传入的错误处理函数进行处理。
+	 * @param {function|string} callback 待执行函数，可以是 function 或者 string 类型。如果是 string 类型，则会被当做代码进行执行。
+	 * @param {object|null} [__context__] 待执行函数的作用域，用于apply指定
+	 * @returns 如果函数有返回值，则返回该返回值；否则返回 tryCatchObj 函数以支持链式调用。
+	 * @throws {Error} 如果传入参数不符合要求，则会抛出相应类型的错误。
+	 */
+	tryCatchObj.run = function (callback, __context__) {
+		callbackFunction = callback;
+		context = __context__;
+		let result = executeTryCatch(callbackFunction, handleError, context);
+		return result !== void 0 ? result : tryCatchObj;
+	};
+
+	/**
+	 * 执行传入的函数并捕获其可能抛出的错误，并通过传入的错误处理函数进行处理。
+	 * @param {function|string} callback - 待执行函数，可以是 function 或者 string 类型。如果是 string 类型，则会被当做代码进行执行。
+	 * @param {function|string|null} handleErrorFunc - 错误处理函数，可以是 function 或者 string 类型。如果是 string 类型，则会被当做代码进行执行。
+	 * @param {object|null} funcThis - 待执行函数的作用域，用于apply指定
+	 * @returns {any|undefined} - 如果函数有返回值，则返回该返回值；否则返回 undefined。
+	 */
+	function executeTryCatch(callback, handleErrorFunc, funcThis) {
+		let result = void 0;
+		try {
+			if (typeof callback === "string") {
+				(function () {
+					eval(callback);
+				}).apply(funcThis, args);
+			} else {
+				result = callback.apply(funcThis, args);
+			}
+		} catch (error) {
+			if (defaultDetails.log) {
+				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);
+					}.apply(funcThis, [...args, error]);
+				} else {
+					result = handleErrorFunc.apply(funcThis, [...args, error]);
+				}
+			}
+		}
+		return result;
+	}
+
+	// 返回 tryCatchObj 函数
+	return tryCatchObj;
+};
+
+
+export {
+    TryCatch
+}

package/src/types/AjaxHooker.d.ts

@@ -0,0 +1,153 @@
+/** 请求的response配置 */
+declare interface UtilsAjaxHookResponseOptions {
+	/**
+	 * （重定向后的）Url
+	 */
+	finalUrl: string;
+	/**
+	 * 响应码
+	 */
+	status: HttpxStatus;
+	/**
+	 * 响应头
+	 */
+	responseHeaders: HttpxHeaders;
+	/**
+	 * 响应内容
+	 */
+	response?: string | Blob | ArrayBuffer | XMLDocument | FormData;
+	/**
+	 * 响应内容文本
+	 */
+	responseText?: string;
+}
+
+/** hook请求的配置 */
+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: UtilsAjaxHookResponseOptions) => void;
+	/**
+	 * 只读属性。异步请求为true，同步请求为false，异步特性无法作用于同步请求
+	 */
+	async: boolean;
+}
+
+/** 过滤规则配置 */
+declare interface UtilsAjaxHookFilterOptions {
+	/**
+	 * 应是xhr或fetch
+	 */
+	type?: "xhr" | "fetch";
+	/**
+	 * 字符串或正则表达式，无需完全匹配
+	 */
+	url?: string;
+	/**
+	 * 请求方法
+	 */
+	method?: HttpxMethod;
+	/**
+	 * 是否异步
+	 */
+	async?: boolean;
+}
+
+/** Utils.ajaxHooker */
+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;
+}