ddan-js 2.10.4 → 2.10.6

package/bin/tiny/node.d.ts

@@ -0,0 +1,37 @@
+declare const dNode: {
+    Ecdh: typeof import("../modules/node/ecdh").default;
+    EcdhWeb: typeof import("../modules/node/ecdh-web").default;
+    Socks5: typeof import("../modules/node/socks5").Socks5;
+    rsa: {
+        generateKeys: () => Promise<{
+            publicKey: string;
+            publicKeyPem: string;
+            privateKey: string;
+            privateKeyPem: string;
+        }>;
+        encrypt: (data: string, publicKey: string) => Promise<string>;
+        decrypt: (encryptedBase64: string, privateKey: string) => Promise<string>;
+        encode: (data: string) => Promise<string>;
+        decode: (encryptedBase64: string) => Promise<string>;
+    };
+    getSystemProxy: () => Promise<{
+        ipaddress: string;
+        port: number;
+    } | undefined> | undefined;
+    toPacScript: (proxy: string, rules?: string[], defaultProxy?: string) => string;
+    toPacProxy: (ipaddress: string, port: number, options?: {
+        type?: "PROXY" | "SOCKS5" | "ALL" | undefined;
+        direct?: boolean | undefined;
+    } | undefined) => string;
+    pacScript: (host: string, port: number, options?: {
+        rules?: string[] | undefined;
+        type?: "PROXY" | "SOCKS5" | "ALL" | undefined;
+        useSystem?: boolean | undefined;
+    } | undefined) => Promise<string>;
+    child_exec: (cmd: string) => Promise<[any, string]>;
+    brotliCompress: typeof import("../modules/node/brotli").brotliCompress;
+    brotliDecompress: typeof import("../modules/node/brotli").brotliDecompress;
+    readDirectory: (dir: string, callback?: import("..").Ddan.Func1<string, any> | undefined) => Promise<unknown>;
+    readFiles: (dir: string, files: string[], callback?: import("..").Ddan.Func1<string, any> | undefined) => Promise<void>;
+};
+export default dNode;

package/bin/tiny/tools.d.ts

@@ -0,0 +1,45 @@
+import Store from '../class/store';
+import Persist from '../class/persist';
+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;
+        ossBase64: (input: string) => string;
+    };
+    watermark: (bg: string, size?: {
+        width?: number | undefined;
+        height?: number | undefined;
+    } | undefined) => import("../class/watermark").DWatermark;
+};
+declare const dStore: {
+    Store: typeof Store;
+    storeRef: (source: import("..").Ddan.IDStore, persistConfig?: import("..").Ddan.IDPersistConfig | undefined) => any;
+    Persist: typeof Persist;
+    persistConfig: (key: string, fields: string[], storage: import("..").Ddan.IStorage) => import("..").Ddan.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;
+};
+export { dCdn, dStore, dJoker, dTracker, dLogger };

package/bin/tiny/utils.d.ts

@@ -0,0 +1,233 @@
+import Event from '../class/event';
+declare const dUtil: {
+    Event: typeof Event;
+    includes: typeof import("../util/includes").default;
+    forof: (source: any, cb: (key: any, val: any) => void) => void;
+    singleton: <T>() => {
+        new (): {};
+        __instance__: any;
+        readonly Instance: T;
+        readonly I: T;
+    };
+    getset: <T_1 = any>(t?: T_1 | undefined) => import("..").Ddan.IGetset<T_1>;
+    copy: (source: any, options?: {
+        fields?: string[] | undefined;
+        camel?: boolean | undefined;
+        pure?: boolean | undefined;
+    } & import("..").Ddan.IIgnoreParams) => any;
+    clone: (source: any) => any;
+    merge: (target: any, source: any, options?: import("..").Ddan.IIgnoreParams) => {};
+    isEmpty: (source: any) => boolean;
+    parseValue: (source: any, { number, boolean }?: {
+        number?: boolean | undefined;
+        boolean?: boolean | undefined;
+    }) => any;
+    cloneClass: <T_2>(source: T_2) => T_2;
+    combine: (target: any, source: any, options?: import("..").Ddan.IIgnoreParams) => any;
+    combines: (objs: any[], options?: import("..").Ddan.IIgnoreParams) => {};
+    observe: (obj: any, key: any, watchFun: any, owner: any, deep?: boolean) => void;
+    find: (obj: any, cb: (k: string, v: any) => boolean) => [string, unknown] | undefined;
+    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;
+    isBrowser: boolean;
+    isNode: boolean;
+    isBlobOrBuffer: (data: any) => boolean;
+    isUint8Array: (data: any) => boolean;
+    isArrayBuffer: (data: any) => boolean;
+    base64: {
+        encode: (input: string) => string;
+        decode: (base64Str: string) => string;
+        encodeByOss: (input: string) => string;
+    };
+    tea: {
+        TEAKey: string;
+        encrypt: (v: Uint32Array, teaKey: Uint32Array) => Uint32Array;
+        decrypt: (v: Uint32Array, teaKey: Uint32Array) => Uint32Array;
+        toTeaKey: (str: string) => Uint32Array;
+        encode: (plaintext: string, key: string) => string;
+        decode: (ciphertext: string, key: string) => string;
+        encodeBytes: (plainbytes: Uint8Array, key: string) => Uint8Array;
+        decodeBytes: (cipherbytes: Uint8Array, key: string) => Uint8Array;
+    };
+    uuid: (len?: number, radix?: number) => string;
+    guid: (len: number, prefix?: boolean, sep?: string) => string;
+    getHexString: (len: number) => string;
+    keyNumber: string;
+    keyLower: string;
+    keyUpper: string;
+    keyChars: string;
+    str2ab: (content?: string, base64?: boolean) => ArrayBuffer;
+    ab2str: (data: ArrayBuffer, base64?: boolean) => string;
+    utf8ToBase64: (str: string) => string;
+    base64ToUtf8: (base64Str: string) => string;
+    getRandomBytes: (length: number) => Uint8Array;
+    textEncode: (text: string) => Uint8Array;
+    textDecode: (buf: ArrayBufferLike) => string;
+    toDataUrl: (textOrBuf: string | ArrayBuffer, contentType?: string) => string;
+    md5: (input: string | Uint8Array) => string;
+    md5Base64: (input: string | Uint8Array) => string;
+    toBase64: (input?: string) => string;
+    fromBase64: (input?: string) => string;
+    bytesToBase64: (bytes: Uint8Array) => string;
+    base64ToBytes: (input?: string) => Uint8Array;
+    toUtf8: (content: string) => string;
+    fromUtf8: (utftext: string) => string;
+    toUtf8Bytes: (content: string) => Uint8Array;
+    fromUtf8Bytes: (utf8Bytes: Uint8Array) => string;
+    pkcs7Padding: (plaintext: Uint8Array, blockSize: number) => Uint8Array;
+    pkcs7Unpadding: (ciphertext: Uint8Array) => Uint8Array;
+    bytes2str: (bytes: Uint8Array) => string;
+    str2bytes: (str?: string) => Uint8Array;
+    str2hex: (str: string) => string;
+    hex2str: (hexstr: string) => string;
+    concatBytes: (...args: Uint8Array[]) => Uint8Array;
+    uint32ToBytes: (uint32: Uint32Array) => Uint8Array;
+    bytesToUint32: (bytes: Uint8Array) => Uint32Array;
+    hex2bytes: (hex: string) => Uint8Array;
+    bytes2hex: (bytes: Uint8Array) => string;
+    toUint32: (str: string) => Uint32Array;
+    fromUint32: (uint32: Uint32Array) => string;
+    flatten: <T_3>(data: T_3[], recursive?: boolean, list?: T_3[]) => T_3[];
+    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, digits?: number) => number;
+        float: (num: string | number, { digits, fixed }?: {
+            digits?: number | undefined;
+            fixed?: boolean | undefined;
+        }) => number;
+        radian2degree: (radians: number) => number;
+        degree2radian: (degrees: number) => number;
+        calcDataSize: (data: number) => {
+            gb: number;
+            mb: number;
+            kb: number;
+            b: number;
+            total: number;
+            desc: string;
+        };
+    };
+    list: {
+        stepAction: <T_4>(list: T_4[], func: import("..").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("..").Ddan.KV<any>[], key: string, value: string) => import("..").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("..").Ddan.IRegexRule | import("..").Ddan.IRegexRule[]) => string;
+        jsonFormat: (jsonString: string) => string;
+        toLines: (content: string, separator?: string | RegExp) => 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("..").Ddan.ICountdown;
+        dtime: (time: string | number | Date) => import("../modules/time/dtime").default;
+        loopFrame: (interval?: number) => import("../modules/time/frame").default;
+        getTimezoneOffset: () => number;
+        getLocalTime: typeof import("../modules/time/dtime").default.getLocalTime;
+        oneDay: number;
+        oneHour: number;
+        oneMinute: number;
+        oneSecond: number;
+    };
+    obj: {
+        copy: (source: any, options?: {
+            fields?: string[] | undefined;
+            camel?: boolean | undefined;
+            pure?: boolean | undefined;
+        } & import("..").Ddan.IIgnoreParams) => any;
+        clone: (source: any) => any;
+        merge: (target: any, source: any, options?: import("..").Ddan.IIgnoreParams) => {};
+        isEmpty: (source: any) => boolean;
+        parseValue: (source: any, { number, boolean }?: {
+            number?: boolean | undefined;
+            boolean?: boolean | undefined;
+        }) => any;
+        cloneClass: <T_2>(source: T_2) => T_2;
+        combine: (target: any, source: any, options?: import("..").Ddan.IIgnoreParams) => any;
+        combines: (objs: any[], options?: import("..").Ddan.IIgnoreParams) => {};
+        observe: (obj: any, key: any, watchFun: any, owner: any, deep?: boolean) => void;
+        find: (obj: any, cb: (k: string, v: any) => boolean) => [string, unknown] | undefined;
+    };
+    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;
+        };
+    };
+};
+export default dUtil;

package/bin/tiny/web.d.ts

@@ -0,0 +1,127 @@
+import Http from '../modules/http';
+declare const dWeb: {
+    Ecdh: typeof import("../modules/browser/ecdh").default;
+    fetch: {
+        getDataURL: (url: string, cache?: RequestCache | undefined) => Promise<[null, {
+            contentType: string;
+            dataUrl: string;
+        }] | [any, undefined]>;
+        getArrayBuffer: (url: string, cache?: RequestCache | undefined) => Promise<[any, undefined] | [null, ArrayBuffer]>;
+        getJson: (url: string, cache?: RequestCache | undefined) => 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>;
+        getText: (url: string, cache?: RequestCache | undefined) => Promise<[any, undefined] | [null, string]>;
+        cache: (url: string, cache?: RequestCache) => Promise<[any, undefined] | [null, boolean]>;
+    };
+    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) => {
+            pathname: string;
+            params: {};
+            route: string;
+            page: string;
+            name: string;
+            withoutExtension: string;
+            extname: string;
+            href: string;
+            url: string;
+            origin: string;
+            host: string;
+            protocol: string;
+            port: string;
+            query: string;
+        };
+        parsePath: (url: string) => {
+            route: string;
+            page: string;
+            name: string;
+            withoutExtension: string;
+            extname: string;
+        };
+        parseHost: (url: string) => import("..").Ddan.IHttpHost;
+        join: (...args: string[]) => string;
+        shExpMatch: (text: string, pattern: string) => boolean;
+        isLocalIpAddress: (addr: string) => boolean;
+        parseFileUrl: (url: string) => {
+            href: string;
+            file: string;
+            url: string;
+            protocol: string;
+            host: string;
+            query: string;
+            params: {};
+        };
+    };
+    icon: import("../class/icon").DIcon;
+    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;
+        copyText: (text: string, legacy?: boolean) => Promise<boolean>;
+        queryPermission: (name: string, def?: PermissionState) => Promise<PermissionState>;
+        isAllowed: (status: PermissionState | undefined, prompt?: boolean) => boolean;
+        legacyCopy: (text: string) => boolean;
+        takeHtmlLinks: (htmlContent: string) => never[];
+        takeHtml: (htmlContent: string, regex: RegExp) => string[];
+        toBlobUrl: (part: BlobPart, mime: "application/javascript") => string;
+    };
+    rsa: {
+        generateKeys: () => Promise<{
+            publicKey: string;
+            publicKeyPem: string;
+            privateKey: string;
+            privateKeyPem: string;
+        }>;
+        encrypt: (data: string, publicKey: string) => Promise<string>;
+        decrypt: (encryptedBase64: string, privateKey: string) => Promise<string>;
+        encode: (data: string) => Promise<string>;
+        decode: (encryptedBase64: string) => Promise<string>;
+    };
+};
+export default dWeb;

package/package.json

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