ddan-js 2.3.8 → 2.4.0

package/bin/types/index.d.ts

@@ -304,9 +304,9 @@ declare const dClass: {
 };
 declare const dStore: {
     Store: typeof Store;
-    storeRef: (source: import("./typings").dd.IDStore, persistConfig?: import("./typings").dd.IDPersistConfig | undefined) => any;
+    storeRef: (source: import("./typings").Ddan.IDStore, persistConfig?: import("./typings").Ddan.IDPersistConfig | undefined) => any;
     Persist: typeof Persist;
-    persistConfig: (key: string, fields: string[], storage: import("./typings").dd.DStorage) => import("./typings").dd.IDPersistConfig;
+    persistConfig: (key: string, fields: string[], storage: import("./typings").Ddan.IStorage) => import("./typings").Ddan.IDPersistConfig;
 };
 declare const dJoker: import("./class/joker").Joker;
 declare const dTracker: import("./class/tracker").DTracker;
@@ -409,3 +409,329 @@ declare const dWeb: {
     };
 };
 export { dUtil, dHook, dWeb, dMini, dCdn, dClass, dStore, dJoker, dTracker, dLogger };
+declare const _default: {
+    gbk: {
+        gbkLength: (str: string) => number;
+        gbkCut: (source: string, len: number) => string;
+    };
+    time: {
+        now: () => import("./modules/time/dtime").default;
+        isToday: (date: any) => any;
+        parseTimestamp: ({ year, month, date, hour, minute, second }: {
+            year?: number | undefined;
+            month?: number | undefined;
+            date?: number | undefined;
+            hour?: number | undefined;
+            minute?: number | undefined;
+            second?: number | undefined;
+        }) => number;
+        todayZero: () => number;
+        format: (time: string | number | Date, reg?: string) => string;
+        countdown: (endTime: string | number | Date, reg?: string) => "" | import("./modules/time/dtime").IDCountdownFormat;
+        dtime: (time: string | number | Date) => import("./modules/time/dtime").default;
+        loopFrame: (interval?: number) => import("./modules/time/frame").default;
+        oneDay: number;
+        oneHour: number;
+        oneMinute: number;
+        oneSecond: number;
+    };
+    hook: {
+        run: <T = any>(task?: Function | Promise<T> | undefined, wait?: number) => Promise<[any, undefined] | [null, T]>;
+        exec: (func: Function, taskId?: string) => Promise<any[]>;
+        debounce: typeof import("./modules/hook/debounce").default;
+        throttle: typeof import("./modules/hook/throttle").default;
+        task: (param?: import("./typings").Ddan.Func1<any, any> | undefined) => import("./class/pipeTask").default;
+        mutex: typeof import("./modules/hook/mutex").default;
+        polling: typeof import("./modules/hook/polling").default;
+        singleton: <T_1>() => {
+            new (): {};
+            __instance__: any;
+            readonly Instance: T_1;
+        };
+        to: <T_2 = any, U extends object = any>(promise: Promise<T_2>, errorExt?: object | undefined) => Promise<[null, T_2] | [U, undefined]>;
+        delay: (time?: number) => Promise<unknown>;
+    };
+    math: {
+        random: (max: number) => number;
+        randomRange: (min: number, max: number) => number;
+        lerp: (start: number, end: number, t: number) => number;
+        randoms: (max: number, count?: number, repeat?: boolean) => number[];
+        strip: (num: string | number, digits?: number) => number;
+        float: (num: string | number, { digits, fixed }?: {
+            digits?: number | undefined;
+            fixed?: boolean | undefined;
+        }) => number;
+        radian2degree: (radians: number) => number;
+        degree2radian: (degrees: number) => number;
+        formatMemory: (mem: number) => {
+            g: number;
+            m: number;
+            kb: number;
+            b: number;
+            desc: string;
+        };
+    };
+    util: {
+        includes: typeof import("./util/includes").default;
+        forof: (source: any, cb: (key: any, val: any) => void) => void;
+        copy: (source: any, options?: {
+            fields?: string[] | undefined;
+            camel?: boolean | undefined;
+            pure?: boolean | undefined;
+        } & import("./typings").dd.IIgnoreParams) => any;
+        clone: (source: any) => any;
+        merge: (target: any, source: any, options?: import("./typings").dd.IIgnoreParams) => {};
+        isEmpty: (source: any) => boolean;
+        parseValue: (source: any, { number, boolean }?: {
+            number?: boolean | undefined;
+            boolean?: boolean | undefined;
+        }) => any;
+        cloneClass: <T_3>(source: T_3) => T_3;
+        combine: (target: any, source: any, options?: import("./typings").dd.IIgnoreParams) => any;
+        combines: (objs: any[], options?: import("./typings").dd.IIgnoreParams) => {};
+        observe: (obj: any, key: any, watchFun: any, owner: any, deep?: boolean) => void;
+        getTag: (value: any) => string;
+        getType: (value: any) => string;
+        toString: () => string;
+        hasOwnProperty: (v: PropertyKey) => boolean;
+        propertyIsEnumerable: (v: PropertyKey) => boolean;
+        is: (val: any, type: string) => boolean;
+        isNumber: (value: any) => boolean;
+        isString: (value: any) => boolean;
+        isObject: (value: any) => boolean;
+        isObjectLike: (value: any) => boolean;
+        isPlainObject: (value: any) => boolean;
+        isSymbol: (value: any) => boolean;
+        isFunction: (value: any) => boolean;
+        isArray: (arg: any) => arg is any[];
+        isArrayLikeObject: (value: any) => boolean;
+        isIndex: (value: any, length: number) => boolean;
+        isArrayLike: (value: any) => boolean;
+        isPrototype: (value: any) => boolean;
+        isArguments: (value: any) => boolean;
+        isPromise: (value: any) => boolean;
+    };
+    list: {
+        stepAction: <T_4>(list: T_4[], func: import("./typings").Ddan.Task<T_4, void>, stepCount?: number) => void;
+        skip: <T_5>(list: T_5[], count: number) => T_5[];
+        take: <T_6>(list: T_6[], count: number, skip?: number) => T_6[];
+        distinct: <T_7>(list: T_7[]) => T_7[];
+        randoms: <T_8>(list: T_8[], count?: number, repeat?: boolean) => T_8[];
+        toKV: (list: import("./typings").Ddan.KV<any>[], key: string, value: string) => import("./typings").Ddan.KV<any>;
+        groupBy: <T_9>(list: T_9[], key: string) => Record<string, T_9[]>;
+        first: <T_10>(list: T_10[]) => T_10 | undefined;
+        last: <T_11>(list: T_11[]) => T_11 | undefined;
+        toList: <T_12>(val: T_12 | T_12[]) => T_12[];
+    };
+    string: {
+        toString: (value: any) => any;
+        startCase: (string: any) => any;
+        snakeCase: (string: any) => any;
+        kebabCase: (string: any) => any;
+        camelCase: (string: any) => any;
+        upperCase: (string: any) => any;
+        upperFirst: (string: any) => any;
+        lowerCase: (string: any) => any;
+        lowerFirst: (string: any) => any;
+        splitOnFirst: (string: any, separator: any) => string[];
+        parseValue: (value?: any, { number, boolean }?: {
+            number?: boolean | undefined;
+            boolean?: boolean | undefined;
+        }) => any;
+        replace: (source: string, rules: import("./typings").dd.IRegexRule | import("./typings").dd.IRegexRule[]) => string;
+    };
+    obj: {
+        copy: (source: any, options?: {
+            fields?: string[] | undefined;
+            camel?: boolean | undefined;
+            pure?: boolean | undefined;
+        } & import("./typings").dd.IIgnoreParams) => any;
+        clone: (source: any) => any;
+        merge: (target: any, source: any, options?: import("./typings").dd.IIgnoreParams) => {};
+        isEmpty: (source: any) => boolean;
+        parseValue: (source: any, { number, boolean }?: {
+            number?: boolean | undefined;
+            boolean?: boolean | undefined;
+        }) => any;
+        cloneClass: <T_3>(source: T_3) => T_3;
+        combine: (target: any, source: any, options?: import("./typings").dd.IIgnoreParams) => any;
+        combines: (objs: any[], options?: import("./typings").dd.IIgnoreParams) => {};
+        observe: (obj: any, key: any, watchFun: any, owner: any, deep?: boolean) => void;
+    };
+    crypto: {
+        base64: {
+            encode: (input: string) => string;
+            decode: (input: string) => string;
+            encodeByOss: (input: string) => string;
+        };
+        uuid: (len?: number, radix?: number) => string;
+        getNewId: (len: number, prefix?: boolean, sep?: string) => string;
+        keyNumber: string;
+        keyLower: string;
+        keyUpper: string;
+        keyChars: string;
+    };
+    mini: {
+        diff: typeof import("./modules/mini/diff").default;
+        promixify: (miniapi: any) => any;
+        run: (func: any, args?: {}) => Promise<[any, undefined] | [null, any]>;
+        formatList: (lists: any[], start: any, name: any) => any;
+        ruleValidator: (_: any, value: any) => boolean;
+        Http: typeof import("./modules/mini/http").default;
+        setWatcher: (page: any) => void;
+    };
+    qs: {
+        parse: (qs: any, { sep, eq, max, multiple, uri, parseNumber, parseBoolean }?: {
+            sep?: string | undefined;
+            eq?: string | undefined;
+            max?: number | undefined;
+            multiple?: boolean | undefined;
+            uri?: boolean | undefined;
+            parseNumber?: boolean | undefined;
+            parseBoolean?: boolean | undefined;
+        }) => {};
+        stringify: (obj: any, { sep, eq, name, uri, cleanZero, cleanNull, cleanWhitespace }?: {
+            sep?: string | undefined;
+            eq?: string | undefined;
+            name?: null | undefined;
+            uri?: boolean | undefined;
+            cleanZero?: boolean | undefined;
+            cleanNull?: boolean | undefined;
+            cleanWhitespace?: boolean | undefined;
+        }) => string;
+        https: (url: string) => string;
+        parseUrl: (url: string) => {
+            host: string;
+            origin: string;
+            url: string;
+            path: string;
+            page: string;
+            query: string;
+            filename: string;
+            filenameWithoutExtension: string;
+            extension: string;
+            route: string;
+            params: {};
+        };
+        parsePath: (path: string) => {
+            root: string;
+            name: string;
+            withoutExtension: string;
+            extension: string;
+        };
+        join: (...args: string[]) => string;
+    };
+    css: {
+        stringify: (styleObj: Record<string, string | number>) => string;
+        parse: (styleStr: string, { camel, pure }?: {
+            camel?: boolean | undefined;
+            pure?: boolean | undefined;
+        }) => {} | undefined;
+        fixValue: (value: string | number, unit?: string) => string | number;
+        style: (cssKV: Record<string, any>, unit?: string) => string;
+        commonFields: string[];
+    };
+    cdn: {
+        ossImage: (url: string, options?: {
+            webp?: boolean | undefined;
+            resize?: number | undefined;
+            interlace?: boolean | undefined;
+            domain?: string | string[] | undefined;
+        }) => string;
+        ossSnapshot: (url: string, options?: {
+            t?: number | undefined;
+            w?: number | undefined;
+            h?: number | undefined;
+            m?: "" | "fast" | undefined;
+            f?: "jpg" | "png" | undefined;
+            ar?: "auto" | "h" | "w" | undefined;
+        }) => string;
+    };
+    html: {
+        dataURLtoFile: (dataurl: any, filename: any) => File;
+        dataURLtoBlob: (dataurl: any) => Blob;
+        blobToFile: (blob: any, fileName: string) => any;
+        readAsDataURL: (file: any, cb: any) => void;
+        downloadUrl: (url: string, filename?: string, checkSomeOrigin?: boolean) => void;
+        download: (urlOrFile: string | Blob | MediaSource, filename?: string) => void;
+        downloadFile: (data: Blob | MediaSource, filename?: string) => void;
+        downloadImage: (url: string) => Promise<void> | undefined;
+        watermark: (text: string, { width, height, angle, fillStyle, font, textAlign, textBaseline }?: {
+            width?: number | undefined;
+            height?: number | undefined;
+            angle?: number | undefined;
+            fillStyle?: string | undefined;
+            font?: string | undefined;
+            textAlign?: "center" | "end" | "left" | "right" | "start" | undefined;
+            textBaseline?: "alphabetic" | "bottom" | "hanging" | "ideographic" | "middle" | "top" | undefined;
+        }) => string;
+    };
+    icon: import("./class/icon").DIcon;
+    rule: {
+        validateId: (content: any) => boolean;
+        validatePhone: (content: any) => boolean;
+        validator: (rules: import("./modules/rule/async-validator").Rules) => import("./modules/rule/async-validator").default;
+        validate: (rules: import("./modules/rule/async-validator").Rules, source_: import("./modules/rule/async-validator").Values, o?: any, oc?: any) => Promise<import("./modules/rule/async-validator").Values>;
+        isChinese: (content: string) => boolean;
+        isNumber: (content: string) => boolean;
+        isFloat: (content: string) => boolean;
+        isPhoneNumber: (content: any) => boolean;
+    };
+    regex: {
+        pattern: {
+            num: string;
+            zh: string;
+            en: string;
+        };
+        regex: (patt: string, modifiers?: "i" | "g" | "m" | undefined) => RegExp;
+        entire: {
+            chinese: RegExp;
+            real: RegExp;
+            cssReal: RegExp;
+            id: RegExp;
+            yyyyMMdd: RegExp;
+        };
+    };
+    convert: {
+        uint8ArrayToString: (arr: any) => string;
+        stringToArrayBuffer: (str: any) => ArrayBuffer;
+        arrayBufferToString: (data: ArrayBuffer, base64?: boolean) => string;
+    };
+    Event: typeof Event;
+    Http: typeof Http;
+    Store: typeof Store;
+    storeRef: (source: import("./typings").Ddan.IDStore, persistConfig?: import("./typings").Ddan.IDPersistConfig | undefined) => any;
+    Persist: typeof Persist;
+    persistConfig: (key: string, fields: string[], storage: import("./typings").Ddan.IStorage) => import("./typings").Ddan.IDPersistConfig;
+    watermark: (bg: string, size?: {
+        width?: number | undefined;
+        height?: number | undefined;
+    } | undefined) => import("./class/watermark").DWatermark;
+    joker: import("./class/joker").Joker;
+    tracker: import("./class/tracker").DTracker;
+    logger: {
+        override: () => void;
+        log: (...args: any[]) => void;
+        info: (...args: any[]) => void;
+        warn: (...args: any[]) => void;
+        error: (...args: any[]) => void;
+        config: ({ tag, format }?: {
+            tag?: boolean | undefined;
+            format?: string | undefined;
+        }) => void;
+    };
+    fetch: {
+        getDataURL: (url: string) => Promise<[any, undefined] | [null, {
+            contentType: string;
+            dataUrl: string;
+        }]>;
+        getArrayBuffer: (url: string) => Promise<[any, undefined] | [null, ArrayBuffer]>;
+        getJson: (url: string) => Promise<[any, undefined] | [null, any]>;
+        download: (url: string, opts?: {
+            success?: ((buffer: Uint8Array) => void) | undefined;
+            progress?: ((percentage: number, current: number, total: number) => void) | undefined;
+            fail?: ((error: Error) => void) | undefined;
+        }) => Promise<Uint8Array | undefined>;
+    };
+};
+export default _default;

package/bin/types/typings/index.d.ts

@@ -1,11 +1,11 @@
-import DPersist from "../class/persist";
 export declare namespace Ddan {
     type KV<T = any> = Record<string, T>;
-    type KeyValueOjbect<T = any> = {
+    interface IKeyValuePart<T = any> {
         key: string;
         value: T;
-    };
-    type KeyValue<T = any> = Required<KeyValueOjbect<T>>;
+    }
+    type KeyValue<T = any> = Required<IKeyValuePart<T>>;
+    type Function = (...args: any[]) => void;
     type Callback<T extends any[] = unknown[], R = any> = (...args: T) => R;
     type Action<T extends any[] = unknown[]> = Callback<T, void>;
     type Task<T = any, R = void> = Callback<[T[]], R>;
@@ -15,33 +15,25 @@ export declare namespace Ddan {
     type Func3<T0 = any, T1 = any, T2 = any, R = any> = Callback<[T0, T1, T2], R>;
     type Func4<T0 = any, T1 = any, T2 = any, T3 = any, R = any> = Callback<[T0, T1, T2, T3], R>;
     type Result<T = any> = T | Promise<T>;
-}
-export declare namespace dd {
-    type Omit<T, K> = Pick<T, Exclude<keyof T, K>>;
-    /**
-     * leading 开始执行
-     * trailing 结束执行
-     */
-    interface IDebounceOption {
-        leading?: boolean;
-        maxWait?: number;
-        trailing?: boolean;
+    interface IEvent {
+        clear: () => void;
+        on: (name: string, handler: Function, tag: string) => void;
+        emit: (name: string, ...args: any[]) => void;
+        off: (name: string, handler: Function) => void;
+        remove: (name: string) => void;
+        removeByTag: (tag: string) => void;
+        once: (name: string, handler: Function) => void;
+        has: (name: string) => boolean;
     }
-    type TStoreGetterFunction = (arg: IDStore) => any;
-    type TStoreCommitFunction = (name: string, payload: any) => void;
-    type TStoreSetterFunction = (arg: IDStore, payload: any) => boolean;
-    type TStoreActionFunction = (arg: IDStore & {
-        commit: TStoreCommitFunction;
-    }, payload: any) => any;
-    interface IDStore {
-        [key: string]: any;
-        getters?: Record<string, TStoreGetterFunction>;
-        setters?: Record<string, TStoreSetterFunction>;
-        actions?: Record<string, TStoreActionFunction>;
-        persist?: IDPersistConfig;
-        __persist?: DPersist;
+    interface IPersist {
+        key: string;
+        storage?: IStorage;
+        fields: string[];
+        save: (data: any) => any;
+        read: () => any;
+        handleSave: (target: IDStore, key: string) => void;
     }
-    interface DStorage {
+    interface IStorage {
         getItem?: (key: string) => string | null;
         removeItem?: (key: string) => void;
         setItem?: (key: string, value: string) => void;
@@ -52,7 +44,33 @@ export declare namespace dd {
     interface IDPersistConfig {
         key: string;
         fields: string[];
-        storage: DStorage;
+        storage: IStorage;
+    }
+    interface IDStore {
+        [key: string]: any;
+        getters?: Record<string, TStoreGetterFunction>;
+        setters?: Record<string, TStoreSetterFunction>;
+        actions?: Record<string, TStoreActionFunction>;
+        persist?: IDPersistConfig;
+        __persist?: IPersist;
+    }
+    type TStoreGetterFunction = (arg: IDStore) => any;
+    type TStoreCommitFunction = (name: string, payload: any) => void;
+    type TStoreSetterFunction = (arg: IDStore, payload: any) => boolean;
+    type TStoreActionFunction = (arg: IDStore & {
+        commit: TStoreCommitFunction;
+    }, payload: any) => any;
+}
+export declare namespace dd {
+    type Omit<T, K> = Pick<T, Exclude<keyof T, K>>;
+    /**
+     * leading 开始执行
+     * trailing 结束执行
+     */
+    interface IDebounceOption {
+        leading?: boolean;
+        maxWait?: number;
+        trailing?: boolean;
     }
     interface IHttpRequest {
         url: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ddan-js",
-  "version": "2.3.8",
+  "version": "2.4.0",
   "description": "",
   "keywords": [
     "ddan-js",