ddan-js 2.6.0 → 2.6.2

package/bin/types/index.d.ts

@@ -187,18 +187,19 @@ declare const dUtil: {
 declare const dHook: {
     sleep: (ms?: number) => Promise<unknown>;
     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>;
+    exec: (func: import("./typings").Ddan.Function, taskId?: string) => import("./typings").Ddan.PSafeResult<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/modules/mutex").default;
     polling: typeof import("./modules/hook/modules/polling").default;
-    pipe: (func: import("./typings").Ddan.Function) => import("./modules/hook/modules/pipeline").default;
+    pipe: (func: import("./typings").Ddan.Function, callback?: ((result: import("./typings").Ddan.SafeResult<any>) => void) | undefined) => import("./modules/hook/modules/pipeline").default;
     pipeline: (max?: number) => import("./modules/hook/modules/pipeline").default;
+    safeTask: (func: import("./typings").Ddan.Function, callback?: ((result: import("./typings").Ddan.SafeResult<any>) => void) | undefined) => import("./modules/hook/modules/safeTask").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?: 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]>;
+    safeRun: <T_3 = any>(func: any) => Promise<[any, undefined] | [null, T_3]>;
     base64: {
         encode: (input: string) => string;
         decode: (input: string) => string;
@@ -472,18 +473,19 @@ declare const _default: {
     hook: {
         sleep: (ms?: number) => Promise<unknown>;
         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>;
+        exec: (func: import("./typings").Ddan.Function, taskId?: string) => import("./typings").Ddan.PSafeResult<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/modules/mutex").default;
         polling: typeof import("./modules/hook/modules/polling").default;
-        pipe: (func: import("./typings").Ddan.Function) => import("./modules/hook/modules/pipeline").default;
+        pipe: (func: import("./typings").Ddan.Function, callback?: ((result: import("./typings").Ddan.SafeResult<any>) => void) | undefined) => import("./modules/hook/modules/pipeline").default;
         pipeline: (max?: number) => import("./modules/hook/modules/pipeline").default;
+        safeTask: (func: import("./typings").Ddan.Function, callback?: ((result: import("./typings").Ddan.SafeResult<any>) => void) | undefined) => import("./modules/hook/modules/safeTask").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?: 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]>;
+        safeRun: <T_3 = any>(func: any) => Promise<[any, undefined] | [null, T_3]>;
     };
     math: {
         random: (max: number) => number;

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

@@ -4,6 +4,6 @@ declare const _default: {
     to: typeof to;
     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]>;
+    safeRun: <T_1 = any>(func: any) => Promise<[null, T_1] | [any, undefined]>;
 };
 export default _default;

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

@@ -7,11 +7,11 @@ declare const DHooker_base: {
     readonly I: DHooker;
 };
 export default class DHooker extends DHooker_base {
-    __lockedMap: Map<string, Ddan.SafeResult<any>>;
+    __lockedMap: Map<string, Ddan.PSafeResult<any>>;
     pipeline: DPipeline;
     constructor();
     lock(id: string, func: Ddan.PFunction): Promise<[any, undefined] | [null, any]> | undefined;
     unlock(id: string): void;
-    exec(func: Ddan.PFunction, taskId: string): Ddan.SafeResult;
+    exec(func: Ddan.PFunction, taskId: string): Ddan.PSafeResult;
 }
 export {};

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

@@ -5,6 +5,7 @@ import mutex from './modules/mutex';
 import DPipeTask from '../../class/pipeTask';
 import polling from './modules/polling';
 import DPipeline from './modules/pipeline';
+import DSafeTask from './modules/safeTask';
 /**
  *
  * @param task 任务
@@ -15,17 +16,18 @@ declare function run<T = any>(task?: Ddan.PFunction<T>, wait?: number): Promise<
 declare const _default: {
     sleep: (ms?: number) => Promise<unknown>;
     run: typeof run;
-    exec: (func: Ddan.Function, taskId?: string) => Ddan.SafeResult<any>;
+    exec: (func: Ddan.Function, taskId?: string) => Ddan.PSafeResult<any>;
     debounce: typeof debounce;
     throttle: typeof throttle;
     task: (param?: Ddan.Func1<any, any> | undefined) => DPipeTask;
     mutex: typeof mutex;
     polling: typeof polling;
-    pipe: (func: Ddan.Function) => DPipeline;
+    pipe: (func: Ddan.Function, callback?: ((result: Ddan.SafeResult<any>) => void) | undefined) => DPipeline;
     pipeline: (max?: number) => DPipeline;
+    safeTask: (func: Ddan.Function, callback?: ((result: Ddan.SafeResult<any>) => void) | undefined) => DSafeTask;
     to: <T = any, U extends object = any>(promise: Promise<T>, errorExt?: object | undefined) => Promise<[null, T] | [U, undefined]>;
     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]>;
+    safeRun: <T_2 = any>(func: any) => Promise<[null, T_2] | [any, undefined]>;
 };
 export default _default;

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

@@ -1,10 +1,11 @@
 import { Ddan } from '../../../typings';
+import DSafeTask from './safeTask';
 export default class DPipeline implements Ddan.IPipeline {
-    __list: Ddan.Function[];
+    __list: DSafeTask[];
     __count: number;
     __max: number;
     constructor(max?: number);
-    push(func?: Ddan.Function): this;
+    push(func: Ddan.Function, callback?: (result: Ddan.SafeResult) => void): this;
     clear(): this;
     _step(): void;
     whenAll(): Promise<this>;

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

@@ -0,0 +1,7 @@
+import { Ddan } from '../../../typings';
+export default class DSafeTask implements Ddan.ISafeTask {
+    _func: Ddan.PFunction;
+    _callback: ((result: Ddan.SafeResult) => void) | undefined;
+    constructor(task: Ddan.PFunction, callback?: (result: Ddan.SafeResult) => void);
+    run(): Ddan.PSafeResult;
+}

package/bin/types/modules/rule/async-validator/index.d.ts

@@ -14,6 +14,12 @@ declare class Schema {
         string: import("./interface").ExecuteValidator;
         method: import("./interface").ExecuteValidator;
         number: import("./interface").ExecuteValidator;
+        /**
+         *  Encapsulates a validation schema.
+         *
+         *  @param descriptor An object declaring validation rules
+         *  for this schema.
+         */
         boolean: import("./interface").ExecuteValidator;
         regexp: import("./interface").ExecuteValidator;
         integer: import("./interface").ExecuteValidator;

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

@@ -16,7 +16,24 @@ 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]>;
+    type SafeResult<T = any> = [any, undefined] | [null, T];
+    type PSafeResult<T = any> = Promise<SafeResult<T>>;
+    type ObjToKeyValUnion<T> = {
+        [K in keyof T]: {
+            key: K;
+            value: T[K];
+        };
+    }[keyof T];
+    type ObjToKeyValArray<T> = {
+        [K in keyof T]: [K, T[K]];
+    }[keyof T];
+    type ObjToSelectedValueUnion<T> = {
+        [K in keyof T]: T[K];
+    }[keyof T];
+    type Optional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+    type GetOptional<T> = {
+        [P in keyof T as T[P] extends Required<T>[P] ? never : P]: T[P];
+    };
     interface IHttpHost {
         href: string;
         url: string;
@@ -149,6 +166,9 @@ export declare namespace Ddan {
         clear(): IPipeline;
         whenAll(): Promise<IPipeline>;
     }
+    interface ISafeTask {
+        run(): PSafeResult;
+    }
 }
 export declare namespace dd {
     interface IHttpRequest {

package/package.json

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