ddan-js 2.5.5 → 2.5.7

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

@@ -0,0 +1,17 @@
+import DPipeline from './modules/pipeline';
+import { Ddan } from '../../typings';
+declare const DHooker_base: {
+    new (): {};
+    __instance__: any;
+    readonly Instance: DHooker;
+    readonly I: DHooker;
+};
+export default class DHooker extends DHooker_base {
+    __lockedMap: Map<string, Ddan.SafeResult<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;
+}
+export {};

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

@@ -1,27 +1,30 @@
+import { Ddan } from '../../typings';
 import debounce from './debounce';
 import throttle from './throttle';
 import mutex from './mutex';
 import DPipeTask from '../../class/pipeTask';
-import { Ddan } from '../../typings';
 import polling from './polling';
+import DPipeline from './modules/pipeline';
 /**
  *
  * @param task 任务
  * @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[]>;
+    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: 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/{class → modules/hook/modules}/pipeline.d.ts

@@ -1,9 +1,10 @@
-export default class DPipeline {
-    __list: any[];
+import { Ddan } from '../../../typings';
+export default class DPipeline implements Ddan.IPipeline {
+    __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;
@@ -122,7 +124,7 @@ export declare namespace Ddan {
     }
     interface IRegexRule {
         key: string;
-        flag?: "i" | "g" | "m" | "gi" | "mi";
+        flag?: 'i' | 'g' | 'm' | 'gi' | 'mi';
         value: string;
     }
     interface IIgnoreParams {
@@ -142,6 +144,12 @@ export declare namespace Ddan {
         maxWait?: number;
         trailing?: boolean;
     }
+    interface IPipeline {
+        pipe(func?: any): IPipeline;
+        delay(t?: number): IPipeline;
+        clear(): IPipeline;
+        whenAll(): Promise<IPipeline>;
+    }
 }
 export declare namespace dd {
     interface IHttpRequest {
@@ -165,7 +173,7 @@ export declare namespace dd {
         [key: string]: any;
         url: string;
         model?: string;
-        method: "get" | "post" | "put";
+        method: 'get' | 'post' | 'put';
         body?: string;
         plugins?: Record<string, any>;
     }
@@ -193,7 +201,7 @@ export declare namespace dd {
     interface IDWatermarkParams {
         [key: string]: any;
         t?: number;
-        g?: "nw" | "north" | "ne" | "west" | "center" | "east" | "sw" | "south" | "se";
+        g?: 'nw' | 'north' | 'ne' | 'west' | 'center' | 'east' | 'sw' | 'south' | 'se';
         x?: number;
         y?: number;
         voffset?: number;
@@ -202,7 +210,7 @@ export declare namespace dd {
         pady?: number;
     }
     interface IDWatermarkText {
-        type?: "d3F5LXplbmhlaQ" | "d3F5LW1pY3JvaGVp" | "ZmFuZ3poZW5nc2h1c29uZw" | "ZmFuZ3poZW5na2FpdGk" | "ZmFuZ3poZW5naGVpdGk" | "ZmFuZ3poZW5nZmFuZ3Nvbmc" | "ZHJvaWRzYW5zZmFsbGJhY2s";
+        type?: 'd3F5LXplbmhlaQ' | 'd3F5LW1pY3JvaGVp' | 'ZmFuZ3poZW5nc2h1c29uZw' | 'ZmFuZ3poZW5na2FpdGk' | 'ZmFuZ3poZW5naGVpdGk' | 'ZmFuZ3poZW5nZmFuZ3Nvbmc' | 'ZHJvaWRzYW5zZmFsbGJhY2s';
         color?: string;
         size?: number;
         shadow?: number;

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

@@ -7,6 +7,7 @@ declare function singleton<T>(): {
     new (): {};
     __instance__: any;
     readonly Instance: T;
+    readonly I: T;
 };
 declare function getset<T = any>(t?: T): Ddan.IGetset<T>;
 declare const _default: {

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

@@ -6,6 +6,7 @@ declare const _default: {
         new (): {};
         __instance__: any;
         readonly Instance: T;
+        readonly I: T;
     };
     getset: <T_1 = any>(t?: T_1 | undefined) => import("..").Ddan.IGetset<T_1>;
     copy: (source: any, options?: {

package/package.json

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

package/bin/lib/class/task.js

@@ -1,39 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const base_1 = require("../modules/hook/base");
-class DTask {
-    __source;
-    constructor(source) {
-        this.__source = source;
-    }
-    run = () => base_1.default.safeDo(this.__source);
-    static _lockedMap = new Map();
-    static _lock(id, func) {
-        if (!id || !func)
-            return undefined;
-        const task = new DTask(func).run();
-        this._lockedMap.set(id, task);
-        return task;
-    }
-    static _unlock(id) {
-        if (!id)
-            return;
-        this._lockedMap.delete(id);
-    }
-    static async exec(func, taskId) {
-        if (!func || !taskId) {
-            return new DTask(func).run();
-        }
-        const _task = this._lockedMap.get(taskId);
-        if (_task) {
-            return _task;
-        }
-        const _newTask = this._lock(taskId, func);
-        if (!_newTask)
-            return new DTask(func).run();
-        const result = await _newTask;
-        this._unlock(taskId);
-        return result;
-    }
-}
-exports.default = DTask;

package/bin/types/class/task.d.ts

@@ -1,9 +0,0 @@
-export default class DTask<T = any> {
-    __source: any;
-    constructor(source?: any);
-    run: () => Promise<[any, undefined] | [null, T]>;
-    static _lockedMap: Map<string, Promise<any[]>>;
-    static _lock(id: string, func: Function): Promise<[any, undefined] | [null, any]> | undefined;
-    static _unlock(id: string): void;
-    static exec(func: Function, taskId: string): Promise<any[]>;
-}