wenay-common2 1.0.45 → 1.0.48

package/lib/Common/rcp/listen-socket.js

@@ -4,12 +4,51 @@ exports.listenSocket = listenSocket;
 exports.listenSocketFirst = listenSocketFirst;
 exports.listenSocketAll = listenSocketAll;
 exports.listenSocketSmart = listenSocketSmart;
+const rpc_protocol_1 = require("./rpc-protocol");
+const rpc_off_1 = require("./rpc-off");
+function createThrottleLatest(ms, sink) {
+    let timer = null;
+    let pending = null;
+    let killed = false;
+    function flush() {
+        timer = null;
+        if (pending) {
+            const a = pending;
+            pending = null;
+            emit(...a);
+        }
+    }
+    function emit(...a) {
+        sink(...a);
+        if (!killed)
+            timer = setTimeout(flush, ms);
+    }
+    function push(...a) {
+        if (killed)
+            return;
+        if (timer) {
+            pending = a;
+            return;
+        }
+        emit(...a);
+    }
+    function cancel() {
+        killed = true;
+        if (timer) {
+            clearTimeout(timer);
+            timer = null;
+        }
+        pending = null;
+    }
+    return { push, cancel };
+}
 function listenSocket(e, d) {
-    const { stop, addListenClose, status, paramsModify } = d ?? {};
+    const { stop, addListenClose, status, paramsModify, throttle } = d ?? {};
     const { addListen, removeListen, eventClose, removeEventClose } = e;
     let last = null;
     let active = null;
     let resolveWait = null;
+    let throttleCh = null;
     function finish() {
         if (resolveWait) {
             resolveWait();
@@ -17,6 +56,10 @@ function listenSocket(e, d) {
         }
     }
     function removeCallback() {
+        if (throttleCh) {
+            throttleCh.cancel();
+            throttleCh = null;
+        }
         if (last) {
             stop?.(last);
             last = null;
@@ -29,7 +72,10 @@ function listenSocket(e, d) {
         finish();
         return true;
     }
-    async function callback(z) {
+    function callback(z) {
+        if (typeof z !== "function") {
+            throw new TypeError("listenSocket.callback expects a function");
+        }
         if (last)
             stop?.(last);
         if (active)
@@ -53,9 +99,20 @@ function listenSocket(e, d) {
                     removeCallback();
             };
         }
-        const inner = handler;
+        let inner = handler;
+        if (throttle) {
+            if (throttleCh)
+                throttleCh.cancel();
+            const ch = createThrottleLatest(throttle, (...a) => handler(...a));
+            throttleCh = ch;
+            inner = (...a) => ch.push(...a);
+        }
         active = (...a) => {
-            if (a[0] === "___STOP") {
+            if (a[0] === rpc_protocol_1.RPC_STOP) {
+                if (throttleCh) {
+                    throttleCh.cancel();
+                    throttleCh = null;
+                }
                 z(...a);
                 if (last) {
                     stop?.(last);
@@ -73,11 +130,36 @@ function listenSocket(e, d) {
         };
         addListen(active, { cbClose: removeCallback });
         addListenClose?.addListen(removeCallback);
-        return new Promise((resolve) => {
+        const wait = new Promise((resolve) => {
             resolveWait = () => { resolve(); };
         });
+        return (0, rpc_off_1.makeOff)(wait, removeCallback, { unsubscribe: removeCallback, removeCallback });
+    }
+    function once(z) {
+        if (typeof z !== "function") {
+            throw new TypeError("listenSocket.once expects a function");
+        }
+        let fired = false;
+        const oneShot = ((...a) => {
+            if (a[0] === rpc_protocol_1.RPC_STOP) {
+                removeCallback();
+                return;
+            }
+            if (fired)
+                return;
+            fired = true;
+            try {
+                z(...a);
+            }
+            finally {
+                (0, rpc_off_1.endCallback)(z);
+                removeCallback();
+            }
+        });
+        return callback(oneShot);
     }
-    return { callback, removeCallback };
+    function closeStream() { e.close?.(); }
+    return { callback, removeCallback, on: callback, once, close: closeStream };
 }
 function listenSocketFirst(e, options) {
     const r = listenSocket(e, {
@@ -86,6 +168,9 @@ function listenSocketFirst(e, options) {
     });
     return {
         callback: r.callback,
+        on: r.callback,
+        once: r.once,
+        close: r.close,
         removeCallback: r.removeCallback,
     };
 }
@@ -93,6 +178,9 @@ function listenSocketAll(e, options) {
     const r = listenSocket(e, { ...options });
     return {
         callback: r.callback,
+        on: r.callback,
+        once: r.once,
+        close: r.close,
         removeCallback: r.removeCallback,
     };
 }
@@ -100,6 +188,9 @@ function listenSocketSmart(e, options) {
     const r = listenSocket(e, { ...options });
     return {
         callback: r.callback,
+        on: r.callback,
+        once: r.once,
+        close: r.close,
         removeCallback: r.removeCallback,
     };
 }

package/lib/Common/rcp/oldCommonsServer.d.ts

@@ -101,7 +101,7 @@ export declare function CreatAPIFacadeClientOld<T extends object>({ socketKey, s
     infoStrictly(): any;
     strictlyInit(obj?: object): Promise<unknown>;
 };
-export declare function CreatAPIFacadeServerOld<T extends object>({ object, socket, socketKey, debug }: {
+export declare function CreatAPIFacadeServerOld<T extends object>(params: {
     socket: tSocket;
     object: T;
     socketKey: string;

package/lib/Common/rcp/oldCommonsServer.js

@@ -9,7 +9,11 @@ exports.CreatAPIFacadeClientOld = CreatAPIFacadeClientOld;
 exports.CreatAPIFacadeServerOld = CreatAPIFacadeServerOld;
 exports.fMiniTest = fMiniTest;
 const common_1 = require("../core/common");
+const old_ommonsServerMini_1 = require("./old\u0421ommonsServerMini");
 function funcPromiseServer(data, obj) {
+    return (0, old_ommonsServerMini_1.promiseServer)(data, obj);
+}
+function funcPromiseServerOld(data, obj) {
     const buf = data;
     data.api({
         onMessage: async (datum) => {
@@ -86,6 +90,9 @@ function funcPromiseServer2(sendMessage, obj) {
     };
 }
 function funcForWebSocket(data) {
+    return (0, old_ommonsServerMini_1.wsWrapper)(data);
+}
+function funcForWebSocketOld(data) {
     const limit = data.limit;
     const sendMessage = data.sendMessage;
     const free = (() => {
@@ -122,6 +129,7 @@ function funcForWebSocket(data) {
                 if (data.data == "___STOP") {
                     callbackMany.delete(mapId);
                     free.numsSet(mapId);
+                    return;
                 }
                 buf?.(data.data);
             }
@@ -188,6 +196,9 @@ function funcForWebSocket(data) {
     };
 }
 function funcScreenerClient2(data, wait) {
+    return (0, old_ommonsServerMini_1.createClientProxy)(data, wait);
+}
+function funcScreenerClient2Old(data, wait) {
     const tr = (address) => new Proxy((() => { }), {
         get(target, p, receiver) {
             address.push(p);
@@ -328,7 +339,10 @@ function CreatAPIFacadeClientOld({ socketKey, socket, limit }) {
         }
     };
 }
-function CreatAPIFacadeServerOld({ object, socket, socketKey, debug = false }) {
+function CreatAPIFacadeServerOld(params) {
+    return (0, old_ommonsServerMini_1.createAPIFacadeServer)(params);
+}
+function CreatAPIFacadeServerOldImpl({ object, socket, socketKey, debug = false }) {
     function ff(obj) {
         return Object.fromEntries(Object.entries(obj).map(([k, v]) => {
             return [

package/lib/Common/rcp/old/320/241ommonsServerMini.js

@@ -150,6 +150,7 @@ function wsWrapper(soc) {
                 if (msg.data === "___STOP") {
                     cbsMap.delete(id);
                     pool.release(id);
+                    return;
                 }
                 cb(msg.data);
             }

package/lib/Common/rcp/rpc-caps.d.ts

@@ -0,0 +1,10 @@
+export declare const Caps: {
+    readonly COMPACT: number;
+};
+export type tCaps = number;
+export declare const CAPS_ALL: tCaps;
+export declare const hasCap: (caps: tCaps, c: number) => boolean;
+export type RpcOpt = {
+    compact?: boolean;
+};
+export declare function optToCaps(opt?: RpcOpt): tCaps;

package/lib/Common/rcp/rpc-caps.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasCap = exports.CAPS_ALL = exports.Caps = void 0;
+exports.optToCaps = optToCaps;
+exports.Caps = {
+    COMPACT: 1 << 0,
+};
+exports.CAPS_ALL = exports.Caps.COMPACT;
+const hasCap = (caps, c) => (caps & c) === c;
+exports.hasCap = hasCap;
+function optToCaps(opt) {
+    let c = exports.CAPS_ALL;
+    if (opt?.compact === false)
+        c &= ~exports.Caps.COMPACT;
+    return c;
+}

package/lib/Common/rcp/rpc-client.d.ts

@@ -1,4 +1,7 @@
 import { type SocketTmpl } from "./rpc-protocol";
+import { type RpcLimits } from "./rpc-limits";
+import { makeOff } from "./rpc-off";
+import { type RpcOpt } from "./rpc-caps";
 type UnwrapPromise<T> = T extends Promise<infer R> ? R : T;
 export type DeepDataOnly<T> = T extends Function ? never : T extends Array<infer U> ? Array<DeepDataOnly<U>> : T extends object ? {
     [K in keyof T as T[K] extends Function ? never : K]: DeepDataOnly<T[K]>;
@@ -24,6 +27,10 @@ type ClientApiHandle = {
     clearCallbacks: () => void;
     remove: (fn: Function) => void;
     end: (fn: Function) => void;
+    subscriptions: () => {
+        key: string;
+        consumers: number;
+    }[];
 };
 export type RpcClientReturn<T extends object> = {
     func: ClientAPIAll<T>;
@@ -34,13 +41,28 @@ export type RpcClientReturn<T extends object> = {
     strict: ClientAPIStrict<T>;
     api: ClientApiHandle;
     abortAll: (reason: string) => void;
+    dispose: (reason?: string, opts?: {
+        socketAlive?: boolean;
+    }) => void;
+    close: (reason?: string, opts?: {
+        socketAlive?: boolean;
+    }) => void;
     schema: () => any;
     readyStrict: () => Promise<void>;
+    ready: () => Promise<void>;
     initStrict: (obj?: object) => Promise<void>;
+    init: (obj?: object) => Promise<void>;
+    reauth: (token: any) => Promise<any>;
+    auth: () => Promise<any>;
+    onDisconnect: (cb: (reason: string) => void) => ReturnType<typeof makeOff>;
 };
-export declare function createRpcClient<T extends object>({ socket, socketKey: key, limit }: {
+export declare function createRpcClient<T extends object>({ socket, socketKey: key, limit, limits, dedupeListen, token, opt }: {
     socket: SocketTmpl;
     socketKey: string;
     limit?: number;
+    limits?: RpcLimits;
+    dedupeListen?: boolean;
+    token?: any;
+    opt?: RpcOpt;
 }): RpcClientReturn<T>;
 export type { ClientApiHandle };