ddan-js 2.8.1 → 2.8.2

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

@@ -69,36 +69,40 @@ function radian2degree(radians) {
 function degree2radian(degrees) {
     return degrees / radiansToAngles;
 }
-function formatMemory(mem) {
-    let _mem = mem;
+function calcDataSize(data) {
     const result = {
-        g: 0,
-        m: 0,
+        gb: 0,
+        mb: 0,
         kb: 0,
         b: 0,
+        total: data,
         desc: '',
     };
-    if (_mem >= 1 << 30) {
-        result.g = Math.floor(_mem / (1 << 30));
-        _mem = _mem % (1 << 30);
+    const units = [
+        { name: 'gb', divisor: 1 << 30 },
+        { name: 'mb', divisor: 1 << 20 },
+        { name: 'kb', divisor: 1 << 10 },
+        { name: 'b', divisor: 1 },
+    ];
+    // 计算每个单位的数量
+    for (const unit of units) {
+        const value = Math.floor(data / unit.divisor);
+        result[unit.name] = value;
+        data -= value * unit.divisor;
     }
-    if (_mem >= 1 << 20) {
-        result.m = Math.floor(_mem / (1 << 20));
-        _mem = _mem % (1 << 20);
+    // 计算简洁的描述
+    if (result.gb > 0) {
+        result.desc = (result.gb + result.mb / 1024).toFixed(2) + 'GB';
     }
-    if (_mem >= 1 << 10) {
-        result.kb = Math.floor(_mem / (1 << 10));
-        _mem = _mem % (1 << 10);
+    else if (result.mb > 0) {
+        result.desc = (result.mb + result.kb / 1024).toFixed(2) + 'MB';
+    }
+    else if (result.kb > 0) {
+        result.desc = (result.kb + result.b / 1024).toFixed(2) + 'KB';
+    }
+    else {
+        result.desc = result.b + 'B';
     }
-    result.b = _mem;
-    if (mem >= 1 << 30)
-        result.desc = (mem / (1 << 30)).toFixed(2) + 'G';
-    else if (mem >= 1 << 20)
-        result.desc = (mem / (1 << 20)).toFixed(2) + 'M';
-    else if (mem >= 1 << 10)
-        result.desc = (mem / (1 << 10)).toFixed(2) + 'KB';
-    else
-        result.desc = mem + 'B';
     return result;
 }
 exports.default = {
@@ -110,5 +114,5 @@ exports.default = {
     float,
     radian2degree,
     degree2radian,
-    formatMemory,
+    calcDataSize,
 };

package/bin/lib/modules/node/socks5.js

@@ -23,6 +23,8 @@ class Socks5 {
     __event;
     __pipeline;
     __logger;
+    __totalReceived = 0;
+    __totalSent = 0;
     constructor(upstreamProxy, allowedDomains = ['*'], debug = false, logger) {
         this.__event = new event_1.default();
         this.upstreamProxy = upstreamProxy;
@@ -43,6 +45,12 @@ class Socks5 {
             return '';
         return `socks5://127.0.0.1:${this.__port}`;
     }
+    get totalReceived() {
+        return this.__totalReceived;
+    }
+    get totalSent() {
+        return this.__totalSent;
+    }
     validateProxyConfig(proxyConfig = this.upstreamProxy) {
         const { ipaddress, port, userId, password } = proxyConfig || {};
         if (!ipaddress || typeof ipaddress !== 'string') {
@@ -146,19 +154,19 @@ class Socks5 {
                 // 走上游代理
                 const upstreamSocket = await this.connectToUpstreamProxy(destination);
                 this.__logger?.info(`[socks5] handle connection upstream`, addrport);
-                this.setupDataForwarding(clientSocket, upstreamSocket);
+                this.setupDataForwarding(clientSocket, upstreamSocket, 'upstream');
             }
             else if (this.useSystemProxy && this.systemProxy && !index_1.default.isLocalIpAddress(addr)) {
                 // 走系统代理
                 const systemSocket = await this.connectToSystemProxy(destination);
                 this.__debug && console.info(`[socks5] handle connection system`, addrport);
-                this.setupDataForwarding(clientSocket, systemSocket);
+                this.setupDataForwarding(clientSocket, systemSocket, 'system');
             }
             else {
                 this.__debug && console.info(`[socks5] handle connection local`, addrport);
                 // 本地连接
                 const localSocket = await this.connectToLocal(destination);
-                this.setupDataForwarding(clientSocket, localSocket);
+                this.setupDataForwarding(clientSocket, localSocket, 'local');
             }
         }
         catch (err) {
@@ -281,12 +289,20 @@ class Socks5 {
             });
         });
     }
-    setupDataForwarding(clientSocket, targetSocket) {
+    setupDataForwarding(clientSocket, targetSocket, type = 'local') {
         clientSocket.write(new Uint8Array([0x05, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]));
         clientSocket.pipe(targetSocket);
         targetSocket.pipe(clientSocket);
         const addrPort = `${targetSocket.localAddress}:${targetSocket.localPort}`;
         this.__debug && console.info(`[socks5] setupDataForwarding ${addrPort}`);
+        if (type === 'upstream') {
+            targetSocket.on('data', (buf) => {
+                this.__totalSent += buf.length;
+            });
+            clientSocket.on('data', (buf) => {
+                this.__totalReceived += buf.length;
+            });
+        }
         clientSocket.on('close', () => {
             this.__debug && console.info('[socks5] client socket close', addrPort);
             targetSocket.end();
@@ -348,6 +364,10 @@ class Socks5 {
             return;
         this.__event.off(name, listener);
     }
+    resetStatistics() {
+        this.__totalReceived = 0;
+        this.__totalSent = 0;
+    }
     _emit(name, ...args) {
         try {
             if (!name)

package/bin/types/index.d.ts

@@ -125,11 +125,12 @@ declare const dUtil: {
         }) => number;
         radian2degree: (radians: number) => number;
         degree2radian: (degrees: number) => number;
-        formatMemory: (mem: number) => {
-            g: number;
-            m: number;
+        calcDataSize: (data: number) => {
+            gb: number;
+            mb: number;
             kb: number;
             b: number;
+            total: number;
             desc: string;
         };
     };
@@ -286,6 +287,25 @@ declare const dHook: {
         readonly Instance: T;
         readonly I: T;
     };
+    random: (max: number) => number;
+    randomRange: (min: number, max: number) => number;
+    lerp: (start: number, end: number, t: number) => number;
+    randoms: (max: number, count?: number, repeat?: boolean) => number[];
+    strip: (num: string | number, digits?: number) => number;
+    float: (num: string | number, { digits, fixed }?: {
+        digits?: number | undefined;
+        fixed?: boolean | undefined;
+    }) => number;
+    radian2degree: (radians: number) => number;
+    degree2radian: (degrees: number) => number;
+    calcDataSize: (data: number) => {
+        gb: number;
+        mb: number;
+        kb: number;
+        b: number;
+        total: number;
+        desc: string;
+    };
     toString: (value: any) => any;
     startCase: (string: any) => any;
     snakeCase: (string: any) => any;
@@ -317,10 +337,12 @@ declare const dHook: {
     logParse: (logStr: string) => string;
     logRString: (data: any) => Promise<string>;
     logRParse: (logStr: string) => Promise<string>;
-    to: <T_2 = any, U extends object = any>(promise: Promise<T_2>, errorExt?: object | undefined) => Promise<[null, T_2] | [U, undefined]>;
-    go: <T_3 = any>(task?: import("./typings").Ddan.PFunction<T_3> | undefined) => Promise<[any, undefined] | [null, T_3]>;
+    to: <T_2 = any, U extends object = any>(promise: Promise<T_2>, errorExt?: object | undefined, fn?: import("./typings").Ddan.noop | undefined) => Promise<[null, T_2] | [U, undefined]>;
+    go: <T_3 = any>(task?: import("./typings").Ddan.PFunction<T_3> | undefined, fn?: import("./typings").Ddan.noop | undefined) => Promise<[any, undefined] | [null, T_3]>;
     delay: (ms?: number) => Promise<unknown>;
-    safeRun: <T_4 = any>(func: any) => Promise<[any, undefined] | [null, T_4]>;
+    safeRun: <T_4 = any>(func: any, fn?: import("./typings").Ddan.noop | undefined) => Promise<[any, undefined] | [null, T_4]>;
+    toError: (value: any) => any;
+    timeout: <T_5 = any>(task?: import("./typings").Ddan.PFunction<T_5> | undefined, ms?: number, desc?: string) => Promise<[any, undefined] | [null, T_5]>;
     base64: {
         encode: (input: string) => string;
         decode: (base64Str: string) => string;
@@ -699,10 +721,12 @@ declare const _default: {
         logParse: (logStr: string) => string;
         logRString: (data: any) => Promise<string>;
         logRParse: (logStr: string) => Promise<string>;
-        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]>;
+        to: <T_1 = any, U extends object = any>(promise: Promise<T_1>, errorExt?: object | undefined, fn?: import("./typings").Ddan.noop | undefined) => Promise<[null, T_1] | [U, undefined]>;
+        go: <T_2 = any>(task?: import("./typings").Ddan.PFunction<T_2> | undefined, fn?: import("./typings").Ddan.noop | undefined) => Promise<[any, undefined] | [null, T_2]>;
         delay: (ms?: number) => Promise<unknown>;
-        safeRun: <T_3 = any>(func: any) => Promise<[any, undefined] | [null, T_3]>;
+        safeRun: <T_3 = any>(func: any, fn?: import("./typings").Ddan.noop | undefined) => Promise<[any, undefined] | [null, T_3]>;
+        toError: (value: any) => any;
+        timeout: <T_4 = any>(task?: import("./typings").Ddan.PFunction<T_4> | undefined, ms?: number, desc?: string) => Promise<[any, undefined] | [null, T_4]>;
     };
     math: {
         random: (max: number) => number;
@@ -716,24 +740,25 @@ declare const _default: {
         }) => number;
         radian2degree: (radians: number) => number;
         degree2radian: (degrees: number) => number;
-        formatMemory: (mem: number) => {
-            g: number;
-            m: number;
+        calcDataSize: (data: number) => {
+            gb: number;
+            mb: number;
             kb: number;
             b: number;
+            total: number;
             desc: string;
         };
     };
     util: {
         includes: typeof import("./util/includes").default;
         forof: (source: any, cb: (key: any, val: any) => void) => void;
-        singleton: <T_4>() => {
+        singleton: <T_5>() => {
             new (): {};
             __instance__: any;
-            readonly Instance: T_4;
-            readonly I: T_4;
+            readonly Instance: T_5;
+            readonly I: T_5;
         };
-        getset: <T_5 = any>(t?: T_5 | undefined) => import("./typings").Ddan.IGetset<T_5>;
+        getset: <T_6 = any>(t?: T_6 | undefined) => import("./typings").Ddan.IGetset<T_6>;
         copy: (source: any, options?: {
             fields?: string[] | undefined;
             camel?: boolean | undefined;
@@ -746,7 +771,7 @@ declare const _default: {
             number?: boolean | undefined;
             boolean?: boolean | undefined;
         }) => any;
-        cloneClass: <T_6>(source: T_6) => T_6;
+        cloneClass: <T_7>(source: T_7) => T_7;
         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;
@@ -778,16 +803,16 @@ declare const _default: {
         isArrayBuffer: (data: any) => boolean;
     };
     list: {
-        stepAction: <T_7>(list: T_7[], func: import("./typings").Ddan.Task<T_7, void>, stepCount?: number) => void;
-        skip: <T_8>(list: T_8[], count: number) => T_8[];
-        take: <T_9>(list: T_9[], count: number, skip?: number) => T_9[];
-        distinct: <T_10>(list: T_10[]) => T_10[];
-        randoms: <T_11>(list: T_11[], count?: number, repeat?: boolean) => T_11[];
+        stepAction: <T_8>(list: T_8[], func: import("./typings").Ddan.Task<T_8, void>, stepCount?: number) => void;
+        skip: <T_9>(list: T_9[], count: number) => T_9[];
+        take: <T_10>(list: T_10[], count: number, skip?: number) => T_10[];
+        distinct: <T_11>(list: T_11[]) => T_11[];
+        randoms: <T_12>(list: T_12[], count?: number, repeat?: boolean) => T_12[];
         toKV: (list: import("./typings").Ddan.KV<any>[], key: string, value: string) => import("./typings").Ddan.KV<any>;
-        groupBy: <T_12>(list: T_12[], key: string) => Record<string, T_12[]>;
-        first: <T_13>(list: T_13[]) => T_13 | undefined;
-        last: <T_14>(list: T_14[]) => T_14 | undefined;
-        toList: <T_15>(val: T_15 | T_15[]) => T_15[];
+        groupBy: <T_13>(list: T_13[], key: string) => Record<string, T_13[]>;
+        first: <T_14>(list: T_14[]) => T_14 | undefined;
+        last: <T_15>(list: T_15[]) => T_15 | undefined;
+        toList: <T_16>(val: T_16 | T_16[]) => T_16[];
     };
     string: {
         toString: (value: any) => any;
@@ -820,7 +845,7 @@ declare const _default: {
             number?: boolean | undefined;
             boolean?: boolean | undefined;
         }) => any;
-        cloneClass: <T_6>(source: T_6) => T_6;
+        cloneClass: <T_7>(source: T_7) => T_7;
         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;

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

@@ -1,9 +1,11 @@
 import { Ddan } from '../../typings';
-declare function to<T = any, U extends object = any>(promise: Promise<T>, errorExt?: object): Promise<[null, T] | [U, undefined]>;
+declare function to<T = any, U extends object = any>(promise: Promise<T>, errorExt?: object, fn?: Ddan.noop): Promise<[null, T] | [U, undefined]>;
 declare const _default: {
     to: typeof to;
-    go: <T = any>(task?: Ddan.PFunction<T> | undefined) => Promise<[any, undefined] | [null, T]>;
+    go: <T = any>(task?: Ddan.PFunction<T> | undefined, fn?: Ddan.noop | undefined) => Promise<[any, undefined] | [null, T]>;
     delay: (ms?: number) => Promise<unknown>;
-    safeRun: <T_1 = any>(func: any) => Promise<[null, T_1] | [any, undefined]>;
+    safeRun: <T_1 = any>(func: any, fn?: Ddan.noop | undefined) => Promise<[null, T_1] | [any, undefined]>;
+    toError: (value: any) => any;
+    timeout: <T_2 = any>(task?: Ddan.PFunction<T_2> | undefined, ms?: number, desc?: string) => Promise<[any, undefined] | [null, T_2]>;
 };
 export default _default;

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

@@ -29,9 +29,11 @@ declare const _default: {
     logParse: (logStr: string) => string;
     logRString: (data: any) => Promise<string>;
     logRParse: (logStr: string) => Promise<string>;
-    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]>;
+    to: <T = any, U extends object = any>(promise: Promise<T>, errorExt?: object | undefined, fn?: Ddan.noop | undefined) => Promise<[null, T] | [U, undefined]>;
+    go: <T_1 = any>(task?: Ddan.PFunction<T_1> | undefined, fn?: Ddan.noop | undefined) => Promise<[any, undefined] | [null, T_1]>;
     delay: (ms?: number) => Promise<unknown>;
-    safeRun: <T_2 = any>(func: any) => Promise<[null, T_2] | [any, undefined]>;
+    safeRun: <T_2 = any>(func: any, fn?: Ddan.noop | undefined) => Promise<[null, T_2] | [any, undefined]>;
+    toError: (value: any) => any;
+    timeout: <T_3 = any>(task?: Ddan.PFunction<T_3> | undefined, ms?: number, desc?: string) => Promise<[any, undefined] | [null, T_3]>;
 };
 export default _default;

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

@@ -34,11 +34,12 @@ declare function radian2degree(radians: number): number;
  * @returns
  */
 declare function degree2radian(degrees: number): number;
-declare function formatMemory(mem: number): {
-    g: number;
-    m: number;
+declare function calcDataSize(data: number): {
+    gb: number;
+    mb: number;
     kb: number;
     b: number;
+    total: number;
     desc: string;
 };
 declare const _default: {
@@ -50,6 +51,6 @@ declare const _default: {
     float: typeof float;
     radian2degree: typeof radian2degree;
     degree2radian: typeof degree2radian;
-    formatMemory: typeof formatMemory;
+    calcDataSize: typeof calcDataSize;
 };
 export default _default;

package/bin/types/modules/node/socks5.d.ts

@@ -30,10 +30,14 @@ export declare class Socks5 {
     __event: DEvent;
     __pipeline: DPipeline;
     __logger: ILogger;
+    __totalReceived: number;
+    __totalSent: number;
     constructor(upstreamProxy: IProxyConfig, allowedDomains?: string[] | ['*'], debug?: boolean, logger?: ILogger);
     get id(): string;
     get port(): number;
     get url(): string;
+    get totalReceived(): number;
+    get totalSent(): number;
     validateProxyConfig(proxyConfig?: IProxyConfig): "" | "无效的上游代理 IP 地址" | "无效的上游代理端口" | "无效的上游代理用户名" | "无效的上游代理密码";
     start(startPort?: number): Promise<number>;
     setUpstreamProxy(upstreamProxy: IProxyConfig): boolean;
@@ -83,6 +87,7 @@ export declare class Socks5 {
     close(): void;
     on(name: Socks5EventType, listener: (...args: any[]) => void): void;
     off(name: Socks5EventType, listener: (...args: any[]) => void): void;
+    resetStatistics(): void;
     private _emit;
 }
 export {};

package/package.json

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