utils-lib-js 2.0.6 → 2.0.8

package/README.md

@@ -1,540 +1,691 @@
 # utils-lib-js
 
-#### 介绍
-JavaScript工具函数，封装的一些常用的js函数
+## 介绍
 
-#### 软件架构
-软件架构说明
+JavaScript 工具函数，封装的一些常用的 js 函数
 
-
-#### 安装教程
-
-1.  pnpm i
-2.  pnpm build
-
-#### 使用说明
+## 调试说明
 
 1.  pnpm build（构建）
 2.  pnpm debug（调试源码）
+3.  在 esm，cjs，window 环境下导入该工具库
 
-#### 参与贡献
+## 参与贡献
 
 1.  Fork 本仓库
-2.  新建 Feat_xxx 分支
+2.  Star 仓库
 3.  提交代码
 4.  新建 Pull Request
 
-#### 功能
-接口：
+## 使用说明
 
-export type IKey = string | symbol | number
+### 安装
 
-##### 对象类型
+`npm install utils-lib-js`
+或
+`yarn add utils-lib-js`
+或
+`pnpm install utils-lib-js`
 
-export interface IObject<T> {
-    [key: IKey]: T | IObject<any>
-}
+### 引入
 
-export interface IPromise extends IObject<any> {
-    promise: Promise<void>
-    resolve: (res: any) => unknown
-    reject: (err: any) => unknown
-}
+#### ESM
+
+```javascript
+import { defer, messageCenter, TaskQueue, Request } from "utils-lib-js";
+```
+
+#### CJS
+
+```javascript
+const { defer, messageCenter, TaskQueue } = require("utils-lib-js");
+```
+
+#### 浏览器中
+
+```html
+<script src="./node_modules/utils-lib-js/dist/umd/index.js"></script>
+<script>
+  console.log(UtilsLib);
+</script>
+```
+
+### TS 接口注释
+
+参照 https://gitee.com/DieHunter/utils-lib-js/blob/master/src/types.ts
+
+### 代码演示
+
+#### base 模块
 
-export type IInstance<T> = {
-    _instance: Function
-} & T
+##### 1. `randomNum(min: number, max: number, bool?: boolean): number`
 
-export type IDemoteArray<T> = Array<IDemoteArray<T> | T>
+生成指定范围内的随机整数。
 
-##### base
+- `min`: 最小值（包含）。
+- `max`: 最大值（包含）。
+- `bool`: 是否包含最大值，默认为 `false`。
 
-/**产生区间随机数
-* @param {number} min  最小区间
-* @param {number} max  最大区间
-* @param {boolean} bool  包含最大值
-* @return {number} 随机数
-**/
+```javascript
+const randomNumber = randomNum(1, 10);
+console.log(randomNumber); // 生成一个介于 1 到 10 之间的随机整数
+```
 
-export type IRandomNum = (min: number, max: number, bool?: boolean) => number
+##### 2. `urlSplit(url: string): object`
 
-/**获取url的参数
-* @param {string} url  待截取的地址
-* @return {object} 参数对象
-**/
+将 URL 查询参数解析为对象。
 
-export type IUrlSplit = (url: string) => IObject<any>
+- `url`: 包含查询参数的 URL。
 
-/**添加url的参数
-* @param {string} url  待添加参数的地址
-* @param {object} query  待添加的参数
-* @return {string} 添加参数后的url
-**/
+```javascript
+const url = "https://example.com/path?param1=value1&param2=value2";
+const params = urlSplit(url);
+console.log(params);
+// 输出: { param1: 'value1', param2: 'value2' }
+```
 
-export type IUrlJoin = (url: string, query: object) => string
+##### 3. `urlJoin(url: string, query: object): string`
 
-/**获取数据类型
-* @param {any} data  待检测数据
-* @return {string} 数据类型
-**/
+将对象转换为 URL 查询参数，并与原始 URL 连接。
 
-export type IGetType<T> = (data: any) => typeof data | T[keyof T] | "null";
+- `url`: 原始 URL。
+- `query`: 包含查询参数的对象。
 
-/**批量判断数据类型
-* @param {any} data  待检测数据
-* @param {any} whiteList  数据类型名单
-* @return {boolean} 是否在白名单中
-**/
+```javascript
+const url = "https://example.com/path";
+const query = { param1: "value1", param2: "value2" };
+const newUrl = urlJoin(url, query);
+console.log(newUrl);
+// 输出: https://example.com/path?param1=value1&param2=value2
+```
 
-export type IGetTypeByList = (data: any, whiteList: string[]) => boolean;
+##### 4. `getType(data: any): string`
 
+获取数据的类型。
 
-##### object
+- `data`: 要检查的数据。
 
-/**lodash中的 _.get()，获取对象某级属性
-* @param {IObject} object  目标对象
-* @param {string} key  对象层级
-* @param {any} defaultValue  未取得时默认值
-* @return {IObject[IKey]} 对象某个属性
-**/
+```javascript
+const dataType = getType("Hello, World!");
+console.log(dataType); // 输出: string
+```
 
-export type IGetValue = <T, U = IObject<T> | IObject<T>[IKey]>(object: U, key: string, defaultValue?: any) => U
+##### 5. `getTypeByList(data: any, whiteList: string[]): boolean`
 
-/**lodash中的 _.set()，赋值对象某级属性
-* @param {IObject} object  目标对象
-* @param {string} key  对象层级
-* @param {any} value  需要赋的值
-* @return {IObject} 目标对象
-**/
+检查数据类型是否在白名单内。
 
-export type ISetValue = <T>(object: IObject<T>, key: string, value?: any) => IObject<T>
+- `data`: 要检查的数据。
+- `whiteList`: 允许的数据类型列表。
 
-/**对象混入
-* @param {IObject} target  目标对象
-* @param {string} source  需要混入的对象集合
-* @param {boolean} overwrite  是否重写覆盖原有属性
-* @return {IObject} 目标对象
-**/
+```javascript
+const data = 42;
+const allowedTypes = ["number", "string"];
+const isTypeAllowed = getTypeByList(data, allowedTypes);
+console.log(isTypeAllowed); // 输出: true
+```
 
-export type IMixIn = <U extends IObject<any>>(target?: U, source?: IObject<any>, overwrite?: boolean) => U
+#### object 模块
 
-/**枚举值反向映射
-* @param {IObject<string>} target  目标对象
-* @return {IObject<string>} 目标对象
-**/
+##### 1. `getValue(object: object, key: string, defaultValue: any = ''): any`
 
-export type IEnumInversion = (target: IObject<string>) => IObject<string>
+获取对象中指定路径的值。
 
-/**对象复制
-* @param {IObject<any>} target  目标对象
-* @return {IObject} 目标对象
-**/
+- `object`: 目标对象。
+- `key`: 要获取的值的路径。
+- `defaultValue`: 默认值，当路径不存在时返回。
 
-export type ICloneDeep = (target?: any) => any
+```javascript
+const obj = { a: { b: { c: 42 } } };
+const value = getValue(obj, "a.b.c", "default");
+console.log(value); // 输出: 42
+```
 
-/**生成 对象 类型的初始值
-* @param {string} type  数据类型
-* @param {any} __init  初始值
-* @return {any} 目标对象
-**/
+##### 2. `setValue(object: object, key: string, value: any = {}): object`
 
-export type ICreateObjectVariable = (type: string, source?: any) => any
+设置对象中指定路径的值。
 
-/**Object.create 根据源对象产出新对象
-* @param {Function|Object} source  源对象
-* @return {Function|Object} 对象产物
-**/
+- `object`: 目标对象。
+- `key`: 要设置的值的路径。
+- `value`: 要设置的值。
 
-export type ICreateObject = <T, U extends T>(source: T) => U
+```javascript
+const obj = { a: { b: { c: 42 } } };
+setValue(obj, "a.b.d", "new value");
+console.log(obj); // 输出: { a: { b: { c: 42, d: 'new value' } } }
+```
 
-/**类的继承
-* @param {Function} source  源对象
-* @return {Function} 继承产物
-**/
+##### 3. `mixIn(target: object, source: object = {}, overwrite: boolean = false): object`
 
-export type IInherit = <T extends Function>(source: T, target?: Function) => Function
+将源对象的属性混入目标对象中。
 
-/**生成类的实例单例
-* @param {Function} classProto  类
-* @param {Boolean} overwrite  是否覆盖已有单例
-* @param {any[]} params  构造函数的参数
-* @return {IObject} 实例化的单例
-**/
+- `target`: 目标对象。
+- `source`: 源对象。
+- `overwrite`: 是否覆盖已存在的属性，默认为 `false`。
 
-export type IGetInstance = (classProto: IInstance<FunctionConstructor>, overwrite?: boolean, ...params: any[]) => Function
+```javascript
+const target = { a: 1 };
+const source = { b: 2 };
+const result = mixIn(target, source);
+console.log(result); // 输出: { a: 1, b: 2 }
+```
 
-/**通过装饰器将属性混入类中
-* @param {IObject<any>} params  混入的属性
-* @return {ClassDecorator} 装饰器钩子函数
-**/
+##### 4. `enumInversion(target: object): object`
 
-export type IClassDecorator = (params: IObject<any>) => <TFunction extends Function>(target: TFunction) => void
+反转枚举对象的键值对。
 
-/**JSON.parse封装
-* @param {string} target  字符串
-* @return {IObject<any>} 对象
-**/
+- `target`: 要反转的枚举对象。
 
-export type IStringToJson = (target: string) => IObject<any>
+```javascript
+const enumObj = { key1: "value1", key2: "value2" };
+const invertedEnum = enumInversion(enumObj);
+console.log(invertedEnum); // 输出: { value1: 'key1', value2: 'key2' }
+```
 
-/**JSON.stringify封装
-* @param {IObject<any>} target  对象
-* @return {string} 字符串
-**/
+##### 5. `isNotObject(source: any, type: string): boolean`
 
-export type IJsonToString = (target: IObject<any>) => string
+检查值是否为非对象类型。
 
-##### function
+- `source`: 要检查的值。
+- `type`: 数据类型。
 
-/**节流(throttle):高频事件触发，但在 n 秒内只会执行一次
-* @param {Function} fn  节流处理的函数
-* @param {number} time  执行间隔/毫秒
-* @return {Function} 处理后的函数
-**/
+```javascript
+const result = isNotObject(42, "number");
+console.log(result); // 输出: false
+```
 
-export type IThrottle = (fn: Function, time: number) => (...args: any[]) => void
+##### 6. `cloneDeep(target: any): any`
 
-/**防抖(debounce):触发高频事件后 n 秒内函数只会执行一次
-* @param {Function} fn  防抖处理的函数
-* @param {number} time  允许运行函数间隔/毫秒
-* @return {Function} 处理后的函数
-**/
+深度克隆对象。
 
-export type IDebounce = (fn: Function, time: number) => (...args: any[]) => void
+- `target`: 要克隆的对象。
 
-/**
- * Promise扁平化，避免Promise嵌套
- * @param {number} timer  超时
- * @returns {Promise,resolve,reject} 
- */
-export type IDefer = (timer: number) => IPromise
+```javascript
+const obj = { a: { b: { c: 42 } } };
+const clonedObj = cloneDeep(obj);
+console.log(clonedObj); // 输出: { a: { b: { c: 42 } } }
+```
 
-/**await与try catch 捕获异常处理方法
- * @param {Promise<any>} defer  延迟函数
- * @returns {Promise<any>} [error, result]
- */
+##### 7. `createObjectVariable(type: string, source: object = {}): object`
 
-export type ICatchAwait<T extends Promise<any>> = (defer: T) => T
+根据类型创建特定类型的对象。
 
-##### array
+- `type`: 要创建的对象类型。
+- `source`: 初始化对象的数据。
 
-/**数组乱序
- * @param {Array<any>} arr  目标数组
- * @returns {Array<any>} 乱序后的数组
- */
- 
-export type IArrayRandom<T extends any[]> = (arr: T) => T
+```javascript
+const array = createObjectVariable("array", [1, 2, 3]);
+console.log(array); // 输出: [1, 2, 3]
+```
 
-/**数组数组去重
- * @param {Array<any>} arr  目标数组
- * @returns {Array<any>} 去重后的数组
- */
+##### 8. `createObject(source: object): object`
 
-export type IArrayUniq<T extends any[]> = (arr: T) => T
+使用原型链创建对象。
 
-/**数组扁平化
- * @param {Array<any>} arr  目标数组
- * @returns {Array<any>} 扁平化的数组
- */
+- `source`: 原型对象。
 
-export type IArrayDemote<T extends IDemoteArray<any>> = (arr: T, result?: T) => T
+```javascript
+const protoObj = { a: 1 };
+const newObj = createObject(protoObj);
+console.log(newObj.a); // 输出: 1
+```
 
-##### element
+##### 9. `inherit(source: object, target: function): function`
 
-/**IElementParams
- * @param {string} ele 标签类型
- * @param {CSSStyleDeclaration} style 样式
- * @param {Attr} attr 属性
- * @param {object} parent 父元素
- */
+继承原型链。
 
-interface IElementParams<T> {
-    ele: T | string
-    style: CSSStyleDeclaration
-    attr: Attr
-    parent: T
+- `source`: 父对象的原型链。
+- `target`: 子对象的构造函数。
+
+```javascript
+function Parent() {}
+Parent.prototype.method = function () {
+  console.log("Hello from parent");
+};
+
+function Child() {}
+inherit(Parent, Child);
+const childInstance = new Child();
+childInstance.method(); // 输出: Hello from parent
+```
+
+##### 10. `getInstance(classProto: function, overwrite: boolean = false, ...params: any[]): object`
+
+获取类的单例实例。
+
+- `classProto`: 类的原型链。
+- `overwrite`: 是否覆盖已存在的实例，默认为 `false`。
+- `params`: 类构造函数的参数。
+
+```javascript
+class Singleton {
+  constructor(name) {
+    this.name = name;
+  }
 }
 
-/**新增标签，设置属性及样式
- * @param {IElementParams} params 配置
- * @return {ElementObject} 生成的标签
- */
+const instance1 = getInstance(Singleton, false, "Instance 1");
+const instance2 = getInstance(Singleton, true, "Instance 2");
 
-export type ICreateElement<T = HTMLElement> = (params: IElementParams<T>) => T
+console.log(instance1 === instance2); // 输出: false
+```
 
-##### event
+##### 11. `classDecorator(params: object): ClassDecorator`
 
-/**浏览器事件
- * @param {Document} ele 标签
- * @param {string} type 事件类型
- * @param {(e: Event) => void} handler 事件回调
- * @return {void}
- */
+为类添加装饰器。
 
-export type IAddHandler = <T extends Document>(ele: T, type: string, handler: (e: Event) => void) => void
+- `params`: 要添加的属性和方法。
 
-/**取消事件冒泡
- * @param {Event} e 浏览器事件对象
- * @return {void}
- */
+```javascript
+@classDecorator({
+  additionalMethod: function () {
+    console.log("Additional method");
+  },
+})
+class DecoratedClass {}
 
-export type IStopBubble = (e: Event) => void
+const instance = new DecoratedClass();
+instance.additionalMethod(); // 输出: Additional method
+```
 
-/**取消默认事件
- * @param {Event} e 浏览器事件对象
- * @return {void}
- */
+##### 12. `stringToJson(target: string): object | null`
 
-export type IStopDefault = (e: Event) => void
+将 JSON 字符串转换为对象。
 
-/**取消浏览器事件
- * @param {Document} ele 标签
- * @param {string} type 事件类型
- * @param {(e: Event) => void} handler 事件回调
- * @return {void}
- */
+- `target`: 要转换的 JSON 字符串。
 
-export type IRemoveHandler = <T extends Document>(ele: T, type: string, handler: (e: Event) => void) => void
+```javascript
+const jsonString = '{"key": "value"}';
+const jsonObject = stringToJson(jsonString);
+console.log(jsonObject); // 输出: { key: 'value' }
+```
 
-/**取消默认事件
- * @param {Event} e 浏览器事件对象
- * @return {void}
- */
+##### 13. `jsonToString(target: any): string`
 
-export type IDispatchEvent = <T extends Document>(ele: T, data: any) => void
+将对象转换为 JSON 字符串。
 
+- `target`: 要转换的对象。
 
-##### log
+```javascript
+const obj = { key: "value" };
+const jsonString = jsonToString(obj);
+console.log(jsonString); // 输出: '{"key":"value"}'
+```
 
-/** 单行输出
- * @param {string} str 输出字符
- * @param {boolean} overwrite 覆盖前面的输出
- * @param {boolean} warp 最后一行换行
- * @return {void}
- */
-export type ILogOneLine = (str: string, overwrite?: boolean, warp?: boolean) => void
+##### 14. `isWindow(win: any): boolean`
 
-/** 循环输出某个队列
- * @param {string[]} loopList 输出的字符队列
- * @param {number} index 第几个字符
- * @param {boolean} isStop 控制暂停循环
- * @param {number} timer 两个相隔时间间隔
- */
-export type ILogLoopParams = {
-    loopList?: string[]
-    index?: number
-    isStop?: boolean
-    timer?: number
-}
-export type ILogLoop = (opts?: ILogLoopParams) => ILogLoopParams | void
+检查是否是浏览器窗口。
 
-##### request 模块
-###### https://gitee.com/DieHunter/js-request-lib
-export type IRequestParams<T> = T | IObject<any> | null
+- `win`: 要检查的对象。
 
-// 请求路径
+```javascript
+const isBrowserWindow = isWindow(window);
+console.log(isBrowserWindow); // 输出: true
+```
 
-export type IUrl = string
+#### array 模块
 
-// 环境判断
+##### 1. `arrayRandom(arr: any[]): any[]`
 
-export type IEnv = 'Window' | 'Node'
+对数组进行随机排序。
 
-// fetch返回取值方式
+- `arr`: 要排序的数组。
 
-export type IDataType = "text" | "json" | "blob" | "formData" | "arrayBuffer"
+```javascript
+const originalArray = [1, 2, 3, 4, 5];
+const randomizedArray = arrayRandom(originalArray);
+console.log(randomizedArray);
+// 输出: 一个随机排序的数组
+```
 
-// 请求方式
+##### 2. `arrayUniq(arr: any[]): any[]`
 
-export type IRequestMethods = "GET" | "POST" | "DELETE" | "PUT" | "OPTION"
+从数组中移除重复的元素。
 
-// body结构
+- `arr`: 要处理的数组。
 
-export type IRequestBody = IRequestParams<BodyInit>
+```javascript
+const arrayWithDuplicates = [1, 2, 2, 3, 4, 4, 5];
+const uniqueArray = arrayUniq(arrayWithDuplicates);
+console.log(uniqueArray);
+// 输出: 移除重复元素后的数组
+```
 
-// heads结构
+##### 3. `arrayDemote(arr: IDemoteArray<any>, result: any[] = []): any[]`
 
-export type IRequestHeaders = IRequestParams<HeadersInit>
+将多层嵌套的数组降维。
 
-// 请求基础函数
+- `arr`: 要降维的数组。
+- `result`: 用于存储结果的数组，默认为空数组。
 
-export type IRequestBaseFn = (url: IUrl, opts: IRequestOptions) => Promise<any>
+```javascript
+const nestedArray = [1, [2, [3, [4]], 5]];
+const demotedArray = arrayDemote(nestedArray);
+console.log(demotedArray);
+// 输出: 降维后的数组 [1, 2, 3, 4, 5]
+```
 
-// 请求函数体
+#### function 模块
 
-export type IRequestFn = (url?: IUrl, query?: IObject<any>, body?: IRequestBody, opts?: IRequestOptions) => Promise<any>
+##### 1. `throttle(fn: Function, time: number): Function`
 
-// 请求参数
+限制函数在指定时间内的调用频率。
 
-export type IRequestOptions = {
-    method?: IRequestMethods
-    query?: IRequestParams<IObject<any>>
-    body?: IRequestBody
-    headers?: IRequestHeaders
-    controller?: AbortController
-    timeout?: number
-    timer?: number | unknown | null
-    [key: string]: any
-}
+- `fn`: 要执行的函数。
+- `time`: 时间间隔（毫秒）。
 
-// 拦截器
+```javascript
+const throttledFunction = throttle(
+  () => console.log("Throttled function called!"),
+  1000
+);
+throttledFunction(); // 只有在 1 秒后才会执行
+```
 
-export type IInterceptors = {
-    use(type: "request" | "response" | "error", fn: Function): void
-    get reqFn(): Function
-    get resFn(): Function
-    get errFn(): Function
-}
+##### 2. `debounce(fn: Function, time: number): Function`
 
-// 公共函数
-
-export type IRequestBase = {
-    readonly origin: string
-    chackUrl: (url: IUrl) => boolean
-    envDesc: () => IEnv
-    errorFn: <Err = any, R = Function>(reject: R) => (err: Err) => R
-    clearTimer: (opts: IRequestOptions) => void
-    initAbort: <T = IRequestOptions>(opts: T) => T
-    requestType: () => IRequestBaseFn
-    fixOrigin: (fixStr: string) => string
-    fetch: IRequestBaseFn
-    http: IRequestBaseFn
-    getDataByType: (type: IDataType, response: Response) => Promise<any>
-}
+限制函数在指定时间内的连续调用。
 
-// 初始化参数
+- `fn`: 要执行的函数。
+- `time`: 时间间隔（毫秒）。
 
-export type IRequestInit = {
-    initDefaultParams: (url: IUrl, opts: IRequestOptions) => any
-    initFetchParams: (url: IUrl, opts: IRequestOptions) => any
-    initHttpParams: (url: IUrl, opts: IRequestOptions) => any
-}
+```javascript
+const debouncedFunction = debounce(
+  () => console.log("Debounced function called!"),
+  1000
+);
+debouncedFunction(); // 在 1 秒内多次调用，只有最后一次会执行
+```
 
-// 请求主体类
+##### 3. `defer(timer: number = 0): { promise: Promise<void>, resolve: Function, reject: Function }`
 
-export type IRequest = {
-    GET: IRequestFn
-    POST: IRequestFn
-    DELETE: IRequestFn
-    PUT: IRequestFn
-    OPTIONS: IRequestFn
-    HEAD: IRequestFn
-    PATCH: IRequestFn
-} & IRequestBase
+创建一个扁平化的 Promise 延迟对象，可以设置在一定时间后超时。
 
+- `timer`: 超时时间（毫秒），默认为 0。
 
-<!-- 消息中心 -->
-##### 消息中心
-###### https://gitee.com/DieHunter/message-center
-export declare interface Handlers {
-    [key: string]: Array<Function>
-}
-export declare interface IMessageCenter {
-    events: Handlers
-    _instance?: IMessageCenter
-    on: (type: string, handler: Function) => this
-    emit: (type: string, data?: any) => this
-    un: (type: string, handler?: Function) => this
-    once: (type: string, handler: Function) => this
-    clear: () => this
-    has: (type: string) => boolean
-    handlerLength: (type: string) => number
-    watch: (type: string, handler: Function) => this
-    invoke: (type: string, data?: any) => Promise<void>
-}
+```javascript
+const deferFn = () => {
+  const { resolve, promise } = defer();
+  setTimeout(() => resolve("success"), 500);
+  return promise;
+};
+const delayFn = () => {
+  const { promise } = defer(1000);
+  return promise;
+};
+deferFn().then(console.log); // 延迟输出
+delayFn().catch(console.error); // 超时输出
+```
 
+##### 4. `catchAwait(defer: Promise<any>): Promise<[Error | null, any]>`
 
+捕获异步操作的错误并返回 `[Error, null]` 或 `[null, result]`。
 
-<!-- 任务队列 -->
-##### 任务队列
-###### https://gitee.com/DieHunter/task-queue
-/**
- * 单条队列
- * defer: 待运行的异步函数
- * params?: defer的参数，也可以用bind直接传递
- * 
- */
-export interface IQueue {
-    defer: Function
-    name?: string
-}
-/**
- * 队列参数
- * children: 队列列表
- * name: 队列唯一标识
- * result: 运行完成后的结果
- * 
- */
-export interface IQueues {
-    children: Array<Function>
-    name: string
-    result?: any[]
-}
-/**
- * 队列缓存
- */
-export type IQueueTemp = {
-    [key: string]: IQueues
-}
-/**
- * 系统队列
- */
-export type IQueueList = Array<IQueue>
-/**
- * 队列状态 idle:空闲 pending:等待 fulfilled:完成 rejected:失败
- */
-export type IState = "idle" | "pending" | "fulfilled" | "rejected"
-/**
- * 任务队列参数
- */
-export type ITaskQueueProps = {
-    maxLen: number
-}
-/**
- * 任务队列
- */
-export type ITaskQueue = {
-    readonly fix: string
-    props: ITaskQueueProps
-    queueTemp: IQueueTemp
-    queues: IQueueList
-    state: IState
-    push: (queue: IQueues) => Promise<void>
-    unshift: (length: number) => IQueueList
-    run: (reject: any) => unknown
-    clear: () => void
-}
+- `defer`: 异步操作的 Promise 对象。
 
+```javascript
+const asyncOperation = new Promise((resolve, reject) => {
+  // 模拟异步操作
+  setTimeout(() => {
+    reject(new Error("Something went wrong!"));
+  }, 1000);
+});
 
+const [error, result] = await catchAwait(asyncOperation);
+console.log(error); // 输出: Error: Something went wrong!
+console.log(result); // 输出: null
+```
 
-/** 单行输出
- * @param {string} str 输出字符
- * @param {boolean} overwrite 覆盖前面的输出
- * @param {boolean} warp 最后一行换行
- * @return {void}
- */
-export function logOneLine(str: string): void
-export function logOneLine(str: string, overwrite?: boolean): void
-export function logOneLine(str: string, overwrite?: boolean, warp?: boolean): void
-
-
-// animate
-
-/**
- * 动画类
- * 参考：https://gitee.com/DieHunter/myCode/tree/master/%E5%89%8D%E7%AB%AF%E5%8A%A8%E7%94%BB/js
- * 
- */
-export type IAnimateFrame = {
-    id: number | null // 动画索引
-    duration: number // 帧数控制
-    isActive: boolean// 激活控制
-    fn(timer: number): void
-    start(duration: number): void
-    stop(): void
-    animate(timer: number): void
-}
-declare var IAnimateFrame: {
-    new(fn: (timer: number) => void): IAnimateFrame
-    prototype: IAnimateFrame
-}
+#### element 模块
+
+##### 1. `createElement(options: { ele?: string | HTMLElement, style?: object, attr?: object, parent?: HTMLElement }): HTMLElement`
+
+创建并返回一个 HTML 元素。
+
+- `ele`: 元素类型或已存在的 HTMLElement 对象，可选，默认为 'div'。
+- `style`: 元素的样式对象，可选。
+- `attr`: 元素的属性对象，可选。
+- `parent`: 元素的父级元素，可选。
+
+```javascript
+const options = {
+  ele: 'div',
+  style: { color: 'blue', fontSize: '16px' },
+  attr: { id: 'myElement', className: 'custom-class' },
+  parent: document.body
+};
+
+const createdElement = createElement(options);
+// 在 body 中创建一个带有样式和属性的 div 元素
+```
+#### event 模块
+
+##### 1. `addHandler(ele: HTMLElement, type: string, handler: EventListener): void`
+
+为元素添加事件监听器。
+
+- `ele`: 目标元素。
+- `type`: 事件类型。
+- `handler`: 事件处理函数。
+
+```javascript
+const button = document.getElementById('myButton');
+const handleClick = () => console.log('Button clicked!');
+addHandler(button, 'click', handleClick);
+```
+
+##### 2. `stopBubble(event: Event): void`
+
+阻止事件冒泡。
+
+- `event`: 事件对象。
+
+```javascript
+const handleClick = (event) => {
+  console.log('Button clicked!');
+  stopBubble(event);
+};
+```
+
+##### 3. `stopDefault(event: Event): void`
+
+阻止事件的默认行为。
+
+- `event`: 事件对象。
+
+```javascript
+const handleFormSubmit = (event) => {
+  console.log('Form submitted!');
+  stopDefault(event);
+};
+```
+
+##### 4. `removeHandler(ele: HTMLElement, type: string, handler: EventListener): void`
+
+移除元素的事件监听器。
+
+- `ele`: 目标元素。
+- `type`: 事件类型。
+- `handler`: 要移除的事件处理函数。
+
+```javascript
+const button = document.getElementById('myButton');
+const handleClick = () => console.log('Button clicked!');
+addHandler(button, 'click', handleClick);
+// 其他操作...
+removeHandler(button, 'click', handleClick);
+```
+
+##### 5. `dispatchEvent(ele: HTMLElement, data: any): void`
+
+触发自定义事件。
+
+- `ele`: 目标元素。
+- `data`: 自定义事件的数据。
+
+```javascript
+const customEvent = new CustomEvent('customEvent', { detail: { key: 'value' } });
+const targetElement = document.getElementById('myElement');
+dispatchEvent(targetElement, customEvent);
+```
+#### storage 模块
+
+##### 1. `setStorage(key: string, val: any): void`
+
+将值存储到本地存储中。
+
+- `key`: 存储的键名。
+- `val`: 要存储的值。
+
+```javascript
+const userData = { username: 'john_doe', email: 'john@example.com' };
+setStorage('user_data', userData);
+```
+
+##### 2. `getStorage(key: string): any`
+
+从本地存储中获取值。
+
+- `key`: 要获取的键名。
+
+```javascript
+const storedUserData = getStorage('user_data');
+console.log(storedUserData);
+// 输出: { username: 'john_doe', email: 'john@example.com' }
+```
+
+##### 3. `clearStorage(key?: string): void`
+
+清除本地存储中的值。
+
+- `key`: 可选，要清除的键名。如果未提供键名，则清除所有存储。
+
+```javascript
+clearStorage('user_data'); // 清除特定键名的存储值
+// 或者
+clearStorage(); // 清除所有本地存储的值
+```
+
+#### log 模块
+
+##### 1. `logOneLine(str: string, overwrite: boolean = false, wrap: boolean = true): void`
+
+在一行中输出日志。
+
+- `str`: 要输出的字符串。
+- `overwrite`: 是否覆盖当前行，默认为 `false`。
+- `wrap`: 是否在输出后换行，默认为 `true`。
+
+```javascript
+logOneLine('This is a single line log message.');
+```
+
+##### 2. `logLoop(opts?: { loopList?: string[], isStop?: boolean, timer?: number, index?: number }): { loopList?: string[], isStop?: boolean, timer?: number, index?: number }`
+
+在控制台中输出循环动画。
+
+- `opts`: 可选参数对象，包含以下属性：
+  - `loopList`: 动画字符列表，默认为 `['\\', '|', '/', '—', '—']`。
+  - `isStop`: 是否停止循环，默认为 `false`。
+  - `timer`: 动画切换的时间间隔（毫秒），默认为 `100`。
+  - `index`: 当前动画字符的索引，默认为 `0`。
+
+```javascript
+logLoop(); // 启动默认循环动画
+// 或者
+logLoop({ loopList: ['-', '+', '-', '+'], timer: 200 }); // 启动自定义循环动画
+```
+#### animation 模块
+
+##### 1. `class AnimateFrame`
+
+提供帧动画的类。
+
+- `start(duration?: number): void`: 启动帧动画，可选参数 `duration` 为帧数控制。
+- `stop(): void`: 停止帧动画。
+
+```javascript
+const animateFrame = new AnimateFrame((timestamp) => {
+  // 在此处更新动画状态
+  console.log('AnimationFrame callback:', timestamp);
+});
+
+animateFrame.start(60); // 启动帧动画，每秒 60 帧
+// 其他操作...
+animateFrame.stop(); // 停止帧动画
+```
+
+##### 2. `quadraticBezier(_x: number, _y: number, t: number): [number, number]`
+
+计算二次贝塞尔曲线上的点坐标。
+
+- `_x`: 控制点1 x 坐标。
+- `_y`: 控制点1 y 坐标。
+- `t`: 时间参数，取值范围 [0, 1]。
+
+```javascript
+const result = quadraticBezier(0, 0, 1, 1, 0.5);
+console.log(result);
+// 输出: [0.75, 0.75]
+```
+
+##### 3. `cubicBezier(_x1: number, _y1: number, _x2: number, _y2: number, t: number): [number, number]`
+
+计算三次贝塞尔曲线上的点坐标。
+
+- `_x1`: 控制点1 x 坐标。
+- `_y1`: 控制点1 y 坐标。
+- `_x2`: 控制点2 x 坐标。
+- `_y2`: 控制点2 y 坐标。
+- `t`: 时间参数，取值范围 [0, 1]。
+
+```javascript
+const result = cubicBezier(0, 0, 0.5, 1, 0.5);
+console.log(result);
+// 输出: [0.375, 0.625]
+```
+
+##### 4. `factorial(n: number): number`
+
+计算阶乘。
+
+- `n`: 非负整数。
+
+```javascript
+const result = factorial(5);
+console.log(result);
+// 输出: 120
+```
+
+##### 5. `combination(n: number, k: number): number`
+
+计算组合数。
+
+- `n`: 总数。
+- `k`: 选择的个数。
+
+```javascript
+const result = combination(5, 2);
+console.log(result);
+// 输出: 10
+```
+
+##### 6. `NBezier(points: number[][], t: number): [number, number]`
+
+计算 N 次贝塞尔曲线上的点坐标。
+
+- `points`: 控制点数组，每个点是一个二阶数组。
+- `t`: 时间参数，取值范围 [0, 1]。
+
+```javascript
+const points = [[0, 0], [1, 1], [2, 0]];
+const result = NBezier(points, 0.5);
+console.log(result);
+// 输出: [1.5, 0.75]
+```
+
+#### event-message-center
+https://gitee.com/DieHunter/message-center
+#### task-queue-lib
+https://gitee.com/DieHunter/task-queue
+#### js-request-lib
+https://gitee.com/DieHunter/js-request-lib