ddan-js 2.10.2 → 2.10.4

package/bin/index.d.ts

@@ -5,6 +5,7 @@ import Store from './class/store';
 import Persist from './class/persist';
 import KValue from './class/kvalue';
 import Mapping from './class/mapping';
+import dHook from './tiny/hook';
 declare const dUtil: {
     Event: typeof Event;
     includes: typeof import("./util/includes").default;
@@ -236,206 +237,6 @@ declare const dUtil: {
         };
     };
 };
-declare const dHook: {
-    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("./typings").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: {};
-        };
-    };
-    singleton: <T>() => {
-        new (): {};
-        __instance__: any;
-        readonly Instance: T;
-        readonly I: T;
-    };
-    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;
-    };
-    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").Ddan.IRegexRule | import("./typings").Ddan.IRegexRule[]) => string;
-    jsonFormat: (jsonString: string) => string;
-    toLines: (content: string, separator?: string | RegExp) => string[];
-    sleep: (ms?: number) => Promise<unknown>;
-    run: <T_1 = any>(task?: import("./typings").Ddan.PFunction<T_1> | undefined, wait?: number) => Promise<[any, undefined] | [null, T_1]>;
-    exec: (func: import("./typings").Ddan.Function, taskId?: string) => import("./typings").Ddan.PSafeResult<any>;
-    debounce: typeof import("./modules/hook/modules/debounce").default;
-    throttle: typeof import("./modules/hook/modules/throttle").default;
-    task: (param?: import("./typings").Ddan.Func1<any, any> | undefined) => import("./class/pipeTask").default;
-    mutex: typeof import("./modules/hook/modules/mutex").default;
-    polling: typeof import("./modules/hook/modules/polling").default;
-    pipe: (func: import("./typings").Ddan.Function, callback?: ((result: import("./typings").Ddan.SafeResult<any>) => void) | undefined) => import("./modules/hook/modules/pipeline").default;
-    pipeline: (max?: number) => import("./modules/hook/modules/pipeline").default;
-    safeTask: (func: import("./typings").Ddan.Function, callback?: ((result: import("./typings").Ddan.SafeResult<any>) => void) | undefined) => import("./modules/hook/modules/safeTask").default;
-    bezier1: (p0: import("./typings").Ddan.IPoint, p1: import("./typings").Ddan.IPoint, t: number) => import("./typings").Ddan.IPoint;
-    bezier2: (p0: import("./typings").Ddan.IPoint, p1: import("./typings").Ddan.IPoint, p2: import("./typings").Ddan.IPoint, t: number) => import("./typings").Ddan.IPoint;
-    bezier3: (p0: import("./typings").Ddan.IPoint, p1: import("./typings").Ddan.IPoint, p2: import("./typings").Ddan.IPoint, p3: import("./typings").Ddan.IPoint, t: number) => import("./typings").Ddan.IPoint;
-    bezier: (points: import("./typings").Ddan.IPoint[], t: number) => import("./typings").Ddan.IPoint;
-    bezierCurve: (points: import("./typings").Ddan.IPoint[], t: number) => import("./typings").Ddan.IPoint;
-    lerpAverage: (points: import("./typings").Ddan.IPoint[], step: number, type?: "" | "lerp") => number;
-    proportion: (start: number, end: number, current: number) => number;
-    logString: (data: any) => string;
-    logParse: (logStr: string) => string;
-    logRString: (data: any) => Promise<string>;
-    logRParse: (logStr: string) => Promise<string>;
-    to: <T_2 = any, U extends object = any>(promise: Promise<T_2>, errorExt?: object | undefined, fn?: import("./typings").Ddan.noop | undefined) => Promise<[null, T_2] | [U, undefined]>;
-    go: <T_3 = any>(task?: import("./typings").Ddan.PFunction<T_3> | undefined, fn?: import("./typings").Ddan.noop | undefined) => Promise<[any, undefined] | [null, T_3]>;
-    delay: (ms?: number) => Promise<unknown>;
-    safeRun: <T_4 = any>(func: any, fn?: import("./typings").Ddan.noop | undefined) => Promise<[any, undefined] | [null, T_4]>;
-    toError: (value: any) => any;
-    timeout: <T_5 = any>(task?: import("./typings").Ddan.PFunction<T_5> | undefined, ms?: number, desc?: string) => Promise<[any, undefined] | [null, T_5]>;
-    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_6>(data: T_6[], recursive?: boolean, list?: T_6[]) => T_6[];
-    copy: (source: any, options?: {
-        fields?: string[] | undefined;
-        camel?: boolean | undefined;
-        pure?: boolean | undefined;
-        ignoreNull?: boolean | undefined;
-        ignoreZero?: boolean | undefined;
-        ignoreEmptyArray?: boolean | undefined;
-        ignoreEmptyString?: boolean | undefined;
-    }) => any;
-    clone: (source: any, weakMap?: WeakMap<object, any>) => any;
-    cloneClass: <T_7>(source: T_7) => T_7;
-    isEqual: <T_8 = any>(value: T_8, other: T_8, depth?: number) => boolean;
-    isEqualArray: (value: any[], other: any[], depth?: number) => boolean;
-    isEqualObject: (value: Record<string, any>, other: Record<string, any>, depth?: number) => boolean;
-    isEqualValue: <T_9>(value: T_9, other: T_9, type: string) => boolean;
-    isEqualAB: (value: ArrayBuffer, other: ArrayBuffer) => boolean;
-    isEqualDeep: <T_10>(value: T_10, other: T_10) => boolean;
-};
 declare const dMini: {
     mini: {
         diff: typeof import("./modules/mini/diff").default;

package/bin/tiny/hook.d.ts

@@ -0,0 +1,202 @@
+declare const dHook: {
+    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: {};
+        };
+    };
+    singleton: <T>() => {
+        new (): {};
+        __instance__: any;
+        readonly Instance: T;
+        readonly I: T;
+    };
+    getset: <T_1 = any>(t?: T_1 | undefined) => import("..").Ddan.IGetset<T_1>;
+    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;
+    };
+    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[];
+    sleep: (ms?: number) => Promise<unknown>;
+    run: <T_2 = any>(task?: import("..").Ddan.PFunction<T_2> | undefined, wait?: number) => Promise<[any, undefined] | [null, T_2]>;
+    exec: (func: import("..").Ddan.Function, taskId?: string) => import("..").Ddan.PSafeResult<any>;
+    debounce: typeof import("../modules/hook/modules/debounce").default;
+    throttle: typeof import("../modules/hook/modules/throttle").default;
+    task: (param?: import("..").Ddan.Func1<any, any> | undefined) => import("../class/pipeTask").default;
+    mutex: typeof import("../modules/hook/modules/mutex").default;
+    polling: typeof import("../modules/hook/modules/polling").default;
+    pipe: (func: import("..").Ddan.Function, callback?: ((result: import("..").Ddan.SafeResult<any>) => void) | undefined) => import("../modules/hook/modules/pipeline").default;
+    pipeline: (max?: number) => import("../modules/hook/modules/pipeline").default;
+    safeTask: (func: import("..").Ddan.Function, callback?: ((result: import("..").Ddan.SafeResult<any>) => void) | undefined) => import("../modules/hook/modules/safeTask").default;
+    bezier1: (p0: import("..").Ddan.IPoint, p1: import("..").Ddan.IPoint, t: number) => import("..").Ddan.IPoint;
+    bezier2: (p0: import("..").Ddan.IPoint, p1: import("..").Ddan.IPoint, p2: import("..").Ddan.IPoint, t: number) => import("..").Ddan.IPoint;
+    bezier3: (p0: import("..").Ddan.IPoint, p1: import("..").Ddan.IPoint, p2: import("..").Ddan.IPoint, p3: import("..").Ddan.IPoint, t: number) => import("..").Ddan.IPoint;
+    bezier: (points: import("..").Ddan.IPoint[], t: number) => import("..").Ddan.IPoint;
+    bezierCurve: (points: import("..").Ddan.IPoint[], t: number) => import("..").Ddan.IPoint;
+    lerpAverage: (points: import("..").Ddan.IPoint[], step: number, type?: "" | "lerp") => number;
+    proportion: (start: number, end: number, current: number) => number;
+    logString: (data: any) => string;
+    logParse: (logStr: string) => string;
+    logRString: (data: any) => Promise<string>;
+    logRParse: (logStr: string) => Promise<string>;
+    to: <T_3 = any, U extends object = any>(promise: Promise<T_3>, errorExt?: object | undefined, fn?: import("..").Ddan.noop | undefined) => Promise<[null, T_3] | [U, undefined]>;
+    go: <T_4 = any>(task?: import("..").Ddan.PFunction<T_4> | undefined, fn?: import("..").Ddan.noop | undefined) => Promise<[any, undefined] | [null, T_4]>;
+    delay: (ms?: number) => Promise<unknown>;
+    safeRun: <T_5 = any>(func: any, fn?: import("..").Ddan.noop | undefined) => Promise<[any, undefined] | [null, T_5]>;
+    toError: (value: any) => any;
+    timeout: <T_6 = any>(task?: import("..").Ddan.PFunction<T_6> | undefined, ms?: number, desc?: string) => Promise<[any, undefined] | [null, T_6]>;
+    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_7>(data: T_7[], recursive?: boolean, list?: T_7[]) => T_7[];
+    copy: (source: any, options?: {
+        fields?: string[] | undefined;
+        camel?: boolean | undefined;
+        pure?: boolean | undefined;
+        ignoreNull?: boolean | undefined;
+        ignoreZero?: boolean | undefined;
+        ignoreEmptyArray?: boolean | undefined;
+        ignoreEmptyString?: boolean | undefined;
+    }) => any;
+    clone: (source: any, weakMap?: WeakMap<object, any>) => any;
+    cloneClass: <T_8>(source: T_8) => T_8;
+    isEqual: <T_9 = any>(value: T_9, other: T_9, depth?: number) => boolean;
+    isEqualArray: (value: any[], other: any[], depth?: number) => boolean;
+    isEqualObject: (value: Record<string, any>, other: Record<string, any>, depth?: number) => boolean;
+    isEqualValue: <T_10>(value: T_10, other: T_10, type: string) => boolean;
+    isEqualAB: (value: ArrayBuffer, other: ArrayBuffer) => boolean;
+    isEqualDeep: <T_11>(value: T_11, other: T_11) => boolean;
+};
+export default dHook;

package/package.json

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