@whitesev/utils 1.0.5 → 1.0.8

package/src/indexedDB/index.d.ts

@@ -1,128 +0,0 @@
-/** indexedDB */
-declare interface UtilsIndexedDBConstructor {
-	dbName: string;
-	slqVersion: string;
-	dbVersion: number;
-	storeName: string;
-	indexedDB: IDBFactory;
-	db: UtilsNestedObjectWithToString;
-	store: null;
-	errorCode: UtilsNestedObjectWithToString;
-	/**
-	 * 创建 “表”
-	 * @param dbName 表名
-	 */
-	createStore(dbName: string): any;
-	/**
-	 * 打开数据库
-	 * @param callback 回调
-	 * @param dbName 数据库名
-	 */
-	open(
-		callback: (
-			store:
-				| UtilsNestedObjectWithToString
-				| {
-						code: number;
-						msg: string;
-						error: Error;
-				  }
-		) => void,
-		dbName: string
-	): void;
-	/**
-	 * 保存数据到数据库
-	 * @param key 数据key
-	 * @param value 数据值
-	 */
-	save(
-		key: string,
-		value: any
-	): Promise<{
-		code: number;
-		msg: string;
-		success: boolean;
-	}>;
-	/**
-	 * 根据key获取值
-	 * @param key 数据key
-	 */
-	get(key: string): Promise<
-		| {
-				code: number;
-				msg: string;
-				data: any[];
-				success: true;
-		  }
-		| {
-				code: number;
-				msg: string;
-				error: Error;
-				result: any;
-		  }
-	>;
-	/**
-	 * 正则获取数据
-	 * @param key 数据键
-	 */
-	regexpGet(key: string): Promise<
-		| {
-				code: number;
-				msg: string;
-				data: any[];
-				success: true;
-		  }
-		| {
-				code: number;
-				msg: string;
-				error: Error;
-				result: any;
-		  }
-	>;
-	/**
-	 * 删除数据
-	 * @param key 数据键
-	 */
-	delete(key: string): Promise<
-		| {
-				code: number;
-				msg: string;
-				success: true;
-		  }
-		| {
-				code: number;
-				msg: string;
-				error: Error;
-		  }
-	>;
-	/**
-	 * 删除所有数据
-	 */
-	deleteAll(): Promise<
-		| {
-				code: number;
-				msg: string;
-				error: Error;
-				result: any;
-		  }
-		| {
-				code: number;
-				msg: string;
-				success: true;
-		  }
-	>;
-}
-
-/** indexedDB */
-declare interface UtilsIndexedDB {
-	/**
-	 * @param dbName 数据存储名，默认为：default_db
-	 * @param storeName 表名，默认为：default_form
-	 * @param dbVersion indexDB的版本号，默认为：1
-	 */
-	new (
-		dbName?: string,
-		storeName?: string,
-		dbVersion?: number
-	): UtilsIndexedDBConstructor;
-}

package/src/indexedDB/indexedDB.js

@@ -1,355 +0,0 @@
-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/index.d.ts

@@ -1,6 +0,0 @@
-/** tryCatch */
-declare interface UtilsTryCatch {
-	run: UtilsTryCatch;
-	config: UtilsTryCatch;
-	error: UtilsTryCatch;
-}

package/src/tryCatch/tryCatch.js

@@ -1,100 +0,0 @@
-/**
- * 
- * @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
-}