ddan-js 2.5.6 → 2.5.7

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]>;
+    run: <T = any>(task?: import("./typings").Ddan.PFunction<T> | undefined, wait?: number) => Promise<[any, undefined] | [null, T]>;
+    exec: (func: import("./typings").Ddan.PFunction<any>, taskId?: string) => import("./typings").Ddan.SafeResult<any>;
     debounce: typeof import("./modules/hook/debounce").default;
     throttle: typeof import("./modules/hook/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;
+    pipe: (func: import("./typings").Ddan.PFunction<any>) => 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]>;
+        run: <T = any>(task?: import("./typings").Ddan.PFunction<T> | undefined, wait?: number) => Promise<[any, undefined] | [null, T]>;
+        exec: (func: import("./typings").Ddan.PFunction<any>, taskId?: string) => import("./typings").Ddan.SafeResult<any>;
         debounce: typeof import("./modules/hook/debounce").default;
         throttle: typeof import("./modules/hook/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;
+        pipe: (func: import("./typings").Ddan.PFunction<any>) => 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

@@ -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.PFunction<any>, 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.PFunction<any>) => 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/modules/pipeline.d.ts

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

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;

package/package.json

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