ddan-js 2.5.6 → 2.5.8

package/bin/lib/modules/hook/index.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const debounce_1 = require("./debounce");
-const throttle_1 = require("./throttle");
-const mutex_1 = require("./mutex");
+const debounce_1 = require("./modules/debounce");
+const throttle_1 = require("./modules/throttle");
+const mutex_1 = require("./modules/mutex");
 const pipeTask_1 = require("../../class/pipeTask");
 const base_1 = require("./base");
-const polling_1 = require("./polling");
+const polling_1 = require("./modules/polling");
 const hooker_1 = require("./hooker");
 const pipeline_1 = require("./modules/pipeline");
 /**

package/bin/lib/modules/hook/{debounce.js → modules/debounce.js}

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const to_1 = require("../../util/to");
-const is_1 = require("../../util/is");
+const to_1 = require("../../../util/to");
+const is_1 = require("../../../util/is");
 const FUNC_ERROR_TEXT = 'Expected a function';
 const nativeMax = Math.max;
 const nativeMin = Math.min;

package/bin/lib/modules/hook/modules/pipeline.js

@@ -8,10 +8,10 @@ class DPipeline {
     constructor() {
         this.clear();
     }
-    pipe(_task) {
+    pipe(func) {
         if (this.__waitting)
             return this;
-        _task && this.__list.push(_task);
+        func && this.__list.push(func);
         this._step();
         return this;
     }

package/bin/lib/modules/hook/{polling.js → modules/polling.js}

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const base_1 = require("./base");
+const base_1 = require("../base");
 async function polling(params = {}) {
     const { func, interval = 100, times = 1000 } = params;
     let _times = times;

package/bin/lib/modules/hook/{throttle.js → modules/throttle.js}

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const is_1 = require("../../util/is");
+const is_1 = require("../../../util/is");
 const debounce_1 = require("./debounce");
 /** Error message constants. */
 const FUNC_ERROR_TEXT = 'Expected a function';

package/bin/types/index.d.ts

@@ -186,17 +186,17 @@ declare const dUtil: {
 };
 declare const dHook: {
     sleep: (ms?: number) => Promise<unknown>;
-    run: <T = any>(task?: Function | Promise<T> | undefined, wait?: number) => Promise<[any, undefined] | [null, T]>;
-    exec: (func: Function, taskId?: string) => Promise<[any, undefined] | [null, any]>;
-    debounce: typeof import("./modules/hook/debounce").default;
-    throttle: typeof import("./modules/hook/throttle").default;
+    run: <T = any>(task?: import("./typings").Ddan.PFunction<T> | undefined, wait?: number) => Promise<[any, undefined] | [null, T]>;
+    exec: (func: import("./typings").Ddan.Function, taskId?: string) => import("./typings").Ddan.SafeResult<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/mutex").default;
-    polling: typeof import("./modules/hook/polling").default;
-    pipe: (func: Function) => import("./modules/hook/modules/pipeline").default;
+    mutex: typeof import("./modules/hook/modules/mutex").default;
+    polling: typeof import("./modules/hook/modules/polling").default;
+    pipe: (func: import("./typings").Ddan.Function) => import("./modules/hook/modules/pipeline").default;
     pipeline: () => import("./modules/hook/modules/pipeline").default;
     to: <T_1 = any, U extends object = any>(promise: Promise<T_1>, errorExt?: object | undefined) => Promise<[null, T_1] | [U, undefined]>;
-    go: <T_2 = any>(task?: Function | Promise<T_2> | undefined) => Promise<[any, undefined] | [null, T_2]>;
+    go: <T_2 = any>(task?: import("./typings").Ddan.PFunction<T_2> | undefined) => Promise<[any, undefined] | [null, T_2]>;
     delay: (ms?: number) => Promise<unknown>;
     safeDo: <T_3 = any>(func: any) => Promise<[null, T_3] | [any, undefined]>;
     base64: {
@@ -471,17 +471,17 @@ declare const _default: {
     };
     hook: {
         sleep: (ms?: number) => Promise<unknown>;
-        run: <T = any>(task?: Function | Promise<T> | undefined, wait?: number) => Promise<[any, undefined] | [null, T]>;
-        exec: (func: Function, taskId?: string) => Promise<[any, undefined] | [null, any]>;
-        debounce: typeof import("./modules/hook/debounce").default;
-        throttle: typeof import("./modules/hook/throttle").default;
+        run: <T = any>(task?: import("./typings").Ddan.PFunction<T> | undefined, wait?: number) => Promise<[any, undefined] | [null, T]>;
+        exec: (func: import("./typings").Ddan.Function, taskId?: string) => import("./typings").Ddan.SafeResult<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/mutex").default;
-        polling: typeof import("./modules/hook/polling").default;
-        pipe: (func: Function) => import("./modules/hook/modules/pipeline").default;
+        mutex: typeof import("./modules/hook/modules/mutex").default;
+        polling: typeof import("./modules/hook/modules/polling").default;
+        pipe: (func: import("./typings").Ddan.Function) => import("./modules/hook/modules/pipeline").default;
         pipeline: () => import("./modules/hook/modules/pipeline").default;
         to: <T_1 = any, U extends object = any>(promise: Promise<T_1>, errorExt?: object | undefined) => Promise<[null, T_1] | [U, undefined]>;
-        go: <T_2 = any>(task?: Function | Promise<T_2> | undefined) => Promise<[any, undefined] | [null, T_2]>;
+        go: <T_2 = any>(task?: import("./typings").Ddan.PFunction<T_2> | undefined) => Promise<[any, undefined] | [null, T_2]>;
         delay: (ms?: number) => Promise<unknown>;
         safeDo: <T_3 = any>(func: any) => Promise<[null, T_3] | [any, undefined]>;
     };

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

@@ -1,7 +1,8 @@
+import { Ddan } from '../../typings';
 declare function to<T = any, U extends object = any>(promise: Promise<T>, errorExt?: object): Promise<[null, T] | [U, undefined]>;
 declare const _default: {
     to: typeof to;
-    go: <T = any>(task?: Function | Promise<T> | undefined) => Promise<[any, undefined] | [null, T]>;
+    go: <T = any>(task?: Ddan.PFunction<T> | undefined) => Promise<[any, undefined] | [null, T]>;
     delay: (ms?: number) => Promise<unknown>;
     safeDo: <T_1 = any>(func: any) => Promise<[null, T_1] | [any, undefined]>;
 };

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

@@ -1,4 +1,5 @@
 import DPipeline from './modules/pipeline';
+import { Ddan } from '../../typings';
 declare const DHooker_base: {
     new (): {};
     __instance__: any;
@@ -6,11 +7,11 @@ declare const DHooker_base: {
     readonly I: DHooker;
 };
 export default class DHooker extends DHooker_base {
-    __lockedMap: Map<string, Promise<[any, undefined] | [null, any]>>;
+    __lockedMap: Map<string, Ddan.SafeResult<any>>;
     pipeline: DPipeline;
     constructor();
-    lock(id: string, func: Function): Promise<[any, undefined] | [null, any]> | undefined;
+    lock(id: string, func: Ddan.PFunction): Promise<[any, undefined] | [null, any]> | undefined;
     unlock(id: string): void;
-    exec(func: Function, taskId: string): Promise<[any, undefined] | [null, any]>;
+    exec(func: Ddan.PFunction, taskId: string): Ddan.SafeResult;
 }
 export {};

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

@@ -1,9 +1,9 @@
 import { Ddan } from '../../typings';
-import debounce from './debounce';
-import throttle from './throttle';
-import mutex from './mutex';
+import debounce from './modules/debounce';
+import throttle from './modules/throttle';
+import mutex from './modules/mutex';
 import DPipeTask from '../../class/pipeTask';
-import polling from './polling';
+import polling from './modules/polling';
 import DPipeline from './modules/pipeline';
 /**
  *
@@ -11,20 +11,20 @@ import DPipeline from './modules/pipeline';
  * @param wait 最小等待时间，单位毫秒
  * @returns
  */
-declare function run<T = any>(task?: Promise<T> | Function, wait?: number): Promise<[any, undefined] | [null, T]>;
+declare function run<T = any>(task?: Ddan.PFunction<T>, wait?: number): Promise<[any, undefined] | [null, T]>;
 declare const _default: {
     sleep: (ms?: number) => Promise<unknown>;
     run: typeof run;
-    exec: (func: Function, taskId?: string) => Promise<[any, undefined] | [null, any]>;
+    exec: (func: Ddan.Function, taskId?: string) => Ddan.SafeResult<any>;
     debounce: typeof debounce;
     throttle: typeof throttle;
     task: (param?: Ddan.Func1<any, any> | undefined) => DPipeTask;
     mutex: typeof mutex;
     polling: typeof polling;
-    pipe: (func: Function) => DPipeline;
+    pipe: (func: Ddan.Function) => DPipeline;
     pipeline: () => DPipeline;
     to: <T = any, U extends object = any>(promise: Promise<T>, errorExt?: object | undefined) => Promise<[null, T] | [U, undefined]>;
-    go: <T_1 = any>(task?: Function | Promise<T_1> | undefined) => Promise<[any, undefined] | [null, T_1]>;
+    go: <T_1 = any>(task?: Ddan.PFunction<T_1> | undefined) => Promise<[any, undefined] | [null, T_1]>;
     delay: (ms?: number) => Promise<unknown>;
     safeDo: <T_2 = any>(func: any) => Promise<[null, T_2] | [any, undefined]>;
 };

package/bin/types/modules/hook/{debounce.d.ts → modules/debounce.d.ts}

@@ -1,4 +1,4 @@
-import { Ddan } from '../../typings';
+import { Ddan } from '../../../typings';
 /**
  * 防抖 一段时间内，规定时间间隔多次执行，回调触发一次
  * @param func

package/bin/types/modules/hook/{mutex.d.ts → modules/mutex.d.ts}

@@ -1,3 +1,3 @@
-import { Ddan } from "../../typings";
+import { Ddan } from "../../../typings";
 declare function mutex(func: Ddan.Action): (...args: any[]) => Promise<false | undefined>;
 export default mutex;

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

@@ -1,10 +1,10 @@
 import { Ddan } from '../../../typings';
 export default class DPipeline implements Ddan.IPipeline {
-    __list: any[];
+    __list: Ddan.Function[];
     __running: boolean;
     __waitting: boolean;
     constructor();
-    pipe(_task?: any): this;
+    pipe(func?: Ddan.Function): this;
     delay(t?: number): this;
     clear(): this;
     _step(): Promise<void>;

package/bin/types/modules/hook/{polling.d.ts → modules/polling.d.ts}

@@ -1,4 +1,4 @@
-import { Ddan } from "../../typings";
+import { Ddan } from "../../../typings";
 declare function polling(params?: {
     func?: Ddan.Func<Ddan.Result<Boolean | void>>;
     interval?: number;

package/bin/types/modules/hook/{throttle.d.ts → modules/throttle.d.ts}

@@ -1,4 +1,4 @@
-import { Ddan } from "../../typings";
+import { Ddan } from "../../../typings";
 /**
  * 节流 每个间隔内，触发一次
  * @param func

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

@@ -6,6 +6,7 @@ export declare namespace Ddan {
     }
     type KeyValue<T = any> = Required<IKeyValuePart<T>>;
     type Function = (...args: any[]) => void;
+    type PFunction<T = any> = Promise<T> | Function;
     type Callback<T extends any[] = unknown[], R = any> = (...args: T) => R;
     type Action<T extends any[] = unknown[]> = Callback<T, void>;
     type Task<T = any, R = void> = Callback<[T[]], R>;
@@ -15,6 +16,7 @@ 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>;
+    type SafeResult<T = any> = Promise<[any, undefined] | [null, T]>;
     interface IHttpHost {
         href: string;
         url: string;
@@ -143,7 +145,7 @@ export declare namespace Ddan {
         trailing?: boolean;
     }
     interface IPipeline {
-        pipe(func?: any): IPipeline;
+        pipe(func?: Function): IPipeline;
         delay(t?: number): IPipeline;
         clear(): IPipeline;
         whenAll(): Promise<IPipeline>;

package/package.json

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