utils-lib-js 2.0.6 → 2.0.8

package/README.en.md

@@ -1,540 +1,705 @@
 # utils-lib-js
 
-#### Introduction
-JavaScript utility functions, packaging some commonly used js functions
-
-#### Software Architecture
-Software architecture specification
-
-
-#### installation tutorial
+## Introduction
 
-1.  pnpm i
-2.  pnpm build
+JavaScript utility functions, packaging some commonly used js functions
 
-#### Usage instructions
+## Debugging instructions
 
 1. pnpm build
 2. pnpm debug (debug source)
+3. Import the tool library in esm, cjs, and window environments
 
-#### Contribute
+## Contribute
 
 1. Fork the local warehouse
-2. Create a branch of Feat_xxx
+2. Star Warehouse
 3. Submit the code
 4. Create a Pull Request
 
-#### function
-Interface:
+## Instructions for use
 
-export type IKey = string | symbol | number
+### Install
 
-##### Object type
+`npm install utils-lib-js`
+or
+`yarn add utils-lib-js`
+or
+`pnpm install utils-lib-js`
 
-export interface IObject<T> {
-[key: IKey]: T | IObject<any>
-}
+### Introduce
 
-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");
+```
+
+#### in your browser
+
+```html
+<script src="./node_modules/utils-lib-js/dist/umd/index.js"></script>
+<script>
+  console.log(UtilsLib);
+</script>
+```
+
+### TS interface comment
+
+With reference to https://gitee.com/DieHunter/utils-lib-js/blob/master/src/types.ts
+
+### Code demo
 
-export type IInstance<T> = {
-_instance: Function
-} & T
+#### base module
 
-export type IDemoteArray<T> = Array<IDemoteArray<T> | T>
+##### 1. `randomNum(min: number, max: number, bool? : boolean): number`
 
-##### base
+Generates random integers within the specified range.
 
-/** Generates interval random numbers
-* @param {number} min Minimum interval
-* @param {number} max Maximum range
-* @param {boolean} bool Contains the maximum value
-* @return {number} A random number
-* * /
+- 'min' : indicates the minimum value (including).
+- 'max' : indicates the maximum value (inclusive).
+- 'bool' : Indicates whether the maximum value is contained. The default value is false.
 
-export type IRandomNum = (min: number, max: number, bool? : boolean) => number
+```javascript
+const randomNumber = randomNum(1, 10);
+console.log(randomNumber); // Generates a random integer between 1 and 10
+```
 
-/** Gets the parameters of the url
-* @param {string} url Indicates the address to be intercepted
-* @return {object} Parameter object
-* * /
+##### 2. `urlSplit(url: string): object`
 
-export type IUrlSplit = (url: string) => IObject<any>
+Parses URL query parameters into objects.
 
-/** Adds parameters for the url
-* @param {string} url Address to which the parameter is to be added
-* @param {object} query Specifies the parameter to be added
-* @return {string} The url after the parameter is added
-* * /
+- 'url' : indicates the URL containing the query parameter.
 
-export type IUrlJoin = (url: string, query: object) => string
+```javascript
+const url = "https://example.com/path?param1=value1&param2=value2";
+const params = urlSplit(url);
+console.log(params);
+// Output: {param1: 'value1', param2: 'value2'}
+```
 
-/** Gets the data type
-* @param {any} data Indicates the data to be detected
-* @return {string} Data type
-* * /
+##### 3. `urlJoin(url: string, query: object): string`
 
-export type IGetType<T> = (data: any) => typeof data | T[keyof T] | "null";
+Converts the object to a URL query parameter and concatenates it with the original URL.
 
-/** Determine the data type in batches
-* @param {any} data Indicates the data to be detected
-* @param {any} whiteList Indicates a list of data types
-* @return {boolean} Whether it is in the whitelist
-* * /
+- 'url' : indicates the original URL.
+- 'query' : object containing query parameters.
 
-export type IGetTypeByList = (data: any, whiteList: string[]) => boolean;
+```javascript
+const url = "https://example.com/path";
+const query = { param1: "value1", param2: "value2" };
+const newUrl = urlJoin(url, query);
+console.log(newUrl);
+// Output: https://example.com/path?param1=value1&param2=value2
+```
 
+##### 4. `getType(data: any): string`
 
-##### object
+Get the type of data.
 
-/**lodash _.get() to get a certain level attribute of the object
-* @param {IObject} object Indicates the target object
-* @param {string} key object hierarchy
-* @param {any} defaultValue Default value if not obtained
-* @return {IObject[IKey]} A property of an object
-* * /
+- 'data' : indicates the data to be checked.
 
-export type IGetValue = <T, U = IObject<T> | IObject<T>[IKey]>(object: U, key: string, defaultValue? : any) => U
+```javascript
+const dataType = getType("Hello, World!");
+console.log(dataType); // Output: string
+```
 
-/**lodash _.set(), which assigns a level attribute to the object
-* @param {IObject} object Indicates the target object
-* @param {string} key object hierarchy
-* @param {any} value Specifies the value to be assigned
-* @return {IObject} Target object
-* * /
+##### 5. `getTypeByList(data: any, whiteList: string[]): boolean`
 
-export type ISetValue = <T>(object: IObject<T>, key: string, value? : any) => IObject<T>
+Check whether the data type is in the whitelist.
 
-/** Object mixed in
-* @param {IObject} target Indicates the target object
-* @param {string} source Set of objects to be mixed in
-* @param {boolean} overwrite Whether to overwrite the original attribute
-* @return {IObject} Target object
-* * /
+- 'data' : indicates the data to be checked.
+- 'whiteList' : indicates the list of allowed data types.
 
-export type IMixIn = <U extends IObject<any>>(target? : U, source? : IObject<any>, overwrite? : boolean) => U
+```javascript
+const data = 42;
+const allowedTypes = ["number", "string"];
+const isTypeAllowed = getTypeByList(data, allowedTypes);
+console.log(isTypeAllowed); // Output: true
+```
 
-/** Enumeration value reverse mapping
-* @param {IObject<string>} target Indicates the target object
-* @return {IObject<string>} Target object
-* * /
+#### object module
 
-export type IEnumInversion = (target: IObject<string>) => IObject<string>
+##### 1. `getValue(object: object, key: string, defaultValue: any = ''): any`
 
-/** Object replication
-* @param {IObject<any>} target Indicates the target object
-* @return {IObject} Target object
-* * /
+Gets the value of the specified path in the object.
 
-export type ICloneDeep = (target? : any) => any
+- 'object' : indicates the target object.
+- 'key' : the path to the value to be obtained.
+- 'defaultValue' : Default value, returned if the path does not exist.
 
-/** Generates the initial value of the object type
-* @param {string} type Indicates the data type
-* @param {any} __init Initial value
-* @return {any} Target object
-* * /
+```javascript
+const obj = { a: { b: { c: 42 } } };
+const value = getValue(obj, "a.b.c", "default");
+console.log(value); // Output: 42
+```
 
-export type ICreateObjectVariable = (type: string, source? : any) => any
+##### 2. `setValue(object: object, key: string, value: any = {}): object`
 
-/** object. create generates a new Object based on the source object
-* @param {Function|Object} source Source object
-* @return {Function|Object} Object product
-* * /
+Sets the value of the specified path in the object.
 
-export type ICreateObject = <T, U extends T>(source: T) => U
+- 'object' : indicates the target object.
+- 'key' : path to the value to be set.
+- 'value' : indicates the value to be set.
 
-Inheritance of the /** class
-* @param {Function} source Source object
-* @return {Function} inheritance product
-* * /
+```javascript
+const obj = { a: { b: { c: 42 } } };
+setValue(obj, "a.b.d", "new value");
+console.log(obj); // Output: {a: {b: {c: 42, d: 'new value'}}}
+```
 
-export type IInherit = <T extends Function>(source: T, target? : Function) => Function
+##### 3. `mixIn(target: object, source: object = {}, overwrite: boolean = false): object`
 
-/** Generates an instance singleton of the class
-* @param {Function} classProto class
-* @param {Boolean} overwrite Whether to overwrite an existing singleton
-* @param {any[]} Parameter of the params constructor
-* @return {IObject} instantiated singleton
-* * /
+Mixes the properties of the source object into the target object.
 
-export type IGetInstance = (classProto: IInstance<FunctionConstructor>, overwrite? : boolean, ... params: any[]) => Function
+- 'target' : indicates the target object.
+- 'source' : indicates the source object.
+- 'overwrite' : Whether to overwrite an existing attribute. The default is' false '.
 
-/** Mixes attributes into classes via decorators
-* @param {IObject<any>} params mixed property
-* @return {ClassDecorator} Decorator hook function
-* * /
+```javascript
+const target = { a: 1 };
+const source = { b: 2 };
+const result = mixIn(target, source);
+console.log(result); // Output: {a: 1, b: 2}
+```
 
-export type IClassDecorator = (params: IObject<any>) => <TFunction extends Function>(target: TFunction) => void
+##### 4. `enumInversion(target: object): object`
 
-/**JSON.parse package
-* @param {string} target string
-* @return {IObject<any>} object
-* * /
+Inverts the key-value pair of an enumeration object.
 
-export type IStringToJson = (target: string) => IObject<any>
+- 'target' : enumeration object to be reversed.
 
-/**JSON.stringify encapsulation
-* @param {IObject<any>} target object
-* @return {string} A string
-* * /
+```javascript
+const enumObj = { key1: "value1", key2: "value2" };
+const invertedEnum = enumInversion(enumObj);
+console.log(invertedEnum); // Output: {value1: 'key1', value2: 'key2'}
+```
 
-export type IJsonToString = (target: IObject<any>) => string
+##### 5. `isNotObject(source: any, type: string): boolean`
 
-##### function
+Check whether the value is of a non-object type.
 
-/** throttle: A high-frequency event is triggered, but only once in n seconds
-* @param {Function} fn Function for throttling
-* @param {number} time Execution interval/ms
-* @return {Function} Function after processing
-* * /
+- 'source' : indicates the value to be checked.
+- 'type' : indicates the data type.
 
-export type IThrottle = (fn: Function, time: number) => (... args: any[]) => void
+```javascript
+const result = isNotObject(42, "number");
+console.log(result); // Output: false
+```
 
-/** debounce: The function executes only once within n seconds after a high-frequency event is triggered
-* @param {Function} fn Function for anti-shake processing
-* @param {number} time Allows running function intervals/milliseconds
-* @return {Function} Function after processing
-* * /
+##### 6. `cloneDeep(target: any): any`
 
-export type IDebounce = (fn: Function, time: number) => (... args: any[]) => void
+Deep clone object.
 
-/ * *
-* Promise flattening to avoid Promise nesting
-* @param {number} timer times out
-* @returns {Promise,resolve,reject}
-* /
-export type IDefer = (timer: number) => IPromise
+- 'target' : indicates the object to be cloned.
 
-/**await and try catch catch exception handling methods
-* @param {Promise<any>} defer the delay function
-* @returns {Promise<any>} [error, result]
-* /
+```javascript
+const obj = { a: { b: { c: 42 } } };
+const clonedObj = cloneDeep(obj);
+console.log(clonedObj); // Output: {a: {b: {c: 42}}}
+```
 
-export type ICatchAwait<T extends Promise<any>> = (defer: T) => T
+##### 7. `createObjectVariable(type: string, source: object = {}): object`
 
-##### array
+Creates an object of a specific type based on its type.
 
-/** The array is out of order
-* @param {Array<any>} arr target array
-* @returns {Array<any>} The array is out of order
-* /
+- 'type' : indicates the type of the object to be created.
+- 'source' : initializes the data of the object.
 
-export type IArrayRandom<T extends any[]> = (arr: T) => T
+```javascript
+const array = createObjectVariable("array", [1, 2, 3]);
+console.log(array); // Output: [1, 2, 3]
+```
 
-/** array array weight removal
-* @param {Array<any>} arr target array
-* @returns {Array<any>} Specifies the array after deduplication
-* /
+##### 8. `createObject(source: object): object`
 
-export type IArrayUniq<T extends any[]> = (arr: T) => T
+Create objects using a prototype chain.
 
-/** Array flattens
-* @param {Array<any>} arr target array
-* @returns {Array<any>} A flat array
-* /
+- 'source' : prototype object.
 
+```javascript
+const protoObj = { a: 1 };
+const newObj = createObject(protoObj);
+console.log(newObj.a); // Output: 1
+```
 
-export type IArrayDemote<T extends IDemoteArray<any>> = (arr: T, result? : T) => T
+##### 9. `inherit(source: object, target: function): function`
 
-##### element
+Inherit the prototype chain.
 
-/**IElementParams
-* @param {string} ele Label type
-* @param {CSSStyleDeclaration} style
-* @param {Attr} attr attribute
-* @param {object} parent Parent element
-* /
+- 'source' : prototype chain of the parent object.
+- 'target' : constructor of the child object.
 
-interface IElementParams<T> {
-ele: T | string
-style: CSSStyleDeclaration
-attr: Attr
-parent: T
+```javascript
+function Parent() {}
+Parent.prototype.method = function () {
+  console.log("Hello from parent");
+};
+
+function Child() {}
+inherit(Parent, Child);
+const childInstance = new Child();
+childInstance.method(); // Output: Hello from parent
+```
+
+##### 10. `getInstance(classProto: function, overwrite: boolean = false, ... params: any[]): object`
+
+Gets a singleton instance of a class.
+
+- 'classProto' : The prototype chain of the class.
+- 'overwrite' : Whether to overwrite an existing instance. The default is' false '.
+- 'params' : arguments to the class constructor.
+
+```javascript
+class Singleton {
+  constructor(name) {
+    this.name = name;
+  }
 }
 
-/** Add labels, set properties and styles
-* @param {IElementParams} params configuration
-* @return {ElementObject} Generated label
-* /
+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); // Output: false
+```
 
-##### event
+##### 11. `classDecorator(params: object): ClassDecorator`
 
-/** Browser events
-* @param {Document} ele tag
-* @param {string} type Event type
-* @param {(e: Event) => void} handler Event callback
-* @return {void}
-* /
+Add a decorator to the class.
 
-export type IAddHandler = <T extends Document>(ele: T, type: string, handler: (e: Event) => void) => void
+- 'params' : properties and methods to add.
 
-/** Cancel event bubbling
-* @param {Event} e Browser event object
-* @return {void}
-* /
+```javascript
+@classDecorator({
+  additionalMethod: function () {
+    console.log("Additional method");
+  },
+})
+class DecoratedClass {}
 
-export type IStopBubble = (e: Event) => void
+const instance = new DecoratedClass();
+instance.additionalMethod(); // Output: Additional method
+```
 
-/** Cancels the default event
-* @param {Event} e Browser event object
-* @return {void}
-* /
+##### 12. `stringToJson(target: string): object | null`
 
-export type IStopDefault = (e: Event) => void
+Converts a JSON string to an object.
 
-/** Cancels browser events
-* @param {Document} ele tag
-* @param {string} type Event type
-* @param {(e: Event) => void} handler Event callback
-* @return {void}
-* /
+- 'target' : JSON string to be converted.
 
-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); // Output: {key: 'value'}
+```
 
-/** Cancels the default event
-* @param {Event} e Browser event object
-* @return {void}
-* /
+##### 13. `jsonToString(target: any): string`
 
-export type IDispatchEvent = <T extends Document>(ele: T, data: any) => void
+Converts the object to a JSON string.
 
+- 'target' : indicates the object to be converted.
 
-##### log
+```javascript
+const obj = { key: "value" };
+const jsonString = jsonToString(obj);
+console.log(jsonString); // Output: '{"key":"value"}'
+```
 
-/** Single line output
-* @param {string} str Output character
-* @param {boolean} overwrite overwrites the previous output
-* @param {boolean} warp Wrap the last line
-* @return {void}
-* /
-export type ILogOneLine = (str: string, overwrite? : boolean, warp? : boolean) => void
+##### 14. `isWindow(win: any): boolean`
 
-/** Loops out a queue
-* @param {string[]} loopList Indicates the output character queue
-* @param {number} index The number of characters
-* @param {boolean} isStop Control pause loop
-* @param {number} timer Indicates two interval times
-* /
-export type ILogLoopParams = {
-loopList? : string[]
-index? : number
-isStop? : boolean
-timer? : number
-}
-export type ILogLoop = (opts? : ILogLoopParams) => ILogLoopParams | void
+Check whether it is a browser window.
 
-##### request module
-###### https://gitee.com/DieHunter/js-request-lib
-export type IRequestParams<T> = T | IObject<any> | null
+- 'win' : indicates the object to be checked.
 
-// Request path
+```javascript
+const isBrowserWindow = isWindow(window);
+console.log(isBrowserWindow); // Output: true
+```
 
-export type IUrl = string
+#### array module
 
-// Environmental judgment
+##### 1. `arrayRandom(arr: any[]): any[]`
 
-export type IEnv = 'Window' | 'Node'
+Randomly sort the array.
 
-// fetch Returns the value
+- 'arr' : array to sort.
 
-export type IDataType = "text" | "json" | "blob" | "formData" | "arrayBuffer"
+```javascript
+const originalArray = [1, 2, 3, 4, 5];
+const randomizedArray = arrayRandom(originalArray);
+console.log(randomizedArray);
+// Output: a randomly sorted array
+```
 
-// Request mode
+##### 2. `arrayUniq(arr: any[]): any[]`
 
-export type IRequestMethods = "GET" | "POST" | "DELETE" | "PUT" | "OPTION"
+Removes duplicate elements from the array.
 
-// body structure
+- 'arr' : array to process.
 
-export type IRequestBody = IRequestParams<BodyInit>
+```javascript
+const arrayWithDuplicates = [1, 2, 2, 3, 4, 4, 5];
+const uniqueArray = arrayUniq(arrayWithDuplicates);
+console.log(uniqueArray);
+// Output: Array with duplicate elements removed
+```
 
-// heads structure
+##### 3. `arrayDemote(arr: IDemoteArray<any>, result: any[] = []): any[]`
 
-export type IRequestHeaders = IRequestParams<HeadersInit>
+Reduces the dimension of multiple nested arrays.
 
-// Request the base function
+- 'arr' : array to be reduced.
+- 'result' : The array used to store the result. The default is an empty array.
 
-export type IRequestBaseFn = (url: IUrl, opts: IRequestOptions) => Promise<any>
+```javascript
+const nestedArray = [1, [2, [3, [4]], 5]];
+const demotedArray = arrayDemote(nestedArray);
+console.log(demotedArray);
+// Output: reduced array [1, 2, 3, 4, 5]
+```
 
-// Request function body
+#### function module
 
-export type IRequestFn = (url? : IUrl, query? : IObject<any>, body? : IRequestBody, opts? : IRequestOptions) => Promise<any>
+##### 1. `throttle(fn: Function, time: number): Function`
 
-// Request parameters
+Limits how often a function is called within a specified period of time.
 
-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' : function to be executed.
+- 'time' : indicates the time interval (milliseconds).
 
-// Interceptor
+```javascript
+const throttledFunction = throttle(
+  () => console.log("Throttled function called!"),
+  1000
+);
+throttledFunction(); // This command is executed only after 1 second
+```
 
-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`
 
-// Public 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>
-}
+Limits the continuous invocation of a function for a specified period of time.
 
-// Initialize parameters
+- 'fn' : function to be executed.
+- 'time' : indicates the time interval (milliseconds).
 
-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(); // Called multiple times within 1 second, only the last time will be executed
+```
 
-// Request principal class
+##### 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
+Create a flat Promise delay object that can be set to time out after a certain amount of time.
 
+- 'timer' : indicates the timeout period (milliseconds). The default value is 0.
 
-<! -- News Center -->
-##### News Center
-###### 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); // Delay output
+delayFn().catch(console.error); // Timeout output
+```
 
+##### 4. `catchAwait(defer: Promise<any>): Promise<[Error | null, any]>`
 
-<! -- Task Queue -->
-##### Task queue
-###### https://gitee.com/DieHunter/task-queue
-/ * *
-* Single queue
-* defer: asynchronous function to be run
-* params? The: defer parameter can also be passed directly using bind
-*
-* /
-export interface IQueue {
-defer: Function
-name? : string
-}
-/ * *
-* Queue parameter
-* children: Queue list
-* name: indicates the unique identifier of the queue
-* result: indicates the result after the run is complete
-*
-* /
-export interface IQueues {
-children: Array<Function>
-name: string
-result? : any[]
-}
-/ * *
-* queue cache
-* /
-export type IQueueTemp = {
-[key: string]: IQueues
-}
-/ * *
-* System queue
-* /
-export type IQueueList = Array<IQueue>
-/ * *
-* The queue status idle: idle pending: waiting fulfilled: completed rejected: failed
-* /
-export type IState = "idle" | "pending" | "fulfilled" | "rejected"
-/ * *
-* Task queue parameters
-* /
-export type ITaskQueueProps = {
-maxLen: number
-}
-/ * *
-* Task queue
-* /
-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
-}
+Catches an Error for an asynchronous operation and returns' [Error, null] 'or' [null, result] '.
 
+- 'defer' : The Promise object for the asynchronous operation.
 
+```javascript
+const asyncOperation = new Promise((resolve, reject) => {
+  // Simulate asynchronous operations
+  setTimeout(() => {
+    reject(new Error("Something went wrong!"));
+  }, 1000);
+});
 
-/** Single line output
-* @param {string} str Output character
-* @param {boolean} overwrite overwrites the previous output
-* @param {boolean} warp Wrap the last line
-* @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
-
-/ * *
-* Animation
-* reference: 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 // Animation index
-duration: number // Frame number control
-isActive: boolean// Activate control
-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
-}
+const [error, result] = await catchAwait(asyncOperation);
+console.log(error); // Output: Error: Something went wrong!
+console.log(result); // Output: null
+```
+
+#### element module
+
+##### 1. `createElement(options: { ele? : string | HTMLElement, style? : object, attr? : object, parent? : HTMLElement }): HTMLElement`
+
+Creates and returns an HTML element.
+
+- 'ele' : element type or existing HTMLElement object, optional, default is 'div'.
+- 'style' : The style object of the element, optional.
+- 'attr' : attribute object of the element, optional.
+- 'parent' : indicates the parent of the element. This parameter is optional.
+
+```javascript
+const options = {
+  ele: "div",
+  style: { color: "blue", fontSize: "16px" },
+  attr: { id: "myElement", className: "custom-class" },
+  parent: document.body,
+};
+
+const createdElement = createElement(options);
+// Create a div element with style and attributes in the body
+```
+
+#### event module
+
+##### 1. `addHandler(ele: HTMLElement, type: string, handler: EventListener): void`
+
+Add event listeners to the element.
+
+- 'ele' : target element.
+- 'type' : indicates the type of the event.
+- 'handler' : event handler.
+
+```javascript
+const button = document.getElementById("myButton");
+const handleClick = () => console.log("Button clicked! ");
+addHandler(button, "click", handleClick);
+```
+
+##### 2. `stopBubble(event: Event): void`
+
+Prevent events from bubbling.
+
+- 'event' : indicates an event object.
+
+```javascript
+const handleClick = (event) => {
+  console.log("Button clicked! ");
+  stopBubble(event);
+};
+```
+
+##### 3. `stopDefault(event: Event): void`
+
+Default behavior to block events.
+
+- 'event' : indicates an event object.
+
+```javascript
+const handleFormSubmit = (event) => {
+  console.log("Form submitted! ");
+  stopDefault(event);
+};
+```
+
+##### 4. `removeHandler(ele: HTMLElement, type: string, handler: EventListener): void`
+
+Removes an element's event listener.
+
+- 'ele' : target element.
+- 'type' : indicates the type of the event.
+- 'handler' : event handler to be removed.
+
+```javascript
+const button = document.getElementById("myButton");
+const handleClick = () => console.log("Button clicked! ");
+addHandler(button, "click", handleClick);
+// Other operations...
+removeHandler(button, "click", handleClick);
+```
+
+##### 5. `dispatchEvent(ele: HTMLElement, data: any): void`
+
+Trigger a custom event.
+
+- 'ele' : target element.
+- 'data' : indicates the data of a custom event.
+
+```javascript
+const customEvent = new CustomEvent("customEvent", {
+  detail: { key: "value" },
+});
+const targetElement = document.getElementById("myElement");
+dispatchEvent(targetElement, customEvent);
+```
+
+#### storage module
+
+##### 1. `setStorage(key: string, val: any): void`
+
+Store values to local storage.
+
+- 'key' : specifies the name of the key.
+- 'val' : The value to be stored.
+
+```javascript
+const userData = { username: "john_doe", email: "john@example.com" };
+setStorage("user_data", userData);
+```
+
+##### 2. `getStorage(key: string): any`
+
+Gets the value from local storage.
+
+- 'key' : specifies the key name to be obtained.
+
+```javascript
+const storedUserData = getStorage("user_data");
+console.log(storedUserData);
+// Output: {username: 'john_doe', email: 'john@example.com'}
+```
+
+##### 3. `clearStorage(key? : string): void`
+
+Clear the value from the local store.
+
+- 'key' : specifies the name of the key to be cleared. If no key name is provided, all storage is cleared.
+
+```javascript
+clearStorage("user_data"); // Clear the stored value for a specific key name
+// or
+clearStorage(); // Clear all locally stored values
+```
+
+#### log module
+
+##### 1. `logOneLine(str: string, overwrite: boolean = false, wrap: boolean = true): void`
+
+Output logs in one line.
+
+- 'str' : The string to be output.
+- 'overwrite' : Whether to overwrite the current line. The default is' false '.
+- 'wrap' : Whether to wrap lines after output, defaults to '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 }`
+
+Output a loop animation in the console.
+
+- 'opts' : an optional parameter object containing the following properties:
+- `loopList` : animation character list, the default is `[' \ \ ', '|', '/', '-', '-']`.
+- 'isStop' : Whether to stop the loop. The default is' false '.
+- 'timer' : Animation switch interval (milliseconds), default is' 100 '.
+- 'index' : indicates the index of the current animated character. The default value is 0.
+
+```javascript
+logLoop(); // Start the default loop animation
+// or
+logLoop({ loopList: ["-", "+", "-", "+"], timer: 200 }); // Start a custom loop animation
+```
+
+#### animation module
+
+##### 1. `class AnimateFrame`
+
+A class that provides frame animation.
+
+- `start(duration? : number): void ': Starts frame animation, optional parameter' duration 'is frame number control.
+- 'stop(): void' : stops frame animation.
+
+```javascript
+const animateFrame = new AnimateFrame((timestamp) => {
+  // Update animation status here
+  console.log("AnimationFrame callback:", timestamp);
+});
+
+animateFrame.start(60); // Start frame animation at 60 frames per second
+// Other operations...
+animateFrame.stop(); // Stop frame animation
+```
+
+##### 2. `quadraticBezier(_x: number, _y: number, t: number): [number, number]`
+
+Calculate the coordinates of points on the quadratic Bessel curve.
+
+- '\_x' : x coordinates of control point 1.
+- '\_y' : y coordinate of control point 1.
+- 't' : indicates the time parameter. The value ranges from 0 to 1.
+
+```javascript
+const result = quadraticBezier(0, 0, 1, 1, 0.5);
+console.log(result);
+// Output: [0.75, 0.75]
+```
+
+##### 3. `cubicBezier(_x1: number, _y1: number, _x2: number, _y2: number, t: number): [number, number]`
+
+Calculate the coordinates of points on a cubic Bezier curve.
+
+- '\_x1' : x coordinate of control point 1.
+- '\_y1' : y coordinate of control point 1.
+- '\_x2' : control point 2 x coordinates.
+- '\_y2' : y coordinate of control point 2.
+- 't' : indicates the time parameter. The value ranges from 0 to 1.
+
+```javascript
+const result = cubicBezier(0, 0, 0.5, 1, 0.5);
+console.log(result);
+// Output: [0.375, 0.625]
+```
+
+##### 4. `factorial(n: number): number`
+
+Calculate the factorial.
+
+- n: indicates a non-negative integer.
+
+```javascript
+const result = factorial(5);
+console.log(result);
+// Output: 120
+```
+
+##### 5. `combination(n: number, k: number): number`
+
+Calculate the number of combinations.
+
+- n: indicates the total number.
+- 'k' : indicates the number of selected items.
+
+```javascript
+const result = combination(5, 2);
+console.log(result);
+// Output: 10
+```
+
+##### 6. `NBezier(points: number[][], t: number): [number, number]`
+
+Calculate the point coordinates on the NTH Bezier curve.
+
+- 'points' : array of control points. Each point is a second-order array.
+- 't' : indicates the time parameter. The value ranges from 0 to 1.
+
+```javascript
+const points = [
+  [0, 0],
+  [1, 1],
+  [2, 0],
+];
+const result = NBezier(points, 0.5);
+console.log(result);
+// Output: [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