wenay-common 1.0.149 → 1.0.154

package/lib/Common/Listen.d.ts

@@ -1,26 +1,47 @@
 type tr222<T extends any[]> = (...r: T) => void;
-export declare function funcListenCallback<T extends any[]>(a: (e: tr222<T>) => (void | (() => void)), event?: (type: "add" | "remove", count: number) => void): {
+export declare function funcListenCallback<T extends any[]>(a: (e: tr222<T>) => (void | (() => void)), event?: (type: "add" | "remove", count: number, api: ReturnType<typeof funcListenCallback<T>>) => void): {
     lastUpdate: () => Date | null;
     lastUpdateMs: () => number | null;
     isRun: () => boolean;
     run: () => (() => void) | null;
     close: () => void;
-    addListen: (a: tr222<T>) => void;
+    addListen: (a: tr222<T>) => () => void;
     removeListen: (a: (tr222<T>) | null) => void;
     count: () => number;
 };
+type tr2<T extends (...a: any[]) => any> = (a: Parameters<T>[0]) => void;
+type t1<T extends any[] = any[]> = ReturnType<typeof funcListenCallback<T>>;
+type tt = tr2<Parameters<t1["addListen"]>[0]>;
+export declare function funcListenBySocket3<Z extends any[] = any[]>(e: t1<Z>, z: {
+    readonly status?: () => boolean;
+    readonly setEventClose?: (eventClose: () => any) => any;
+}): {
+    callback: (z: (a: Z[0]) => void) => void;
+    removeCallback: () => boolean;
+};
+export declare function funcListenBySocket2<Z extends any[] = any[]>(e: t1<Z>, { stop, setEventClose, status, paramsModify }: {
+    readonly status?: () => boolean;
+    readonly setEventClose?: (eventClose: () => any) => any;
+    readonly stop?: (x: tt) => any;
+    readonly paramsModify?: (...e: Parameters<tt>) => any[];
+}): {
+    callback: (z: (a: Z[0]) => void) => void;
+    removeCallback: () => boolean;
+};
 export declare function funcListenBySocket<Z extends any[] = any[]>(e: ReturnType<typeof funcListenCallback<Z>>, status: () => boolean): {
     callback: (z: (param: Parameters<Parameters<typeof e.addListen>[0]>[0]) => void) => void;
     removeCallback: () => boolean;
 };
 export declare const funcListenBySocket1: typeof funcListenBySocket;
-export declare function UseListen<T extends any[]>(): readonly [(...e: T) => void | undefined, {
+export declare function UseListen<T extends any[]>(data?: {
+    event?: Parameters<typeof funcListenCallback<T>>[1];
+}): readonly [(...e: T) => void | undefined, {
     lastUpdate: () => Date | null;
     lastUpdateMs: () => number | null;
     isRun: () => boolean;
     run: () => (() => void) | null;
     close: () => void;
-    addListen: (a: tr222<T>) => void;
+    addListen: (a: tr222<T>) => () => void;
     removeListen: (a: tr222<T> | null) => void;
     count: () => number;
 }];
@@ -38,4 +59,42 @@ export declare function PromiseArrayListen<T extends any = unknown>(array: ((()
         count: number;
     };
 };
+export type realSocket2<T extends any> = (data: {
+    callback: (data: T) => void;
+    [key: string]: any;
+}, ...b: any[]) => (any | (() => any));
+export type getTypeCallback<T extends realSocket2<any>> = T extends realSocket2<infer R> ? R : never;
+type ParametersOther<T extends (forget: any, ...args: any) => any> = T extends (forget: any, ...args: infer P) => any ? P : never;
+type tr22<T> = T extends undefined ? never : T;
+export declare function socketBuffer3<T extends realSocket2<any | any[]>, T2 extends (readonly unknown[]) | undefined, T3 extends {
+    [key: string]: unknown;
+}>(func: T, callbackMain: (data: getTypeCallback<T>, memo: T3) => T2, memo?: T3): (a: Omit<Parameters<T>[0], "callback"> & {
+    callback: (...data: tr22<T2>) => any;
+}, ...b: ParametersOther<T>) => ReturnType<T>;
+export declare function socketBufferBySnapshot<T extends realSocket2<any | any[]>, T2 extends (readonly unknown[]) | undefined, T3 extends {
+    [key: string]: unknown;
+}>({ func, memo, callbackSave, snapshot }: {
+    func: () => T;
+    callbackSave: (data: getTypeCallback<T>, memo: T3) => T2;
+    memo: T3;
+    snapshot?: (memo: T3) => T3;
+}): {
+    run: (a: tr222<[data: getTypeCallback<T>, memo: T3]>) => () => void;
+    snapshot: () => T3 | undefined;
+    memo: T3;
+    listenA: {
+        lastUpdate: () => Date | null;
+        lastUpdateMs: () => number | null;
+        isRun: () => boolean;
+        run: () => (() => void) | null;
+        close: () => void;
+        addListen: (a: tr222<[data: getTypeCallback<T>, memo: T3]>) => () => void;
+        removeListen: (a: tr222<[data: getTypeCallback<T>, memo: T3]> | null) => void;
+        count: () => number;
+    };
+    connect: () => void;
+    readonly disconnect: ((a: Omit<Parameters<T>[0], "callback"> & {
+        callback: (...data: tr22<T2>) => any;
+    }, ...b: ParametersOther<T>) => ReturnType<T>) | null;
+};
 export {};

package/lib/Common/Listen.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PromiseArrayListen = exports.UseListen = exports.funcListenBySocket1 = exports.funcListenBySocket = exports.funcListenCallback = void 0;
+exports.socketBufferBySnapshot = exports.socketBuffer3 = exports.PromiseArrayListen = exports.UseListen = exports.funcListenBySocket1 = exports.funcListenBySocket = exports.funcListenBySocket2 = exports.funcListenBySocket3 = exports.funcListenCallback = void 0;
 function funcListenCallback(a, event) {
     const obj = new Map;
     let close = null;
@@ -9,7 +9,7 @@ function funcListenCallback(a, event) {
         lastUpdate = Date.now();
         obj.forEach(e => e(...z));
     })) ?? null);
-    return {
+    const api = {
         lastUpdate: () => lastUpdate != null ? new Date(lastUpdate) : lastUpdate,
         lastUpdateMs: () => lastUpdate,
         isRun: () => close != null,
@@ -17,16 +17,66 @@ function funcListenCallback(a, event) {
         close: () => { close?.(); close = null; },
         addListen: (a) => {
             obj.set(a, a);
-            event?.("add", obj.size);
+            event?.("add", obj.size, api);
+            return () => api.removeListen(a);
         },
         removeListen: (a) => {
             obj.delete(a);
-            event?.("remove", obj.size);
+            event?.("remove", obj.size, api);
         },
         count: () => obj.size
     };
+    return api;
 }
 exports.funcListenCallback = funcListenCallback;
+function funcListenBySocket3(e, z) {
+    return funcListenBySocket2(e, { ...z, stop: x => x("___STOP"), paramsModify: (...e) => [e[0]] });
+}
+exports.funcListenBySocket3 = funcListenBySocket3;
+function funcListenBySocket2(e, { stop, setEventClose, status, paramsModify }) {
+    const { addListen, removeListen, count } = e;
+    const x = { x: null };
+    let r2 = null;
+    const removeCallback = () => {
+        if (x.x) {
+            stop?.(x.x);
+            x.x = null;
+        }
+        if (r2)
+            removeListen(r2);
+        return true;
+    };
+    return {
+        callback: (z) => {
+            if (x.x)
+                stop?.(x.x);
+            if (r2)
+                removeListen(r2);
+            x.x = z;
+            if (!z) {
+                console.log(z);
+                console.log(e.count());
+                console.trace();
+            }
+            let ta;
+            ta = z;
+            if (paramsModify) {
+                ta = (...a) => {
+                    const params = paramsModify(...a);
+                    z(...params);
+                };
+            }
+            if (status)
+                r2 = (a) => { status() ? ta(a) : removeListen(r2); };
+            else
+                r2 = (a) => ta(a);
+            addListen(r2);
+            setEventClose?.(() => removeCallback());
+        },
+        removeCallback
+    };
+}
+exports.funcListenBySocket2 = funcListenBySocket2;
 function funcListenBySocket(e, status) {
     const { addListen, removeListen, count } = e;
     let x = null;
@@ -59,9 +109,9 @@ function funcListenBySocket(e, status) {
 }
 exports.funcListenBySocket = funcListenBySocket;
 exports.funcListenBySocket1 = funcListenBySocket;
-function UseListen() {
+function UseListen(data) {
     let t = null;
-    const a = funcListenCallback((e) => { t = e; });
+    const a = funcListenCallback((e) => { t = e; }, data?.event);
     a.run();
     return [(...e) => t?.(...e), a];
 }
@@ -102,3 +152,35 @@ function PromiseArrayListen(array) {
     };
 }
 exports.PromiseArrayListen = PromiseArrayListen;
+function socketBuffer3(func, callbackMain, memo = {}) {
+    return (a, ...b) => func({ ...a, callback: (v) => { const z = callbackMain(v, memo); if (z)
+            a.callback(...z); }
+    }, ...b);
+}
+exports.socketBuffer3 = socketBuffer3;
+function socketBufferBySnapshot({ func, memo = {}, callbackSave, snapshot }) {
+    let d = null;
+    const [callback, listenA] = UseListen({
+        event: (type, count, api) => {
+            if (type == "remove" && count == 0) {
+                api.close();
+                d?.();
+            }
+            if (type == "add" && count == 1)
+                api.run();
+        }
+    });
+    const connect = () => {
+        if (d == null)
+            d = socketBuffer3(func(), callbackSave, memo)({ callback });
+    };
+    const run = (...params) => {
+        if (!listenA.isRun()) {
+            snapshot?.(memo);
+            connect();
+        }
+        return listenA.addListen(...params);
+    };
+    return { run, snapshot: () => snapshot?.(memo), memo, listenA, connect, get disconnect() { return d; } };
+}
+exports.socketBufferBySnapshot = socketBufferBySnapshot;

package/lib/Common/node_console.d.ts

@@ -2,3 +2,4 @@ export {};
 export declare function enable(flag?: boolean): void;
 export declare function disable(): void;
 export declare function __LineFile(lvl?: number): string;
+export declare function __LineFiles(lvlStart?: number, lvlEnd?: number | undefined): string[] | "";

package/lib/Common/node_console.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.__LineFile = exports.disable = exports.enable = void 0;
+exports.__LineFiles = exports.__LineFile = exports.disable = exports.enable = void 0;
 let _enabled = false;
 function enable(flag = true) { _enabled = flag; }
 exports.enable = enable;
@@ -74,3 +74,17 @@ function __LineFile(lvl = 0) {
     return `${e.getFileName()}:${e.getLineNumber()}:${e.getColumnNumber()}  ` + e.getFunctionName();
 }
 exports.__LineFile = __LineFile;
+function __LineFiles(lvlStart = 0, lvlEnd = 5) {
+    if (!_enabled) {
+        return "";
+    }
+    const originalPrepareStackTrace = Error.prepareStackTrace;
+    Error.prepareStackTrace = (_, stack) => stack;
+    let e = new Error().stack.slice(lvlStart + 1, lvlEnd);
+    if (wrapCallSite)
+        e = e.map(e => wrapCallSite(e));
+    const msgs = e.map(e => `${e.getFileName()}:${e.getLineNumber()}:${e.getColumnNumber()}  ` + e.getFunctionName());
+    Error.prepareStackTrace = originalPrepareStackTrace;
+    return msgs;
+}
+exports.__LineFiles = __LineFiles;

package/lib/test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/test.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const wenay_common_1 = require("wenay-common");
+const Listen_1 = require("./Common/Listen");
+function testSocketBufferBySnapshot() {
+    function snapshot() {
+        return {
+            a: 3,
+            b: 4,
+            c: 10
+        };
+    }
+    function tt(a, key, time) {
+        const [startTime, endTime] = [Date.now(), Date.now() + time];
+        return ({ callback }) => {
+            let t = true;
+            async function re() {
+                const step = Math.round((Math.random()) * 500);
+                await (0, wenay_common_1.sleepAsync)(step);
+                a += Math.round((Math.random() - 0.5) * 100);
+                callback({ [key]: a });
+                if (Date.now() < endTime && t)
+                    return re();
+            }
+            re();
+            return () => {
+                console.log("tttt");
+                t = false;
+            };
+        };
+    }
+    const memo = {};
+    const c1 = tt(5, "a", 10000);
+    const test = (0, Listen_1.socketBufferBySnapshot)({
+        func: () => c1,
+        memo,
+        callbackSave: (data, memo1) => {
+            Object.entries(data).forEach(([key, value]) => memo[key] = value);
+            return [data, memo1];
+        },
+        snapshot: (memo) => {
+            Object.entries(snapshot()).forEach(([key, value]) => memo[key] = value);
+            return memo;
+        }
+    });
+    test.snapshot();
+    console.log(test.memo);
+    const t = test.run((a, m) => {
+        console.log(a, m);
+    });
+    const t1 = test.run((a, m) => {
+        console.log(a, m);
+    });
+    (0, wenay_common_1.sleepAsync)(2000)
+        .then(() => {
+        t();
+        console.log("stop t");
+    });
+    (0, wenay_common_1.sleepAsync)(3000)
+        .then(() => {
+        t1();
+        console.log("stop t");
+    });
+}
+testSocketBufferBySnapshot();

package/lib/tsconfig.json

@@ -0,0 +1,6 @@
+{
+  "compilerOptions": {
+    "module": "commonJS",
+    "target": "esnext"
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wenay-common",
-  "version": "1.0.149",
+  "version": "1.0.154",
   "description": "Common library",
   "strict": true,
   "main": "lib/index.js",