ddan-js 2.9.14 → 2.9.15

package/bin/hook.d.ts

@@ -0,0 +1,185 @@
+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[];
+};
+export default dHook;

package/bin/store.d.ts

@@ -0,0 +1,9 @@
+import Store from '../class/store';
+import Persist from '../class/persist';
+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;
+};
+export default dStore;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ddan-js",
-  "version": "2.9.14",
+  "version": "2.9.15",
   "description": "",
   "keywords": [
     "ddan-js",
@@ -35,18 +35,18 @@
     },
     "./hook": {
       "types": "./bin/hook.d.ts",
-      "import": "./bin/tiny/t-hook.mjs",
-      "require": "./bin/tiny/t-hook.js"
+      "import": "./bin/tiny/hook.mjs",
+      "require": "./bin/tiny/hook.js"
     },
     "./utils": {
       "types": "./bin/utils.d.ts",
-      "import": "./bin/tiny/t-utils.mjs",
-      "require": "./bin/tiny/t-utils.js"
+      "import": "./bin/tiny/utils.mjs",
+      "require": "./bin/tiny/utils.js"
     },
     "./web": {
       "types": "./bin/web.d.ts",
-      "import": "./bin/tiny/t-web.mjs",
-      "require": "./bin/tiny/t-web.js"
+      "import": "./bin/tiny/web.mjs",
+      "require": "./bin/tiny/web.js"
     },
     "./*": "./*"
   },