wenay-common2 1.0.22 → 1.0.24

package/lib/Common/events/Listen.d.ts

@@ -1,8 +1,9 @@
 export type Listener<T extends any[]> = (...r: T) => void;
-type NormalizeTuple<T> = T extends any[] ? T : [T];
+export type NormalizeTuple<T> = T extends any[] ? T : [T];
 export declare function funcListenCallbackBase<T>(b: (e: Listener<NormalizeTuple<T>>) => (void | (() => void)), data?: {
     event?: (type: "add" | "remove", count: number, api: ReturnType<typeof funcListenCallbackBase<T>>) => void;
     fast?: boolean;
+    addListenClose?: ReturnType<typeof funcListenCallbackBase<any>>;
 }): {
     func: Listener<NormalizeTuple<T>>;
     isRun: () => boolean;
@@ -52,4 +53,3 @@ export declare function UseListen<T>(data?: Parameters<typeof funcListenCallback
     readonly getAllKeys: Listener<NormalizeTuple<T>>[];
 }];
 export declare function isListenCallback(obj: any): obj is ReturnType<typeof funcListenCallbackBase>;
-export {};

package/lib/Common/events/Listen.js

@@ -6,13 +6,14 @@ exports.funcListenCallback = funcListenCallback;
 exports.UseListen = UseListen;
 exports.isListenCallback = isListenCallback;
 function funcListenCallbackBase(b, data) {
-    const { fast = true, event } = data ?? {};
+    const { fast = true, event, addListenClose } = data ?? {};
     const obj = new Map();
     const evClose = new Map();
     const sinh = new Map();
     let a = (...e) => { obj.forEach(z => z(...e)); };
     let close = null;
     let cached = null;
+    let closeUnsubscribe = null;
     const getArr = () => cached ?? (cached = Array.from(obj.values()));
     const rebuild = () => {
         cached = null;
@@ -37,7 +38,14 @@ function funcListenCallbackBase(b, data) {
         });
     };
     const func = (...e) => { a?.(...e); };
-    const run = () => { close = (b(func) ?? (() => { })); };
+    const run = () => {
+        close = (b(func) ?? (() => { }));
+        if (addListenClose && !closeUnsubscribe) {
+            closeUnsubscribe = addListenClose.addListen(() => {
+                api.close();
+            });
+        }
+    };
     const api = {
         func,
         isRun: () => close !== null,
@@ -51,6 +59,10 @@ function funcListenCallbackBase(b, data) {
             sinh.clear();
             evClose.forEach(cb => cb());
             evClose.clear();
+            if (closeUnsubscribe) {
+                closeUnsubscribe();
+                closeUnsubscribe = null;
+            }
         },
         eventClose: (cb) => {
             evClose.set(cb, cb);

package/lib/Common/events/UseListenTransform.d.ts

@@ -0,0 +1,15 @@
+import { funcListenCallbackBase, Listener, NormalizeTuple } from "./Listen";
+export declare function UseListenTransform<TSource extends any[], TTarget extends any[]>(sourceListen: ReturnType<typeof funcListenCallbackBase<TSource>>, transform: (...args: NormalizeTuple<TSource>) => TTarget | null, options?: {
+    addListenClose?: ReturnType<typeof funcListenCallbackBase<any>>;
+}): readonly [(...a: NormalizeTuple<TTarget>) => void, {
+    func: Listener<NormalizeTuple<TTarget>>;
+    isRun: () => boolean;
+    run: () => void;
+    close: () => void;
+    eventClose: (cb: () => void) => () => void;
+    removeEventClose: (cb: () => void) => void;
+    addListen: (cb: Listener<NormalizeTuple<TTarget>>, cbClose?: (() => void) | undefined) => () => void;
+    removeListen: (cb: Listener<NormalizeTuple<TTarget>> | null) => void;
+    count: () => number;
+    readonly getAllKeys: Listener<NormalizeTuple<TTarget>>[];
+}];

package/lib/Common/events/UseListenTransform.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UseListenTransform = UseListenTransform;
+const Listen_1 = require("./Listen");
+function UseListenTransform(sourceListen, transform, options) {
+    let unsubscribeFromSource = null;
+    const [emit, targetListen] = (0, Listen_1.UseListen)({
+        event: (type, count, api) => {
+            if (type === "add" && count === 1) {
+                const sourceCallback = (...args) => {
+                    const result = transform(...args);
+                    if (result !== null) {
+                        emit(...result);
+                    }
+                };
+                unsubscribeFromSource = sourceListen.addListen(sourceCallback);
+            }
+            if (type === "remove" && count === 0) {
+                if (unsubscribeFromSource) {
+                    unsubscribeFromSource();
+                    unsubscribeFromSource = null;
+                }
+            }
+        },
+        addListenClose: options?.addListenClose
+    });
+    return [emit, targetListen];
+}

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

@@ -9,8 +9,9 @@ export type RpcDescriptor<T extends object> = {
 };
 export declare function rpc<T extends object>(socketKey?: string): RpcDescriptor<T>;
 export declare function createRpcClientHub<T extends Record<string, RpcDescriptor<any>>>(createSocket: (token: string | null) => RpcHubSocket, schemaBuilder: (helper: typeof rpc) => T): {
+    readonly promise: Promise<void>;
     facade: { [K_1 in keyof { [K in keyof T]: T[K] extends RpcDescriptor<infer U extends object> ? import("./rpc-client").RpcClientReturn<DeepSocketListenSmart<U>> : never; }]: { [K in keyof T]: T[K] extends RpcDescriptor<infer U extends object> ? import("./rpc-client").RpcClientReturn<DeepSocketListenSmart<U>> : never; }[K_1] | null; };
-    setToken: (token: string | null) => void;
+    setToken: (token: string | null) => any;
     onConnect: (func?: ((count: number) => void) | null) => void;
     connectCount: () => number;
 };

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

@@ -15,6 +15,7 @@ function createRpcClientHub(createSocket, schemaBuilder) {
     let socket = null;
     let connectCount = 0;
     let onConnectCb = null;
+    let promise = Promise.resolve();
     function setToken(token) {
         socket?.disconnect?.();
         socket = createSocket(token);
@@ -26,15 +27,21 @@ function createRpcClientHub(createSocket, schemaBuilder) {
                 client.initStrict();
             }
         }
-        socket.on("connect", () => {
-            connectCount++;
-            onConnectCb?.(connectCount);
+        promise = new Promise((resolve) => {
+            socket?.on("connect", () => {
+                connectCount++;
+                onConnectCb?.(connectCount);
+                resolve();
+            });
         });
+        return result;
     }
-    return {
+    const result = {
+        get promise() { return promise; },
         facade,
         setToken,
         onConnect: (func) => { onConnectCb = func ?? null; },
         connectCount: () => connectCount,
     };
+    return result;
 }

package/lib/index.d.ts

@@ -16,6 +16,7 @@ export * from "./Common/events/event";
 export * from "./Common/events/SocketBuffer";
 export * from "./Common/events/SocketServerHook";
 export * from "./Common/events/joinListens";
+export * from "./Common/events/UseListenTransform";
 export * from "./Common/rcp/rpc-index";
 export * from "./server/fsKeyVolume";
 export * from "./Common/Color";

package/lib/index.js

@@ -55,6 +55,7 @@ __exportStar(require("./Common/events/event"), exports);
 __exportStar(require("./Common/events/SocketBuffer"), exports);
 __exportStar(require("./Common/events/SocketServerHook"), exports);
 __exportStar(require("./Common/events/joinListens"), exports);
+__exportStar(require("./Common/events/UseListenTransform"), exports);
 __exportStar(require("./Common/rcp/rpc-index"), exports);
 __exportStar(require("./server/fsKeyVolume"), exports);
 __exportStar(require("./Common/Color"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wenay-common2",
-  "version": "1.0.22",
+  "version": "1.0.24",
   "description": "Common library",
   "strict": true,
   "main": "lib/index.js",