ddan-js 2.4.1 → 2.4.2

package/bin/lib/modules/time/dtime.js

@@ -50,7 +50,7 @@ class DTime {
         this.SSS = this.S.toString().padStart(3, "0");
         return this;
     }
-    toCountdown(reg = "") {
+    toCountdown(regFormat = "") {
         const result = {
             countdown: 0,
             timestamp: 0,
@@ -89,7 +89,7 @@ class DTime {
         result.S = amount;
         result.SS = (result.S < 10 ? "0" : "") + result.S;
         result.SSS = result.S.toString().padStart(3, "0");
-        let _reg = reg;
+        let _reg = regFormat;
         if (!_reg) {
             if (result.countdown > const_1.default.oneHour) {
                 _reg = "hh:mm:ss";

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: {
@@ -424,7 +424,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;
@@ -475,17 +475,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) => {};
+        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;
@@ -535,24 +535,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) => {};
+        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/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

@@ -60,9 +60,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 +129,8 @@ export declare namespace dd {
         maxWait?: number;
         trailing?: boolean;
     }
+}
+export declare namespace dd {
     interface IHttpRequest {
         url: string;
         host: string;
@@ -138,17 +197,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/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.2",
   "description": "",
   "keywords": [
     "ddan-js",