ddan-js 2.4.1 → 2.4.3

package/bin/types/index.d.ts

@@ -11,17 +11,17 @@ declare const dUtil: {
         fields?: string[] | undefined;
         camel?: boolean | undefined;
         pure?: boolean | undefined;
-    } & import("./typings").dd.IIgnoreParams) => any;
+    } & import("./typings").Ddan.IIgnoreParams) => any;
     clone: (source: any) => any;
-    merge: (target: any, source: any, options?: import("./typings").dd.IIgnoreParams) => {};
+    merge: (target: any, source: any, options?: import("./typings").Ddan.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) => {};
+    combine: (target: any, source: any, options?: import("./typings").Ddan.IIgnoreParams) => any;
+    combines: (objs: any[], options?: import("./typings").Ddan.IIgnoreParams) => {};
     observe: (obj: any, key: any, watchFun: any, owner: any, deep?: boolean) => void;
     getTag: (value: any) => string;
     getType: (value: any) => string;
@@ -94,7 +94,7 @@ declare const dUtil: {
             number?: boolean | undefined;
             boolean?: boolean | undefined;
         }) => any;
-        replace: (source: string, rules: import("./typings").dd.IRegexRule | import("./typings").dd.IRegexRule[]) => string;
+        replace: (source: string, rules: import("./typings").Ddan.IRegexRule | import("./typings").Ddan.IRegexRule[]) => string;
     };
     time: {
         now: () => import("./modules/time/dtime").default;
@@ -109,7 +109,7 @@ declare const dUtil: {
         }) => number;
         todayZero: () => number;
         format: (time: string | number | Date, reg?: string) => string;
-        countdown: (endTime: string | number | Date, reg?: string) => "" | import("./modules/time/dtime").IDCountdownFormat;
+        countdown: (endTime: string | number | Date, reg?: string) => "" | import("./typings").Ddan.ICountdown;
         dtime: (time: string | number | Date) => import("./modules/time/dtime").default;
         loopFrame: (interval?: number) => import("./modules/time/frame").default;
         oneDay: number;
@@ -122,17 +122,17 @@ declare const dUtil: {
             fields?: string[] | undefined;
             camel?: boolean | undefined;
             pure?: boolean | undefined;
-        } & import("./typings").dd.IIgnoreParams) => any;
+        } & import("./typings").Ddan.IIgnoreParams) => any;
         clone: (source: any) => any;
-        merge: (target: any, source: any, options?: import("./typings").dd.IIgnoreParams) => {};
+        merge: (target: any, source: any, options?: import("./typings").Ddan.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) => {};
+        combine: (target: any, source: any, options?: import("./typings").Ddan.IIgnoreParams) => any;
+        combines: (objs: any[], options?: import("./typings").Ddan.IIgnoreParams) => {};
         observe: (obj: any, key: any, watchFun: any, owner: any, deep?: boolean) => void;
     };
     crypto: {
@@ -187,12 +187,7 @@ declare const dHook: {
     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]>;
+    to: <T_1 = any, U extends object = any>(promise: Promise<T_1>, errorExt?: object | undefined) => Promise<[null, T_1] | [U, undefined]>;
     delay: (time?: number) => Promise<unknown>;
 };
 declare const dMini: {
@@ -424,7 +419,7 @@ declare const _default: {
         }) => number;
         todayZero: () => number;
         format: (time: string | number | Date, reg?: string) => string;
-        countdown: (endTime: string | number | Date, reg?: string) => "" | import("./modules/time/dtime").IDCountdownFormat;
+        countdown: (endTime: string | number | Date, reg?: string) => "" | import("./typings").Ddan.ICountdown;
         dtime: (time: string | number | Date) => import("./modules/time/dtime").default;
         loopFrame: (interval?: number) => import("./modules/time/frame").default;
         oneDay: number;
@@ -440,12 +435,7 @@ declare const _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]>;
+        to: <T_1 = any, U extends object = any>(promise: Promise<T_1>, errorExt?: object | undefined) => Promise<[null, T_1] | [U, undefined]>;
         delay: (time?: number) => Promise<unknown>;
     };
     math: {
@@ -475,17 +465,17 @@ declare const _default: {
             fields?: string[] | undefined;
             camel?: boolean | undefined;
             pure?: boolean | undefined;
-        } & import("./typings").dd.IIgnoreParams) => any;
+        } & import("./typings").Ddan.IIgnoreParams) => any;
         clone: (source: any) => any;
-        merge: (target: any, source: any, options?: import("./typings").dd.IIgnoreParams) => {};
+        merge: (target: any, source: any, options?: import("./typings").Ddan.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) => {};
+        cloneClass: <T_2>(source: T_2) => T_2;
+        combine: (target: any, source: any, options?: import("./typings").Ddan.IIgnoreParams) => any;
+        combines: (objs: any[], options?: import("./typings").Ddan.IIgnoreParams) => {};
         observe: (obj: any, key: any, watchFun: any, owner: any, deep?: boolean) => void;
         getTag: (value: any) => string;
         getType: (value: any) => string;
@@ -509,16 +499,16 @@ declare const _default: {
         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[];
+        stepAction: <T_3>(list: T_3[], func: import("./typings").Ddan.Task<T_3, void>, stepCount?: number) => void;
+        skip: <T_4>(list: T_4[], count: number) => T_4[];
+        take: <T_5>(list: T_5[], count: number, skip?: number) => T_5[];
+        distinct: <T_6>(list: T_6[]) => T_6[];
+        randoms: <T_7>(list: T_7[], count?: number, repeat?: boolean) => T_7[];
         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[];
+        groupBy: <T_8>(list: T_8[], key: string) => Record<string, T_8[]>;
+        first: <T_9>(list: T_9[]) => T_9 | undefined;
+        last: <T_10>(list: T_10[]) => T_10 | undefined;
+        toList: <T_11>(val: T_11 | T_11[]) => T_11[];
     };
     string: {
         toString: (value: any) => any;
@@ -535,24 +525,24 @@ declare const _default: {
             number?: boolean | undefined;
             boolean?: boolean | undefined;
         }) => any;
-        replace: (source: string, rules: import("./typings").dd.IRegexRule | import("./typings").dd.IRegexRule[]) => string;
+        replace: (source: string, rules: import("./typings").Ddan.IRegexRule | import("./typings").Ddan.IRegexRule[]) => string;
     };
     obj: {
         copy: (source: any, options?: {
             fields?: string[] | undefined;
             camel?: boolean | undefined;
             pure?: boolean | undefined;
-        } & import("./typings").dd.IIgnoreParams) => any;
+        } & import("./typings").Ddan.IIgnoreParams) => any;
         clone: (source: any) => any;
-        merge: (target: any, source: any, options?: import("./typings").dd.IIgnoreParams) => {};
+        merge: (target: any, source: any, options?: import("./typings").Ddan.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) => {};
+        cloneClass: <T_2>(source: T_2) => T_2;
+        combine: (target: any, source: any, options?: import("./typings").Ddan.IIgnoreParams) => any;
+        combines: (objs: any[], options?: import("./typings").Ddan.IIgnoreParams) => {};
         observe: (obj: any, key: any, watchFun: any, owner: any, deep?: boolean) => void;
     };
     crypto: {

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

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

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

@@ -11,15 +11,6 @@ import polling from "./polling";
  * @returns
  */
 declare function run<T = any>(task?: Promise<T> | Function, wait?: number): Promise<[any, undefined] | [null, T]>;
-/**
- * 设置单例模式
- * @returns
- */
-declare function singleton<T>(): {
-    new (): {};
-    __instance__: any;
-    readonly Instance: T;
-};
 declare const _default: {
     run: typeof run;
     exec: (func: Function, taskId?: string) => Promise<any[]>;
@@ -28,7 +19,6 @@ declare const _default: {
     task: (param?: Ddan.Func1<any, any> | undefined) => DPipeTask;
     mutex: typeof mutex;
     polling: typeof polling;
-    singleton: typeof singleton;
     to: <T = any, U extends object = any>(promise: Promise<T>, errorExt?: object | undefined) => Promise<[null, T] | [U, undefined]>;
     delay: (time?: number) => Promise<unknown>;
 };

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

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

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

@@ -1,21 +1,21 @@
-import { dd } from '../../typings';
+import { Ddan } from '../../typings';
 declare function cloneClass<T>(source: T): T;
 declare const _default: {
     copy: (source: any, options?: {
         fields?: string[] | undefined;
         camel?: boolean | undefined;
         pure?: boolean | undefined;
-    } & dd.IIgnoreParams) => any;
+    } & Ddan.IIgnoreParams) => any;
     clone: (source: any) => any;
-    merge: (target: any, source: any, options?: dd.IIgnoreParams) => {};
+    merge: (target: any, source: any, options?: Ddan.IIgnoreParams) => {};
     isEmpty: (source: any) => boolean;
     parseValue: (source: any, { number, boolean }?: {
         number?: boolean | undefined;
         boolean?: boolean | undefined;
     }) => any;
     cloneClass: typeof cloneClass;
-    combine: (target: any, source: any, options?: dd.IIgnoreParams) => any;
-    combines: (objs: any[], options?: dd.IIgnoreParams) => {};
+    combine: (target: any, source: any, options?: Ddan.IIgnoreParams) => any;
+    combines: (objs: any[], options?: Ddan.IIgnoreParams) => {};
     observe: (obj: any, key: any, watchFun: any, owner: any, deep?: boolean) => void;
 };
 export default _default;

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

@@ -1,4 +1,4 @@
-import { dd } from "../../typings";
+import { Ddan } from "../../typings";
 declare function toString(value: any): any;
 declare const _default: {
     toString: typeof toString;
@@ -15,6 +15,6 @@ declare const _default: {
         number?: boolean | undefined;
         boolean?: boolean | undefined;
     }) => any;
-    replace: (source: string, rules: dd.IRegexRule | dd.IRegexRule[]) => string;
+    replace: (source: string, rules: Ddan.IRegexRule | Ddan.IRegexRule[]) => string;
 };
 export default _default;

package/bin/types/modules/time/dtime.d.ts

@@ -1,21 +1,5 @@
-export interface IDCountdownFormat {
-    countdown: number;
-    timestamp: number;
-    seconds: number;
-    d: number;
-    dd: string;
-    h: number;
-    hh: string;
-    m: number;
-    mm: string;
-    s: number;
-    ss: string;
-    S: number;
-    SS: string;
-    SSS: string;
-    desc: string;
-}
-export default class DTime {
+import { Ddan } from "../../typings";
+export default class DTime implements Ddan.ITime {
     date?: Date;
     timestamp: number;
     yyyy?: number;
@@ -35,7 +19,7 @@ export default class DTime {
     SSS: string;
     constructor(time: string | number | Date);
     toDate(): this;
-    toCountdown(reg?: string): IDCountdownFormat;
+    toCountdown(regFormat?: string): Ddan.ICountdown;
     add(ms?: number): this;
     format(reg?: string): string;
 }

package/bin/types/modules/time/frame.d.ts

@@ -1,6 +1,7 @@
 /// <reference types="node" />
 import DEvent from "../../class/event";
-export default class DLoopFrame {
+import { Ddan } from "../../typings";
+export default class DLoopFrame implements Ddan.ILoopFrame {
     _loopTimer: string | number | NodeJS.Timeout | undefined;
     _event: DEvent;
     started: boolean;

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

@@ -24,7 +24,7 @@ declare const _default: {
     parseTimestamp: typeof parseTimestamp;
     todayZero: () => number;
     format: (time: string | number | Date, reg?: string) => string;
-    countdown: (endTime: string | number | Date, reg?: string) => "" | import("./dtime").IDCountdownFormat;
+    countdown: (endTime: string | number | Date, reg?: string) => "" | import("../..").Ddan.ICountdown;
     dtime: (time: string | number | Date) => DTime;
     loopFrame: (interval?: number) => LoopFrame;
     oneDay: number;

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

@@ -15,6 +15,10 @@ 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>;
+    interface IGetset<T> {
+        set(value: T): void;
+        get(): T | undefined;
+    }
     interface IEvent {
         clear: () => void;
         on: (name: string, handler: Function, tag?: string) => void;
@@ -60,9 +64,66 @@ export declare namespace Ddan {
     type TStoreActionFunction = (arg: IDStore & {
         commit: TStoreCommitFunction;
     }, payload: any) => any;
-}
-export declare namespace dd {
-    type Omit<T, K> = Pick<T, Exclude<keyof T, K>>;
+    interface ILoopFrame {
+        start: () => ILoopFrame;
+        stop: () => ILoopFrame;
+        restart: () => ILoopFrame;
+        on: (cb: Function) => ILoopFrame;
+        off: (cb: Function) => ILoopFrame;
+    }
+    interface ICountdown {
+        countdown: number;
+        timestamp: number;
+        seconds: number;
+        d: number;
+        dd: string;
+        h: number;
+        hh: string;
+        m: number;
+        mm: string;
+        s: number;
+        ss: string;
+        S: number;
+        SS: string;
+        SSS: string;
+        desc: string;
+    }
+    interface ITime {
+        date?: Date;
+        timestamp: number;
+        yyyy?: number;
+        yy?: string;
+        M?: number;
+        MM?: string;
+        d: number;
+        dd: string;
+        h: number;
+        hh: string;
+        m: number;
+        mm: string;
+        s: number;
+        ss: string;
+        S: number;
+        SS: string;
+        SSS: string;
+        toDate: () => ITime;
+        toCountdown: (regFormat?: string) => Ddan.ICountdown;
+        add: (ms: number) => ITime;
+        format: (regFormat?: string) => string;
+    }
+    interface IRegexRule {
+        key: string;
+        flag?: "i" | "g" | "m" | "gi" | "mi";
+        value: string;
+    }
+    interface IIgnoreParams {
+        ignoreUndefined?: boolean;
+        ignoreNull?: boolean;
+        ignoreZero?: boolean;
+        ignoreEmptyArray?: boolean;
+        ignoreEmptyString?: boolean;
+        cover?: boolean;
+    }
     /**
      * leading 开始执行
      * trailing 结束执行
@@ -72,6 +133,8 @@ export declare namespace dd {
         maxWait?: number;
         trailing?: boolean;
     }
+}
+export declare namespace dd {
     interface IHttpRequest {
         url: string;
         host: string;
@@ -138,17 +201,4 @@ export declare namespace dd {
         padx?: number;
         pady?: number;
     }
-    interface IRegexRule {
-        key: string;
-        flag?: "i" | "g" | "m" | "gi" | "mi";
-        value: string;
-    }
-    interface IIgnoreParams {
-        ignoreUndefined?: boolean;
-        ignoreNull?: boolean;
-        ignoreZero?: boolean;
-        ignoreEmptyArray?: boolean;
-        ignoreEmptyString?: boolean;
-        cover?: boolean;
-    }
 }

package/bin/types/util/function.d.ts

@@ -0,0 +1,16 @@
+import { Ddan } from "../typings";
+/**
+ * 设置单例模式
+ * @returns
+ */
+declare function singleton<T>(): {
+    new (): {};
+    __instance__: any;
+    readonly Instance: T;
+};
+declare function getset<T = any>(): Ddan.IGetset<T>;
+declare const _default: {
+    singleton: typeof singleton;
+    getset: typeof getset;
+};
+export default _default;

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

@@ -6,17 +6,17 @@ declare const _default: {
         fields?: string[] | undefined;
         camel?: boolean | undefined;
         pure?: boolean | undefined;
-    } & import("../typings").dd.IIgnoreParams) => any;
+    } & import("..").Ddan.IIgnoreParams) => any;
     clone: (source: any) => any;
-    merge: (target: any, source: any, options?: import("../typings").dd.IIgnoreParams) => {};
+    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>(source: T) => T;
-    combine: (target: any, source: any, options?: import("../typings").dd.IIgnoreParams) => any;
-    combines: (objs: any[], options?: import("../typings").dd.IIgnoreParams) => {};
+    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;
     getTag: (value: any) => string;
     getType: (value: any) => string;

package/package.json

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