wenay-common2 1.0.34 → 1.0.37

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

@@ -3,15 +3,6 @@ import { type PromiseServerHooks, type RpcLimits } from "./rpc-server";
 import { DeepSocketListen } from "./listen-deep";
 import { type SocketTmpl } from "./rpc-protocol";
 type ListenCallbackBase<T extends any[] = any[]> = ReturnType<typeof funcListenCallbackBase<T>>;
-export declare function createRpcServerAuto<T extends object>({ socket, object: target, socketKey: key, debug, hooks, disconnectListen, limits }: {
-    socket: SocketTmpl;
-    object: T;
-    socketKey: string;
-    debug?: boolean;
-    hooks?: Omit<PromiseServerHooks<DeepSocketListen<T>>, "resolveTransform">;
-    disconnectListen?: ListenCallbackBase<any>;
-    limits?: RpcLimits;
-}): void;
 type ClientProtocol = 'v2' | 'legacy' | null;
 export declare function createRpcServerAuto2<T extends object>({ socket, object: target, socketKey: key, debug, hooks, disconnectListen, limits, onProtocolDetect, }: {
     socket: SocketTmpl;

package/lib/Common/rcp/createRpcServerAutoWithProtocolDetection.js

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createRpcServerAuto = createRpcServerAuto;
 exports.createRpcServerAuto2 = createRpcServerAuto2;
 const Listen_1 = require("../events/Listen");
 const listen_socket_1 = require("./listen-socket");
 const rpc_server_1 = require("./rpc-server");
 const rpc_protocol_1 = require("./rpc-protocol");
 const old_ommonsServerMini_1 = require("./old\u0421ommonsServerMini");
+const rpc_dynamic_1 = require("./rpc-dynamic");
+const rpc_limits_1 = require("./rpc-limits");
 function createRpcServerAuto({ socket, object: target, socketKey: key, debug, hooks, disconnectListen, limits }) {
     const cache = new WeakMap();
     function getListenSocket(parent, disconnectListen) {
@@ -45,37 +46,48 @@ function createRpcServerAuto2({ socket, object: target, socketKey: key, debug =
         return getListenSocket(obj);
     }
     function transformTree(obj) {
-        if (obj == null || typeof obj === 'function')
-            return obj;
-        if (typeof obj !== 'object')
-            return obj;
-        const transformed = resolveTransform(obj);
-        if (transformed !== obj)
-            return transformed;
+        let current = obj;
+        if (!(0, rpc_dynamic_1.isNoStrict)(current)) {
+            current = resolveTransform(current);
+        }
+        if (current == null || typeof current !== 'object' || (0, rpc_dynamic_1.isNoStrict)(current))
+            return current;
         const out = {};
-        for (const k of Object.keys(obj)) {
-            const v = obj[k];
-            if (typeof v === 'function')
-                out[k] = v;
-            else if (v != null && typeof v === 'object')
-                out[k] = transformTree(v);
-            else
+        for (const k of Object.keys(current)) {
+            if (!(0, rpc_limits_1.isSafeKey)(k))
+                continue;
+            const v = current[k];
+            if ((0, rpc_dynamic_1.isNoStrict)(v)) {
                 out[k] = v;
+                continue;
+            }
+            out[k] = typeof v === 'function' ? v : (v != null && typeof v === 'object') ? transformTree(v) : v;
         }
         return out;
     }
     function serialize(obj) {
         const out = {};
         for (const k of Object.keys(obj)) {
+            if (!(0, rpc_limits_1.isSafeKey)(k))
+                continue;
             const v = obj[k];
-            if (v == null)
-                out[k] = 'null';
-            else if (typeof v === 'function')
-                out[k] = 'func';
-            else if (typeof v === 'object')
-                out[k] = serialize(v);
-            else
-                out[k] = 'unknown';
+            switch (true) {
+                case v == null:
+                    out[k] = 'null';
+                    break;
+                case (0, rpc_dynamic_1.isNoStrict)(v):
+                    out[k] = 'dynamic';
+                    break;
+                case typeof v === 'function':
+                    out[k] = 'func';
+                    break;
+                case typeof v === 'object':
+                    out[k] = serialize(v);
+                    break;
+                default:
+                    out[k] = 'unknown';
+                    break;
+            }
         }
         return out;
     }

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

@@ -14,6 +14,11 @@ function createClient(socket, key, opts) {
     let strictData = {};
     let strictWaiters = [];
     let debug = false;
+    const unpackResult = (v) => {
+        if (!v)
+            return v;
+        return v;
+    };
     socket.on(key, (msg) => {
         if (!Array.isArray(msg))
             return;
@@ -28,7 +33,7 @@ function createClient(socket, key, opts) {
                     callbacks.delete(cbId);
                     pool.release(cbId);
                 }
-                msg[3] ? req.fail(msg[3]) : req.ok(msg[2]);
+                msg[3] ? req.fail(msg[3]) : req.ok(unpackResult(msg[2]));
                 break;
             }
             case rpc_protocol_1.Pkt.CB: {

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

@@ -8,11 +8,11 @@ export type RpcDescriptor<T extends object> = {
     __type?: T;
 };
 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): {
+export declare function createRpcClientHub<T extends Record<string, RpcDescriptor<any>>, T2 extends RpcHubSocket>(createSocket: (token: string | null) => T2, schemaBuilder: (helper: typeof rpc) => T): {
     readonly promise: Promise<{ [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]; }>;
     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]; };
     setToken: (token: string | null) => Promise<{ [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]; }>;
-    readonly socket: RpcHubSocket | null;
+    readonly socket: T2;
     onConnect: (func?: ((count: number) => void) | null) => void;
     connectCount: () => number;
 };

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

@@ -23,12 +23,18 @@ function createRpcClientHub(createSocket, schemaBuilder) {
             const targetSocketKey = schema[key].socketKey || key;
             const client = (0, rpc_client_1.createRpcClient)({ socketKey: targetSocketKey, socket });
             facade[key] = client;
-            if (client && typeof client.initStrict === "function") {
-                client.initStrict();
+        }
+        function hi() {
+            for (const key in schema) {
+                const client = facade[key];
+                if (client && typeof client.initStrict === "function") {
+                    client.initStrict();
+                }
             }
         }
         socket?.on("connect", () => {
             connectCount++;
+            hi();
             onConnectCb?.(connectCount);
             if (resolveFunc) {
                 const a = resolveFunc;

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

@@ -186,13 +186,13 @@ function createServer(socket, key, target, hooks, limits) {
                     current = await current;
                 }
                 if (wait)
-                    send([rpc_protocol_1.Pkt.RESP, reqId, current]);
+                    send([rpc_protocol_1.Pkt.RESP, reqId, (0, rpc_walk_1.packResult)(current)]);
             }
             else {
                 const args = (0, rpc_walk_1.unpack)(rawArgsOrSteps, (cbId, cbArgs) => send([rpc_protocol_1.Pkt.CB, cbId, cbArgs]), (cbId) => send([rpc_protocol_1.Pkt.CB_END, cbId]), lim);
                 const res = await fn.apply(ctx, args);
                 if (wait)
-                    send([rpc_protocol_1.Pkt.RESP, reqId, res]);
+                    send([rpc_protocol_1.Pkt.RESP, reqId, (0, rpc_walk_1.packResult)(res)]);
             }
         }
         catch (e) {

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

@@ -2,7 +2,9 @@ import { idPool } from "../id-pool";
 import { type RpcLimits } from "./rpc-limits";
 export declare function walk(val: any, onLeaf: (v: any) => any, lim?: Required<RpcLimits>, depth?: number): any;
 export declare function pack(args: any[], pool: idPool, cbStore: Map<number, Function>, cbIds: number[]): any[];
+export declare function packResult(value: any): any;
 export declare function rpcEndCallback(fn: Function): void;
 export declare function unpack(args: any[], sender: (id: number, a: any[]) => void, onEnd: (id: number) => void, lim?: Required<RpcLimits>): any[];
+export declare function unpackResult(value: any, lim?: Required<RpcLimits>): any;
 export declare const errToObj: (e: any) => any;
 export declare const resolveCA: (path: string[], args: any[]) => [string[], any[]];

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

@@ -3,10 +3,32 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveCA = exports.errToObj = void 0;
 exports.walk = walk;
 exports.pack = pack;
+exports.packResult = packResult;
 exports.rpcEndCallback = rpcEndCallback;
 exports.unpack = unpack;
+exports.unpackResult = unpackResult;
 const rpc_limits_1 = require("./rpc-limits");
 const FN_MARKER = "$_f";
+const DATE_MARKER = "$_d";
+const MAP_MARKER = "$_m";
+const SET_MARKER = "$_s";
+const REGEXP_MARKER = "$_r";
+const BIGINT_MARKER = "$_b";
+const ALL_MARKERS = new Set([FN_MARKER, DATE_MARKER, MAP_MARKER, SET_MARKER, REGEXP_MARKER, BIGINT_MARKER]);
+const DESERIALIZERS = {
+    [DATE_MARKER]: (v) => new Date(v),
+    [MAP_MARKER]: (v) => new Map(v),
+    [SET_MARKER]: (v) => new Set(v),
+    [REGEXP_MARKER]: (v) => new RegExp(v.source, v.flags),
+    [BIGINT_MARKER]: (v) => BigInt(v),
+};
+const SERIALIZERS = [
+    (v) => v instanceof Date ? [DATE_MARKER, v.valueOf()] : null,
+    (v) => v instanceof Map ? [MAP_MARKER, Array.from(v.entries())] : null,
+    (v) => v instanceof Set ? [SET_MARKER, Array.from(v.values())] : null,
+    (v) => v instanceof RegExp ? [REGEXP_MARKER, { source: v.source, flags: v.flags }] : null,
+    (v) => typeof v === "bigint" ? [BIGINT_MARKER, v.toString()] : null,
+];
 function walk(val, onLeaf, lim, depth = 0) {
     if (lim) {
         if (depth > lim.maxDepth)
@@ -16,7 +38,7 @@ function walk(val, onLeaf, lim, depth = 0) {
     }
     if (val == null || typeof val !== "object")
         return onLeaf(val);
-    if (val[FN_MARKER] !== undefined)
+    if (ALL_MARKERS.has(Object.keys(val)[0]))
         return onLeaf(val);
     if (Array.isArray(val)) {
         if (lim && val.length > lim.maxArrayLen)
@@ -32,6 +54,26 @@ function walk(val, onLeaf, lim, depth = 0) {
             o[k] = walk(val[k], onLeaf, lim, depth + 1);
     return o;
 }
+function deserializeLeaf(leaf, onCallback) {
+    if (leaf == null || typeof leaf !== "object")
+        return leaf;
+    const key = Object.keys(leaf)[0];
+    if (!key)
+        return leaf;
+    if (key === FN_MARKER) {
+        return onCallback?.(leaf[FN_MARKER]) ?? leaf;
+    }
+    const deserialize = DESERIALIZERS[key];
+    return deserialize ? deserialize(leaf[key]) : leaf;
+}
+function serializeLeaf(leaf) {
+    for (const serializer of SERIALIZERS) {
+        const result = serializer(leaf);
+        if (result)
+            return { [result[0]]: result[1] };
+    }
+    return leaf;
+}
 function pack(args, pool, cbStore, cbIds) {
     return args.map(v => walk(v, leaf => {
         if (typeof leaf == "function") {
@@ -40,9 +82,12 @@ function pack(args, pool, cbStore, cbIds) {
             cbIds.push(id);
             return { [FN_MARKER]: id };
         }
-        return leaf;
+        return serializeLeaf(leaf);
     }));
 }
+function packResult(value) {
+    return walk(value, leaf => serializeLeaf(leaf));
+}
 const _stopRegistry = new WeakMap();
 function rpcEndCallback(fn) {
     _stopRegistry.get(fn)?.();
@@ -66,9 +111,12 @@ function unpack(args, sender, onEnd, lim) {
             _stopRegistry.set(wrapper, () => onEnd(id));
             return wrapper;
         }
-        return leaf;
+        return deserializeLeaf(leaf);
     }, lim));
 }
+function unpackResult(value, lim) {
+    return walk(value, leaf => deserializeLeaf(leaf), lim);
+}
 const errToObj = (e) => e instanceof Error ? { name: e.name, message: e.message, stack: e.stack } : e;
 exports.errToObj = errToObj;
 const resolveCA = (path, args) => {

package/package.json

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