utils-lib-js 2.0.23 → 2.0.24

package/dist/umd/log.d.ts

@@ -0,0 +1,8 @@
+import { ILogOneLine, ILogLoop } from "./types";
+export declare const logOneLine: ILogOneLine;
+export declare const logLoop: ILogLoop;
+declare const _default: {
+    logOneLine: ILogOneLine;
+    logLoop: ILogLoop;
+};
+export default _default;

package/dist/umd/object.d.ts

@@ -0,0 +1,36 @@
+import { IGetValue, ISetValue, IMixIn, ICloneDeep, ICreateObjectVariable, IEnumInversion, IInherit, ICreateObject, IGetInstance, IClassDecorator, IStringToJson, IJsonToString, IObject } from "./types";
+export declare const getValue: IGetValue;
+export declare const setValue: ISetValue;
+export declare const mixIn: IMixIn;
+export declare const enumInversion: IEnumInversion;
+export declare const isNotObject: (source: any, type: any) => boolean;
+export declare const cloneDeep: ICloneDeep;
+export declare const createObjectVariable: ICreateObjectVariable;
+export declare const createObject: ICreateObject;
+export declare const inherit: IInherit;
+export declare const getInstance: IGetInstance;
+export declare const classDecorator: IClassDecorator;
+export declare const stringToJson: IStringToJson;
+export declare const jsonToString: IJsonToString;
+export declare const isWindow: (win: any) => boolean;
+export declare const emptyObject: (init?: IObject<unknown>) => any;
+export declare const isEmptyObject: (object?: IObject<unknown>) => boolean;
+declare const _default: {
+    getValue: IGetValue;
+    setValue: ISetValue;
+    mixIn: IMixIn;
+    enumInversion: IEnumInversion;
+    isNotObject: (source: any, type: any) => boolean;
+    cloneDeep: ICloneDeep;
+    createObjectVariable: ICreateObjectVariable;
+    createObject: ICreateObject;
+    inherit: IInherit;
+    getInstance: IGetInstance;
+    classDecorator: IClassDecorator;
+    stringToJson: IStringToJson;
+    jsonToString: IJsonToString;
+    isWindow: (win: any) => boolean;
+    emptyObject: (init?: IObject<unknown>) => any;
+    isEmptyObject: (object?: IObject<unknown>) => boolean;
+};
+export default _default;

package/dist/umd/static.d.ts

@@ -0,0 +1,16 @@
+export declare enum types {
+    "[object Array]" = "array",
+    "[object Object]" = "object",
+    "[object Function]" = "function",
+    "[object Set]" = "set",
+    "[object Map]" = "map",
+    "[object WeakMap]" = "weakMap",
+    "[object WeakSet]" = "weakSet",
+    "[object Date]" = "date",
+    "[object RegExp]" = "regExp",
+    "[object Math]" = "math"
+}
+declare const _default: {
+    types: typeof types;
+};
+export default _default;

package/dist/umd/storage.d.ts

@@ -0,0 +1,9 @@
+export declare const setStorage: (key: string, val: any) => void;
+export declare const getStorage: (key: string) => any;
+export declare const clearStorage: (key: string) => void;
+declare const _default: {
+    setStorage: (key: string, val: any) => void;
+    getStorage: (key: string) => any;
+    clearStorage: (key: string) => void;
+};
+export default _default;

package/dist/umd/types.d.ts

@@ -0,0 +1,73 @@
+export type IKey = string | symbol | number;
+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;
+}
+export type IInstance<T> = {
+    _instance: Function;
+} & T;
+export type IDemoteArray<T> = Array<IDemoteArray<T> | T>;
+export type IRandomNum = (min: number, max: number, bool?: boolean) => number;
+export type IUrlSplit = (url: string) => IObject<any>;
+export type IUrlJoin = (url: string, query: object) => string;
+export type IGetType<T> = (data: any) => typeof data | T[keyof T] | "null";
+export type IGetTypeByList = (data: any, whiteList: string[]) => boolean;
+export type IGetValue = <T, U = IObject<T> | IObject<T>[IKey]>(object: U, key: string, defaultValue?: any) => U;
+export type ISetValue = <T>(object: IObject<T>, key: string, value?: any) => IObject<T>;
+export type IMixIn = <U extends IObject<any>>(target?: U, source?: IObject<any>, overwrite?: boolean) => U;
+export type IEnumInversion = (target: IObject<string>) => IObject<string>;
+export type ICloneDeep = (target?: any) => any;
+export type ICreateObjectVariable = (type: string, source?: any) => any;
+export type ICreateObject = <T, U extends T>(source: T) => U;
+export type IInherit = <T extends Function>(source: T, target?: Function) => Function;
+export type IGetInstance = (classProto: IInstance<FunctionConstructor>, overwrite?: boolean, ...params: any[]) => Function;
+export type IClassDecorator = (params: IObject<any>) => <TFunction extends Function>(target: TFunction) => void;
+export type IStringToJson = (target: string) => IObject<any> | null;
+export type IJsonToString = (target: IObject<any>) => string;
+export type IThrottle = (fn: Function, time: number) => (...args: any[]) => void;
+export type IDebounce = (fn: Function, time: number) => (...args: any[]) => void;
+export type IDefer = (timer?: number) => IPromise;
+export type ICatchAwait<T extends Promise<any>> = (defer: T) => T;
+export type IRequestFrame = (callback: (start: number) => void, delay: number) => () => void;
+export type IArrayRandom<T extends any[]> = (arr: T) => T;
+export type IArrayUniq<T extends any[]> = (arr: T) => T;
+export type IArrayDemote<T extends IDemoteArray<any>> = (arr: T, result?: T) => T;
+export type IArrayLoop = (list: unknown[], current?: number) => {
+    item: unknown;
+    current: number;
+};
+type TagAttributes = Partial<Record<string, string | boolean>>;
+interface IElementParams<T> {
+    ele: T | string;
+    style?: Partial<CSSStyleDeclaration>;
+    attr?: TagAttributes;
+    parent?: T;
+}
+export type ICreateElement<T = HTMLElement> = (params: IElementParams<T>) => T;
+export type IAddHandler = <T extends Document>(ele: T, type: string, handler: (e: Event) => void) => void;
+export type IStopBubble = (e: Event) => void;
+export type IStopDefault = (e: Event) => void;
+export type IRemoveHandler = <T extends Document>(ele: T, type: string, handler: (e: Event) => void) => void;
+export type IDispatchEvent = <T extends Document>(ele: T, data: any) => void;
+export type ILogOneLine = (str: string, overwrite?: boolean, warp?: boolean) => void;
+export type ILogLoopParams = {
+    loopList?: string[];
+    index?: number;
+    isStop?: boolean;
+    timer?: number;
+};
+export type ILogLoop = (opts?: ILogLoopParams) => ILogLoopParams | void;
+export type IAnimateFrame = {
+    id: number | null;
+    duration: number;
+    isActive: boolean;
+    fn(timer: number): void;
+    start(duration: number): void;
+    stop(id?: number): void;
+    animate(timer: number): void;
+};
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "utils-lib-js",
-  "version": "2.0.23",
+  "version": "2.0.24",
   "description": "JavaScript工具函数，封装的一些常用的js函数",
   "main": "./dist/cjs/index.js",
   "types": "./dist/cjs/index.d.ts",
@@ -43,7 +43,7 @@
   "dependencies": {
     "event-message-center": "^1.4.0",
     "js-log-lib": "^1.1.2",
-    "js-request-lib": "^1.0.9",
+    "js-request-lib": "^1.0.10",
     "task-queue-lib": "^1.4.2",
     "timer-manager-lib": "^1.0.0"
   },