lz-nframe 1.0.0

package/lib/NWSSocket.d.ts

@@ -0,0 +1,23 @@
+/*******************************************************************************
+文件: NWSSocket.ts
+创建: 2022年06月21日
+作者: 老张
+描述:
+    基于ws模块，另外nodejs还有socket.io模块可以实现ws
+
+websocket事件：
+    ✦onopen  网络连接建立时触发该事件
+    ✦onerror 网络发生错误时触发该事件
+    ✦onclose websocket关闭时触发该事件
+    ✦onmessage 接收到消息
+*******************************************************************************/
+import WebSocket from 'ws';
+export declare class NWSSocket extends WebSocket {
+    /** 连接id，当前时间线程内全局唯一，若线程重启，生成的会与之前重复 */
+    linkId: string;
+    /** 最近活动时间 */
+    actTime: number;
+    /** 最近心跳检测时间 */
+    heartbeatCheckTime: number;
+    static genUniqueId(): string;
+}

package/lib/NWSSocket.js

@@ -0,0 +1,30 @@
+/*******************************************************************************
+文件: NWSSocket.ts
+创建: 2022年06月21日
+作者: 老张
+描述:
+    基于ws模块，另外nodejs还有socket.io模块可以实现ws
+
+websocket事件：
+    ✦onopen  网络连接建立时触发该事件
+    ✦onerror 网络发生错误时触发该事件
+    ✦onclose websocket关闭时触发该事件
+    ✦onmessage 接收到消息
+*******************************************************************************/
+import WebSocket from 'ws';
+let autoIncId = 0;
+export class NWSSocket extends WebSocket {
+    constructor() {
+        super(...arguments);
+        /** 连接id，当前时间线程内全局唯一，若线程重启，生成的会与之前重复 */
+        this.linkId = '';
+        /** 最近活动时间 */
+        this.actTime = 0;
+        /** 最近心跳检测时间 */
+        this.heartbeatCheckTime = 0;
+    }
+    static genUniqueId() {
+        autoIncId++;
+        return 'ws' + autoIncId;
+    }
+}

package/lib/NWSUserClientJ.d.ts

@@ -0,0 +1,76 @@
+/*******************************************************************************
+文件: NWSUserClientJ.ts
+创建: 2026年05月08日
+作者: 老张
+描述:
+    J含义为JSON.
+    面向 Node.js 的 WebSocket 客户端，与 NWSUserMgrJ 配套使用。
+    基于 JSON 帧通讯：{ "c": 命令, "d": 参数 }，内置 _si_（登录）、_hb_（心跳）。
+
+    参考：Cocos Creator 下的 XWebSocket；此处去掉 cc.EventTarget / xfire 依赖，
+    使用 EventEmitter；传输层统一委托 NWSClient（内部使用 ws / NWSSocket）。
+
+内置命令（与 NWSUserMgrJ 一致）：
+    ✦_si_  服务端下发 resign 时须回传登录载荷；服务端下发 ok 表示登录完成
+    ✦_hb_  心跳，收到后原样应答
+*******************************************************************************/
+import { EventEmitter } from 'events';
+/** 与 NWSUserMgrJ 配套的 JSON WebSocket 客户端 */
+export default class NWSUserClientJ extends EventEmitter {
+    static EventError: string;
+    static EventConnected: string;
+    static EventDisconnected: string;
+    static EventMessage: string;
+    /** 收到服务端 _si_ ok，登录验证完成 */
+    static EventSigned: string;
+    /** 是否已与服务器建立 WebSocket（不代表已完成 _si_ 验证） */
+    get connected(): boolean;
+    /** 是否已完成登录验证（收到 _si_ ok） */
+    get signed(): boolean;
+    private url;
+    /** WebSocket 传输层，由本类包装 JSON 协议 */
+    private client;
+    private _connected;
+    private _signed;
+    /** 服务端要求 resign 时用于生成登录参数的回调，须与 NWSUserMgrJ.signInChecker 约定一致 */
+    private getSignInData;
+    /** >0 开启掉线重连，单位为秒，轮询周期约为间隔的 1/10 */
+    private autoReconnectInterval;
+    private reconnectTimer;
+    /** 上次发起 connect 的时间戳（毫秒） */
+    private lastConnectStartTime;
+    /** 为 true 时表示用户主动 disconnect，自动重连不会触发 */
+    private suppressReconnect;
+    private connectTimeoutMs;
+    private signInTimeoutMs;
+    private log;
+    /** 等待本次 connect() 完成的回调（仅用于首次握手阶段） */
+    private connectFinish;
+    constructor(params: {
+        url?: string;
+        /** 自动重连间隔（秒），0 表示不重连 */
+        autoReconnectInterval?: number;
+        /** 响应 _si_ resign 时提交的登录数据 */
+        getSignInData: () => unknown;
+        connectTimeoutMs?: number;
+        signInTimeoutMs?: number;
+        log?: boolean;
+    });
+    /**
+     * 建立连接（仅 TCP/WebSocket 层），返回是否在超时时间内进入 OPEN。
+     */
+    connect(_url?: string): Promise<boolean>;
+    /**
+     * 连接并等待登录完成（收到 _si_ ok）。
+     */
+    signIn(_url?: string): Promise<boolean>;
+    /** 主动断开；之后不会自动重连，除非再次调用 connect / signIn */
+    disconnect(): void;
+    /** 发送业务或内置命令 */
+    send<T>(cmd: string, data: T): void;
+    private onClientConnected;
+    /** NWSClient 上报的原始字符串，解析为 JSON 帧 */
+    private onClientRawMessage;
+    private onClientDisconnected;
+    private onClientError;
+}

package/lib/NWSUserClientJ.js

@@ -0,0 +1,232 @@
+/*******************************************************************************
+文件: NWSUserClientJ.ts
+创建: 2026年05月08日
+作者: 老张
+描述:
+    J含义为JSON.
+    面向 Node.js 的 WebSocket 客户端，与 NWSUserMgrJ 配套使用。
+    基于 JSON 帧通讯：{ "c": 命令, "d": 参数 }，内置 _si_（登录）、_hb_（心跳）。
+
+    参考：Cocos Creator 下的 XWebSocket；此处去掉 cc.EventTarget / xfire 依赖，
+    使用 EventEmitter；传输层统一委托 NWSClient（内部使用 ws / NWSSocket）。
+
+内置命令（与 NWSUserMgrJ 一致）：
+    ✦_si_  服务端下发 resign 时须回传登录载荷；服务端下发 ok 表示登录完成
+    ✦_hb_  心跳，收到后原样应答
+*******************************************************************************/
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { EventEmitter } from 'events';
+import NWSClient from './NWSClient';
+/** 与 NWSUserMgrJ 配套的 JSON WebSocket 客户端 */
+class NWSUserClientJ extends EventEmitter {
+    /** 是否已与服务器建立 WebSocket（不代表已完成 _si_ 验证） */
+    get connected() {
+        return this._connected;
+    }
+    /** 是否已完成登录验证（收到 _si_ ok） */
+    get signed() {
+        return this._signed;
+    }
+    constructor(params) {
+        var _a, _b;
+        super();
+        this._connected = false;
+        this._signed = false;
+        /** >0 开启掉线重连，单位为秒，轮询周期约为间隔的 1/10 */
+        this.autoReconnectInterval = 0;
+        this.reconnectTimer = null;
+        /** 上次发起 connect 的时间戳（毫秒） */
+        this.lastConnectStartTime = 0;
+        /** 为 true 时表示用户主动 disconnect，自动重连不会触发 */
+        this.suppressReconnect = false;
+        this.connectTimeoutMs = 5000;
+        this.signInTimeoutMs = 5000;
+        this.log = false;
+        /** 等待本次 connect() 完成的回调（仅用于首次握手阶段） */
+        this.connectFinish = null;
+        this.url = params.url || '';
+        this.getSignInData = params.getSignInData;
+        this.autoReconnectInterval = params.autoReconnectInterval || 0;
+        this.connectTimeoutMs = (_a = params.connectTimeoutMs) !== null && _a !== void 0 ? _a : 5000;
+        this.signInTimeoutMs = (_b = params.signInTimeoutMs) !== null && _b !== void 0 ? _b : 5000;
+        this.log = params.log || false;
+        this.client = new NWSClient({ log: this.log });
+        this.client.on(NWSClient.EventConnected, this.onClientConnected.bind(this));
+        this.client.on(NWSClient.EventMessage, this.onClientRawMessage.bind(this));
+        this.client.on(NWSClient.EventDisconnected, this.onClientDisconnected.bind(this));
+        this.client.on(NWSClient.EventError, this.onClientError.bind(this));
+        if (this.autoReconnectInterval > 0) {
+            const tickMs = Math.max(100, this.autoReconnectInterval * 100);
+            this.reconnectTimer = setInterval(() => {
+                if (this.suppressReconnect || !this.url) {
+                    return;
+                }
+                if (this.client && !this._connected) {
+                    const off = Date.now() - this.lastConnectStartTime;
+                    if (off / 1000 >= this.autoReconnectInterval) {
+                        void this.connect();
+                    }
+                }
+            }, tickMs);
+        }
+    }
+    /**
+     * 建立连接（仅 TCP/WebSocket 层），返回是否在超时时间内进入 OPEN。
+     */
+    connect(_url) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._connected) {
+                return true;
+            }
+            this.suppressReconnect = false;
+            this._connected = false;
+            this._signed = false;
+            let url = _url || this.url || '';
+            url = url.replace(new RegExp('^http(s){0,1}://'), 'ws$1://');
+            if (!url) {
+                if (this.log) {
+                    console.error('【NWSUserClientJ】URL 异常');
+                }
+                return false;
+            }
+            this.url = url;
+            let settled = false;
+            let innerResolve;
+            const connectPromise = new Promise((resolve) => {
+                innerResolve = resolve;
+            });
+            let timer;
+            const finishConnect = (ok) => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                this.connectFinish = null;
+                clearTimeout(timer);
+                innerResolve(ok);
+            };
+            timer = setTimeout(() => {
+                finishConnect(this._connected);
+            }, this.connectTimeoutMs);
+            this.lastConnectStartTime = Date.now();
+            this.connectFinish = finishConnect;
+            const started = yield this.client.connect(this.url);
+            if (started === false) {
+                finishConnect(false);
+                return connectPromise;
+            }
+            return connectPromise;
+        });
+    }
+    /**
+     * 连接并等待登录完成（收到 _si_ ok）。
+     */
+    signIn(_url) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ok = yield this.connect(_url);
+            if (!ok) {
+                if (this.log) {
+                    console.error('【NWSUserClientJ】signIn：连接失败');
+                }
+                return false;
+            }
+            const deadline = Date.now() + this.signInTimeoutMs;
+            while (!this._signed && Date.now() < deadline) {
+                yield new Promise((r) => setImmediate(r));
+            }
+            if (!this._signed && this.log) {
+                console.error('【NWSUserClientJ】signIn：等待登录确认超时');
+            }
+            return this._signed;
+        });
+    }
+    /** 主动断开；之后不会自动重连，除非再次调用 connect / signIn */
+    disconnect() {
+        this.suppressReconnect = true;
+        this._connected = false;
+        this._signed = false;
+        this.client.disconnect();
+        if (this.connectFinish) {
+            this.connectFinish(false);
+        }
+    }
+    /** 发送业务或内置命令 */
+    send(cmd, data) {
+        const ok = this.client.send(JSON.stringify({ c: cmd, d: data }));
+        if (!ok) {
+            if (this._connected) {
+                this._connected = false;
+                this.emit(NWSUserClientJ.EventDisconnected, 'ws 连接未开启');
+            }
+        }
+    }
+    onClientConnected() {
+        this._connected = true;
+        this.emit(NWSUserClientJ.EventConnected);
+        if (this.connectFinish) {
+            this.connectFinish(true);
+        }
+    }
+    /** NWSClient 上报的原始字符串，解析为 JSON 帧 */
+    onClientRawMessage(str) {
+        if (typeof str !== 'string') {
+            return;
+        }
+        try {
+            let json = JSON.parse(str);
+            let cmd = json === null || json === void 0 ? void 0 : json.c;
+            let data = json === null || json === void 0 ? void 0 : json.d;
+            switch (cmd) {
+                case '_hb_':
+                    this.send('_hb_', undefined);
+                    break;
+                case '_si_': {
+                    if (data === 'resign') {
+                        this._signed = false;
+                        this.send('_si_', this.getSignInData());
+                    }
+                    else if (data === 'ok') {
+                        this._signed = true;
+                        this.emit(NWSUserClientJ.EventSigned);
+                    }
+                    break;
+                }
+                default:
+                    this.emit(NWSUserClientJ.EventMessage, cmd, data);
+                    break;
+            }
+        }
+        catch (error) {
+            return;
+        }
+    }
+    onClientDisconnected(reason) {
+        this._connected = false;
+        this._signed = false;
+        if (this.connectFinish) {
+            this.connectFinish(false);
+        }
+        this.emit(NWSUserClientJ.EventDisconnected, reason || '连接关闭');
+    }
+    onClientError(err) {
+        this.emit(NWSUserClientJ.EventError, err);
+        if (this.connectFinish) {
+            this.connectFinish(false);
+        }
+    }
+}
+NWSUserClientJ.EventError = 'error';
+NWSUserClientJ.EventConnected = 'connected';
+NWSUserClientJ.EventDisconnected = 'disconnected';
+NWSUserClientJ.EventMessage = 'message';
+/** 收到服务端 _si_ ok，登录验证完成 */
+NWSUserClientJ.EventSigned = 'signed';
+export default NWSUserClientJ;

package/lib/NWSUserMgrJ.d.ts

@@ -0,0 +1,82 @@
+/*******************************************************************************
+文件: NWSUserMgrJ.ts
+创建: 2022年08月05日
+作者: 老张
+描述:
+    J含义为JSON.
+    基于NWSServer的实时联网用户管理，内部通信使用NWSServer的接口，信息传输格式使用json。
+    ✦用户与WSSocket通过登录命令_si_(signIn缩写)动态绑定，以便实现重连功能(更换WSSocket)
+    ✦支持重连，用户短时间断开websocket可以重连
+    ✦支持心跳机制，可以主动检测用户是否掉线
+
+信息传输格式如：
+    c为命令，d为命令参数，下方为登录命令示例，实际登录命令参数需自定义
+    {"c": "_si_", "d": {"uid": "123456"}}
+
+内置命令说明（前后下划线是防止与用户自定义命令冲突）：
+    ✦_si_
+        此命令客户端、服务端同名，客户端收到需要响应相同命令
+        登录信息，用来确定是哪个用户
+        参数格式：自定义，服务端下发不需要参数
+        需要实现校验函数：checkSignIn，用来返回uid，【必须，以防范冒名入侵】
+    ✦_hb_
+        此命令客户端、服务端同名，客户端收到需要响应相同命令
+        心跳
+        参数格式：不需要
+
+TODO 复用http服务端口，https://blog.csdn.net/qq_44856695/article/details/120250286
+*******************************************************************************/
+import { EventEmitter } from 'events';
+import NWSServer from './NWSServer';
+/** 基于NWSServer的实时联网用户管理，通信格式使用json */
+export default class NWSUserMgrJ extends EventEmitter {
+    /** 用户掉线，已考虑超时问题，如果设置超时非0，则socket掉线会等候用户重连，重连成功不认定掉线 */
+    static EventUserDisconnected: string;
+    server: NWSServer;
+    /** 连接id <--> 用户id */
+    linkToUIds: {
+        [linkId: string]: string;
+    };
+    uidToLinks: {
+        [uid: string]: {
+            linkId: string;
+            closeTime?: number;
+        };
+    };
+    /** 未绑定用户的连接，超时未绑定直接断开 */
+    private unboundLinks;
+    /** 登录信息校验接口 */
+    private signInChecker;
+    /** 心跳检测间隔，单位：秒，0表不进行心跳检测 */
+    private heartbeatInterval;
+    /** 多久未响应就认定掉线，单位：秒，0表不检测超时，非0时最低5 */
+    private timeoutSeconds;
+    /** 是否输出日志 */
+    private log;
+    constructor(params: {
+        port: number;
+        host?: string;
+        /** 心跳检测间隔，空或0不开启心跳检测，单位：秒 */
+        heartbeatInterval?: number;
+        /** 多久未响应就认定掉线，单位：秒 */
+        timeoutSeconds?: number;
+        /** 登录信息校验，返回用户id，data为登录命令的自定义参数 */
+        signInChecker: (data: any) => string;
+        /** 是否进行日志输出 */
+        log?: boolean;
+    });
+    sendToUser<T>(uid: string, cmd: string, data: T): void;
+    /** 有用户连入NWSServer（也可能是老用户重连）,此时是不能确认是哪个用户的 */
+    private onClientConnected;
+    private onClientDisconnected;
+    /** 处理来自用户的消息 */
+    private onClientMessage;
+    private sendToClient;
+    /**
+     * 心跳定时检测
+     * 像一定时间未活动的连接发送心跳命令，客户端需要响应
+     */
+    private heartbeatEngine;
+    /** 超时检测 */
+    private checkTimeout;
+}

package/lib/NWSUserMgrJ.js

@@ -0,0 +1,208 @@
+/*******************************************************************************
+文件: NWSUserMgrJ.ts
+创建: 2022年08月05日
+作者: 老张
+描述:
+    J含义为JSON.
+    基于NWSServer的实时联网用户管理，内部通信使用NWSServer的接口，信息传输格式使用json。
+    ✦用户与WSSocket通过登录命令_si_(signIn缩写)动态绑定，以便实现重连功能(更换WSSocket)
+    ✦支持重连，用户短时间断开websocket可以重连
+    ✦支持心跳机制，可以主动检测用户是否掉线
+
+信息传输格式如：
+    c为命令，d为命令参数，下方为登录命令示例，实际登录命令参数需自定义
+    {"c": "_si_", "d": {"uid": "123456"}}
+
+内置命令说明（前后下划线是防止与用户自定义命令冲突）：
+    ✦_si_
+        此命令客户端、服务端同名，客户端收到需要响应相同命令
+        登录信息，用来确定是哪个用户
+        参数格式：自定义，服务端下发不需要参数
+        需要实现校验函数：checkSignIn，用来返回uid，【必须，以防范冒名入侵】
+    ✦_hb_
+        此命令客户端、服务端同名，客户端收到需要响应相同命令
+        心跳
+        参数格式：不需要
+
+TODO 复用http服务端口，https://blog.csdn.net/qq_44856695/article/details/120250286
+*******************************************************************************/
+import { EventEmitter } from 'events';
+import NWSServer from './NWSServer';
+import NUtils from 'lz-nutils';
+/** 基于NWSServer的实时联网用户管理，通信格式使用json */
+class NWSUserMgrJ extends EventEmitter {
+    constructor(params) {
+        super();
+        /** 连接id <--> 用户id */
+        this.linkToUIds = {};
+        this.uidToLinks = {};
+        /** 未绑定用户的连接，超时未绑定直接断开 */
+        this.unboundLinks = {};
+        /** 心跳检测间隔，单位：秒，0表不进行心跳检测 */
+        this.heartbeatInterval = 0;
+        /** 多久未响应就认定掉线，单位：秒，0表不检测超时，非0时最低5 */
+        this.timeoutSeconds = 0;
+        /** 是否输出日志 */
+        this.log = false;
+        this.signInChecker = params.signInChecker;
+        this.server = new NWSServer({ log: false });
+        this.server.start(params.port, params.host);
+        this.server.on(NWSServer.EventError, (error) => {
+            console.error('NWSUserMgrJ ws异常：' + error.message);
+        });
+        this.server.on(NWSServer.EventServiceStarted, () => {
+            console.log('NWSUserMgrJ 服务启动');
+        });
+        if (params.heartbeatInterval && params.heartbeatInterval > 0) {
+            this.heartbeatInterval = params.heartbeatInterval;
+            setInterval(this.heartbeatEngine.bind(this), params.heartbeatInterval / 10);
+        }
+        if (params.timeoutSeconds && params.timeoutSeconds > 0) {
+            this.timeoutSeconds = Math.max(5, params.timeoutSeconds);
+            setInterval(this.checkTimeout.bind(this), params.timeoutSeconds / 10);
+        }
+        this.log = params.log || false;
+        // 连接监听
+        this.server.on(NWSServer.EventClientConnected, this.onClientConnected.bind(this));
+        // 连接断开监听
+        this.server.on(NWSServer.EventClientDisconnected, this.onClientDisconnected.bind(this));
+        // 消息监听
+        this.server.on(NWSServer.EventClientMessage, this.onClientMessage.bind(this));
+    }
+    sendToUser(uid, cmd, data) {
+        let link = this.uidToLinks[uid];
+        if (!link)
+            return;
+        this.sendToClient(link.linkId, cmd, data);
+    }
+    /** 有用户连入NWSServer（也可能是老用户重连）,此时是不能确认是哪个用户的 */
+    onClientConnected(linkId) {
+        if (this.log) {
+            console.log('【NWSUserMgrJ】用户连入，分配linkId:' + linkId);
+        }
+        this.sendToClient(linkId, '_si_', 'resign');
+        this.unboundLinks[linkId] = true;
+    }
+    onClientDisconnected(linkId) {
+        delete this.unboundLinks[linkId];
+        let uid = this.linkToUIds[linkId];
+        delete this.linkToUIds[linkId];
+        // 如果没有开启超时检测，则ws掉线立即认定掉线
+        if (uid && !this.timeoutSeconds) {
+            delete this.uidToLinks[uid];
+            this.emit(NWSUserMgrJ.EventUserDisconnected, uid);
+            if (this.log) {
+                console.log(`【NWSUserMgrJ】用户断开连接，linkId:${linkId}，uid:${uid}`);
+            }
+        }
+        else {
+            if (this.uidToLinks[uid]) {
+                this.uidToLinks[uid].closeTime = NUtils.currentTimeMillis;
+            }
+        }
+    }
+    /** 处理来自用户的消息 */
+    onClientMessage(linkId, msg, isBinary) {
+        var _a;
+        let json;
+        try {
+            json = JSON.parse(msg.toString());
+        }
+        catch (e) {
+        }
+        if (!json || typeof json.c !== 'string' || !json.c)
+            return;
+        let cmd = json.c;
+        let data = json.d;
+        switch (cmd) {
+            case '_si_': {
+                let uid = (_a = this.signInChecker) === null || _a === void 0 ? void 0 : _a.call(this, data);
+                if (!uid)
+                    return;
+                // 解绑老连接
+                {
+                    let oldLink = this.uidToLinks[uid];
+                    if (oldLink) {
+                        let ws = this.server.getSocket(oldLink.linkId);
+                        ws === null || ws === void 0 ? void 0 : ws.removeAllListeners();
+                        ws === null || ws === void 0 ? void 0 : ws.close();
+                        delete this.uidToLinks[uid];
+                        delete this.linkToUIds[oldLink.linkId];
+                    }
+                }
+                // 绑定用户id与连接id
+                this.linkToUIds[linkId] = uid;
+                this.uidToLinks[uid] = { linkId };
+                if (this.log) {
+                    console.log(`【NWSUserMgrJ】用户登录成功，linkId:${linkId} uid:${uid}`);
+                }
+                // 下发确认命令
+                this.sendToClient(linkId, '_si_', 'ok');
+                break;
+            }
+            case '_hb_': {
+                // 这里并不需要做啥特殊处理，活动时间已经在WSSocket中收到客户端消息时自动刷新
+                break;
+            }
+            default: {
+                // 先校验用户是否登录
+                let uid = this.linkToUIds[linkId];
+                if (!uid) {
+                    // 下发登录命令
+                    this.sendToClient(linkId, '_si_', 'resign');
+                    return;
+                }
+                // 抛出命令、用户id、参数供监听
+                this.emit(cmd, uid, data);
+                break;
+            }
+        }
+    }
+    sendToClient(linkId, cmd, data) {
+        this.server.sendToClient(linkId, JSON.stringify({ c: cmd, d: data }));
+    }
+    /**
+     * 心跳定时检测
+     * 像一定时间未活动的连接发送心跳命令，客户端需要响应
+     */
+    heartbeatEngine() {
+        if (!this.server || !this.heartbeatInterval)
+            return;
+        for (let uid in this.uidToLinks) {
+            let link = this.uidToLinks[uid];
+            let socket = this.server.getSocket(link.linkId);
+            if (!socket)
+                continue;
+            if ((NUtils.currentTimeMillis - socket.actTime) / 1000 >= this.heartbeatInterval &&
+                (NUtils.currentTimeMillis - (socket.heartbeatCheckTime || 0)) / 1000 >= this.heartbeatInterval) {
+                this.sendToClient(link.linkId, '_hb_', undefined);
+                socket.heartbeatCheckTime = NUtils.currentTimeMillis;
+            }
+        }
+    }
+    /** 超时检测 */
+    checkTimeout() {
+        if (!this.server || !this.timeoutSeconds)
+            return;
+        for (let uid in this.uidToLinks) {
+            let link = this.uidToLinks[uid];
+            let socket = this.server.getSocket(link.linkId);
+            let actTime = (socket === null || socket === void 0 ? void 0 : socket.actTime) != null ? socket.actTime : link.closeTime;
+            if (actTime == null)
+                continue;
+            if ((NUtils.currentTimeMillis - actTime) / 1000 >= this.timeoutSeconds) {
+                delete this.unboundLinks[link.linkId];
+                delete this.linkToUIds[link.linkId];
+                delete this.uidToLinks[uid];
+                this.server.disconnectClient(link.linkId);
+                this.emit(NWSUserMgrJ.EventUserDisconnected, uid);
+                if (this.log) {
+                    console.log(`【NWSUserMgrJ】用户超时断开连接，linkId:${link.linkId}，uid:${uid}`);
+                }
+            }
+        }
+    }
+}
+/** 用户掉线，已考虑超时问题，如果设置超时非0，则socket掉线会等候用户重连，重连成功不认定掉线 */
+NWSUserMgrJ.EventUserDisconnected = 'disconnected';
+export default NWSUserMgrJ;

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "lz-nframe",
+  "version": "1.0.0",
+  "description": "",
+  "type": "module",
+  "main": "./lib/NApp.js",
+  "scripts": {
+    "build": "tsc",
+    "test": "node --import tsx --test test/NConfigsMgr.test.ts test/NHttpClient.test.ts test/NWSClient.test.ts test/NWSUserClientJ.test.ts test/NWSServiceHub.test.ts",
+    "test:watch": "node --import tsx --test --watch test/NConfigsMgr.test.ts test/NHttpClient.test.ts test/NWSClient.test.ts test/NWSUserClientJ.test.ts test/NWSServiceHub.test.ts"
+  },
+  "author": "",
+  "license": "ISC",
+  "files": [
+    "lib/",
+    "package.json"
+  ],
+  "devDependencies": {
+    "@types/node": "^20.12.2",
+    "@types/ws": "^8.18.1",
+    "tsx": "^4.21.0",
+    "typescript": "^5.6.3"
+  },
+  "dependencies": {
+    "lz-nutils": "^1.2.0",
+    "ws": "^8.18.3"
+  }
+}