ddan-js 2.2.6 → 2.2.8

package/bin/types/index.d.ts

@@ -1,8 +1,383 @@
-import Event from "./class/event";
-import Http from "./modules/http";
-import Store from "./class/store";
-import Persist from "./class/persist";
-export { Xhao } from "./typings/xhao";
+export { Ddan } from './typings';
+import Http from './modules/http';
+import Event from './class/event';
+import Store from './class/store';
+import Persist from './class/persist';
+declare const dUtil: {
+    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>(source: T) => T;
+    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;
+    gbk: {
+        gbkLength: (str: string) => number;
+        gbkCut: (source: string, len: number) => string;
+    };
+    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, fractionDigits?: number) => number;
+        float: (num: string | number, { fractionDigits, fixed }?: {
+            fractionDigits?: number | undefined;
+            fixed?: boolean | undefined;
+        }) => number;
+        radian2degree: (radians: number) => number;
+        degree2radian: (degrees: number) => number;
+    };
+    list: {
+        stepAction: <T_1>(list: T_1[], func: import("./typings").Ddan.Task<T_1, void>, stepCount?: number) => void;
+        skip: <T_2>(list: T_2[], count: number) => T_2[];
+        take: <T_3>(list: T_3[], count: number, skip?: number) => T_3[];
+        distinct: <T_4>(list: T_4[]) => T_4[];
+        randoms: <T_5>(list: T_5[], count?: number, repeat?: boolean) => T_5[];
+        toKV: (list: import("./typings").Ddan.KV<any>[], key: string, value: string) => import("./typings").Ddan.KV<any>;
+        groupBy: <T_6>(list: T_6[], key: string) => Record<string, T_6[]>;
+        first: <T_7>(list: T_7[]) => T_7 | undefined;
+        last: <T_8>(list: T_8[]) => T_8 | undefined;
+        toList: <T_9>(val: T_9 | T_9[]) => T_9[];
+    };
+    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;
+    };
+    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;
+    };
+    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>(source: T) => T;
+        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;
+        newId: (len: number, prefix?: boolean, sep?: string) => string;
+        keyNumber: string;
+        keyLower: string;
+        keyUpper: string;
+        keyChars: string;
+    };
+    convert: {
+        uint8ArrayToString: (arr: any) => string;
+        stringToArrayBuffer: (str: any) => ArrayBuffer;
+        arrayBufferToString: (data: ArrayBuffer, base64?: boolean) => string;
+    };
+    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;
+        };
+    };
+};
+declare const dHook: {
+    sleep: (time?: number) => Promise<unknown>;
+    run: (task?: Function | Promise<any> | undefined, wait?: number) => Promise<[null, any] | [any, undefined]>;
+    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;
+    delay: (time?: number) => Promise<unknown>;
+    mutex: typeof import("./modules/hook/mutex").default;
+    to: <T = any, U extends object = any>(promise: Promise<T>, errorExt?: object | undefined) => Promise<[null, T] | [U, undefined]>;
+};
+declare const dMini: {
+    mini: {
+        diff: typeof import("./modules/mini/diff").default;
+        promixify: (miniapi: any) => any;
+        run: (func: any, args?: {}) => Promise<[null, any] | [any, undefined]>;
+        formatList: (lists: any[], start: any, name: any) => any;
+        ruleValidator: (_: any, value: any) => boolean;
+        Http: typeof import("./modules/mini/http").default;
+        setWatcher: (page: any) => void;
+    };
+    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[];
+    };
+    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) => {
+            url: string;
+            path: string;
+            page: string;
+            query: string;
+            params: {};
+        };
+        parsePath: (path: string) => {
+            root: string;
+            name: string;
+            withoutExtension: string;
+            extension: string;
+        };
+        join: (...args: string[]) => string;
+    };
+    icon: import("./class/icon").DIcon;
+    html: {
+        dataURLtoFile: (dataurl: any, filename: any) => File;
+        dataURLtoBlob: (dataurl: any) => Blob;
+        blobToFile: (theBlob: any, fileName: any) => any;
+        readAsDataURL: (file: any, cb: any) => void;
+        downloadUrl: (filename: string, url: string) => void;
+        download: (filename: string, obj: string | Blob | MediaSource) => 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;
+    };
+};
+declare const dCdn: {
+    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;
+    };
+    watermark: (bg: string, size?: {
+        width?: number | undefined;
+        height?: number | undefined;
+    } | undefined) => import("./class/watermark").DWatermark;
+};
+declare const dClass: {
+    Event: typeof Event;
+    Http: typeof Http;
+};
+declare const dStore: {
+    Store: typeof Store;
+    storeRef: (source: import("./typings").dd.IDStore, persistConfig?: import("./typings").dd.IDPersistConfig | undefined) => any;
+    Persist: typeof Persist;
+    persistConfig: (key: string, fields: string[], storage: import("./typings").dd.DStorage) => import("./typings").dd.IDPersistConfig;
+};
+declare const dJoker: import("./class/joker").Joker;
+declare const dTracker: import("./class/tracker").DTracker;
+declare const dLogger: {
+    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;
+};
+declare const dWeb: {
+    fetch: {
+        getDataURL: (url: string) => Promise<[any, undefined] | [null, {
+            contentType: string;
+            dataUrl: string;
+        }]>;
+        getArrayBuffer: (url: string) => Promise<[any, undefined] | [null, ArrayBuffer]>;
+        getJson: (url: string) => Promise<[null, any] | [any, undefined]>;
+    };
+    Http: typeof Http;
+    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[];
+    };
+    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) => {
+            url: string;
+            path: string;
+            page: string;
+            query: string;
+            params: {};
+        };
+        parsePath: (path: string) => {
+            root: string;
+            name: string;
+            withoutExtension: string;
+            extension: string;
+        };
+        join: (...args: string[]) => string;
+    };
+    icon: import("./class/icon").DIcon;
+    html: {
+        dataURLtoFile: (dataurl: any, filename: any) => File;
+        dataURLtoBlob: (dataurl: any) => Blob;
+        blobToFile: (theBlob: any, fileName: any) => any;
+        readAsDataURL: (file: any, cb: any) => void;
+        downloadUrl: (filename: string, url: string) => void;
+        download: (filename: string, obj: string | Blob | MediaSource) => 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;
+    };
+};
+export { dUtil, dHook, dWeb, dMini, dCdn, dClass, dStore, dJoker, dTracker, dLogger };
 declare const _default: {
     gbk: {
         gbkLength: (str: string) => number;
@@ -35,7 +410,7 @@ declare const _default: {
         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/xhao").Xhao.Func1<any, any> | undefined) => import("./class/pipeTask").default;
+        task: (param?: import("./typings").Ddan.Func1<any, any> | undefined) => import("./class/pipeTask").default;
         delay: (time?: number) => Promise<unknown>;
         mutex: typeof import("./modules/hook/mutex").default;
         to: <T = any, U extends object = any>(promise: Promise<T>, errorExt?: object | undefined) => Promise<[null, T] | [U, undefined]>;
@@ -94,12 +469,12 @@ declare const _default: {
         isPromise: (value: any) => boolean;
     };
     list: {
-        stepAction: <T_2>(list: T_2[], func: import("./typings/xhao").Xhao.Task<T_2, void>, stepCount?: number) => void;
+        stepAction: <T_2>(list: T_2[], func: import("./typings").Ddan.Task<T_2, void>, stepCount?: number) => void;
         skip: <T_3>(list: T_3[], count: number) => T_3[];
         take: <T_4>(list: T_4[], count: number, skip?: number) => T_4[];
         distinct: <T_5>(list: T_5[]) => T_5[];
         randoms: <T_6>(list: T_6[], count?: number, repeat?: boolean) => T_6[];
-        toKV: (list: import("./typings/xhao").Xhao.KV<any>[], key: string, value: string) => import("./typings/xhao").Xhao.KV<any>;
+        toKV: (list: import("./typings").Ddan.KV<any>[], key: string, value: string) => import("./typings").Ddan.KV<any>;
         groupBy: <T_7>(list: T_7[], key: string) => Record<string, T_7[]>;
         first: <T_8>(list: T_8[]) => T_8 | undefined;
         last: <T_9>(list: T_9[]) => T_9 | undefined;
@@ -240,10 +615,6 @@ declare const _default: {
             textAlign?: "center" | "end" | "left" | "right" | "start" | undefined;
             textBaseline?: "alphabetic" | "bottom" | "hanging" | "ideographic" | "middle" | "top" | undefined;
         }) => string;
-        fetchDataURL: (url: string) => Promise<{
-            contentType: string;
-            dataUrl: string;
-        }>;
     };
     icon: import("./class/icon").DIcon;
     rule: {
@@ -274,6 +645,7 @@ declare const _default: {
     convert: {
         uint8ArrayToString: (arr: any) => string;
         stringToArrayBuffer: (str: any) => ArrayBuffer;
+        arrayBufferToString: (data: ArrayBuffer, base64?: boolean) => string;
     };
     Event: typeof Event;
     Http: typeof Http;
@@ -298,5 +670,13 @@ declare const _default: {
             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<[null, any] | [any, undefined]>;
+    };
 };
 export default _default;

package/bin/types/modules/convert/index.d.ts

@@ -1,7 +1,9 @@
 declare function uint8ArrayToString(arr: any): string;
 declare function stringToArrayBuffer(str: any): ArrayBuffer;
+declare function arrayBufferToString(data: ArrayBuffer, base64?: boolean): string;
 declare const _default: {
     uint8ArrayToString: typeof uint8ArrayToString;
     stringToArrayBuffer: typeof stringToArrayBuffer;
+    arrayBufferToString: typeof arrayBufferToString;
 };
 export default _default;

package/bin/types/modules/fetch.d.ts

@@ -0,0 +1,9 @@
+declare const _default: {
+    getDataURL: (url: string) => Promise<[null, {
+        contentType: string;
+        dataUrl: string;
+    }] | [any, undefined]>;
+    getArrayBuffer: (url: string) => Promise<[any, undefined] | [null, ArrayBuffer]>;
+    getJson: (url: string) => Promise<[any, undefined] | [null, any]>;
+};
+export default _default;

package/bin/types/modules/hook/debounce.d.ts

@@ -1,5 +1,5 @@
 import { dd } from '../../typings';
-import { Xhao } from '../../typings/xhao';
+import { Ddan } from '../../typings';
 /**
  * 防抖 一段时间内，规定时间间隔多次执行，回调触发一次
  * @param func
@@ -7,7 +7,7 @@ import { Xhao } from '../../typings/xhao';
  * @param options 参数：leading 开始执行， trailing结束执行
  * @returns
  */
-declare function debounce(func: Xhao.Action, wait?: number, options?: dd.IDebounceOption): {
+declare function debounce(func: Ddan.Action, wait?: number, options?: dd.IDebounceOption): {
     (...debouncedArgs: any[]): any;
     cancel: () => void;
     flush: () => any;

package/bin/types/modules/hook/index.d.ts

@@ -2,14 +2,14 @@ import debounce from "./debounce";
 import throttle from "./throttle";
 import mutex from "./mutex";
 import DPipeTask from "../../class/pipeTask";
-import { Xhao } from "../../typings/xhao";
+import { Ddan } from "../../typings";
 declare const _default: {
     sleep: (time?: number) => Promise<unknown>;
     run: (task?: Function | Promise<any> | undefined, wait?: number) => Promise<[null, any] | [any, undefined]>;
     exec: (func: Function, taskId?: string) => Promise<any[]>;
     debounce: typeof debounce;
     throttle: typeof throttle;
-    task: (param?: Xhao.Func1<any, any> | undefined) => DPipeTask;
+    task: (param?: Ddan.Func1<any, any> | undefined) => DPipeTask;
     delay: (time?: number) => Promise<unknown>;
     mutex: typeof mutex;
     to: <T = any, U extends object = any>(promise: Promise<T>, errorExt?: object | undefined) => Promise<[null, T] | [U, undefined]>;

package/bin/types/modules/hook/mutex.d.ts

@@ -1,3 +1,3 @@
-import { Xhao } from "../../typings/xhao";
-declare function mutex(func: Xhao.Action): (...args: any[]) => Promise<false | undefined>;
+import { Ddan } from "../../typings";
+declare function mutex(func: Ddan.Action): (...args: any[]) => Promise<false | undefined>;
 export default mutex;

package/bin/types/modules/hook/throttle.d.ts

@@ -1,5 +1,5 @@
 import { dd } from "../../typings";
-import { Xhao } from "../../typings/xhao";
+import { Ddan } from "../../typings";
 /**
  * 节流 每个间隔内，触发一次
  * @param func
@@ -7,7 +7,7 @@ import { Xhao } from "../../typings/xhao";
  * @param options 参数：leading 开始执行， trailing结束执行
  * @returns
  */
-declare function throttle(func: Xhao.Action, wait?: number, options?: Omit<dd.IDebounceOption, 'maxWait'>): {
+declare function throttle(func: Ddan.Action, wait?: number, options?: Omit<dd.IDebounceOption, 'maxWait'>): {
     (...debouncedArgs: any[]): any;
     cancel: () => void;
     flush: () => any;

package/bin/types/modules/html.d.ts

@@ -15,9 +15,5 @@ declare const _default: {
         textAlign?: "center" | "end" | "left" | "right" | "start" | undefined;
         textBaseline?: "alphabetic" | "bottom" | "hanging" | "ideographic" | "middle" | "top" | undefined;
     }) => string;
-    fetchDataURL: (url: string) => Promise<{
-        contentType: string;
-        dataUrl: string;
-    }>;
 };
 export default _default;

package/bin/types/modules/http/index.d.ts

@@ -1,6 +1,6 @@
 import Interceptor from "./interceptor";
 import { dd } from "../../typings";
-import { Xhao } from "../../typings/xhao";
+import { Ddan } from "../../typings";
 export default class Http implements dd.IHttp {
     host: string;
     reqConfig: {};
@@ -33,5 +33,5 @@ export default class Http implements dd.IHttp {
      * @param {object} req
      */
     getIdFromReqUrl(req: any): any;
-    fetch(name: string, payload?: Xhao.KV): Promise<any>;
+    fetch(name: string, payload?: Ddan.KV): Promise<any>;
 }

package/bin/types/modules/list/index.d.ts

@@ -1,4 +1,4 @@
-import { Xhao } from "../../typings/xhao";
+import { Ddan } from "../../typings";
 /**
  * 分步动作
  * @param list 列表
@@ -6,7 +6,7 @@ import { Xhao } from "../../typings/xhao";
  * @param stepCount 每步数量
  * @returns
  */
-declare function stepAction<T>(list: T[], func: Xhao.Task<T>, stepCount?: number): void;
+declare function stepAction<T>(list: T[], func: Ddan.Task<T>, stepCount?: number): void;
 /**
  * 跳过数据
  * @param list 列表
@@ -35,7 +35,7 @@ declare const _default: {
     take: typeof take;
     distinct: typeof distinct;
     randoms: typeof randoms;
-    toKV: (list: Xhao.KV<any>[], key: string, value: string) => Xhao.KV<any>;
+    toKV: (list: Ddan.KV<any>[], key: string, value: string) => Ddan.KV<any>;
     groupBy: <T>(list: T[], key: string) => Record<string, T[]>;
     first: <T_1>(list: T_1[]) => T_1 | undefined;
     last: <T_2>(list: T_2[]) => T_2 | undefined;

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

@@ -1,5 +1,21 @@
 import DPersist from "../class/persist";
-import { Xhao } from "./xhao";
+export declare namespace Ddan {
+    type KV<T = any> = Record<string, T>;
+    type KeyValueOjbect<T = any> = {
+        key: string;
+        value: T;
+    };
+    type KeyValue<T = any> = Required<KeyValueOjbect<T>>;
+    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>;
+    type Func<R = any> = Callback<[], R>;
+    type Func1<T = any, R = any> = Callback<[T], R>;
+    type Func2<T0 = any, T1 = any, R = any> = Callback<[T0, T1], R>;
+    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>>;
     /**
@@ -46,14 +62,14 @@ export declare namespace dd {
     interface IHttpApiConfig {
         [key: string]: IHttpRequestInit;
     }
-    type ResponseInterceptFunc = Xhao.Func1<IHttpResponse>;
-    type RequestInterceptFunc = Xhao.Func1<IHttpRequest, IHttpRequest>;
+    type ResponseInterceptFunc = Ddan.Func1<IHttpResponse>;
+    type RequestInterceptFunc = Ddan.Func1<IHttpRequest, IHttpRequest>;
     interface IHttpConfig {
         host?: string;
         config: IHttpApiConfig;
         handleRequest?: RequestInterceptFunc | RequestInterceptFunc[];
         handleResponse?: ResponseInterceptFunc | ResponseInterceptFunc[];
-        handleError?: Xhao.Func1;
+        handleError?: Ddan.Func1;
     }
     interface IHttpRequestInit extends RequestInit {
         [key: string]: any;
@@ -74,7 +90,7 @@ export declare namespace dd {
     }
     interface IHttpResponse {
         response: Response & Record<string, any>;
-        config?: Xhao.KV;
+        config?: Ddan.KV;
         refetch: () => Promise<any>;
     }
     interface IMiniHttpOptions {

package/package.json

@@ -1,8 +1,22 @@
 {
   "name": "ddan-js",
-  "version": "2.2.6",
+  "version": "2.2.8",
   "description": "",
-  "keywords": [],
+  "keywords": [
+    "ddan-js",
+    "ddan",
+    "Ddan",
+    "dUtil",
+    "dHook",
+    "dWeb",
+    "dMini",
+    "dCdn",
+    "dClass",
+    "dStore",
+    "dJoker",
+    "dTracker",
+    "dLogger"
+  ],
   "main": "bin/ddan-js.js",
   "module": "bin/ddan-js.esm.js",
   "typings": "bin/types/index.d.ts",

package/bin/lib/typings/xhao.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });