lz-nframe 1.0.0

package/lib/NSimpleHttpServer.js

@@ -0,0 +1,222 @@
+/*******************************************************************************
+文件: NSimpleHttpServer.ts
+创建: 2022年02月17日
+作者: 老张
+描述:
+    基于NodeJS内置http模块实现http(s)服务器，不需要额外的依赖包
+
+文档：
+    http模块api参考：http://nodejs.cn/api/http.html
+
+参考：
+    https://www.cnblogs.com/chuanzi/p/10507919.html
+
+示例：
+    new NSimpleHttpServer()
+        .addPage('/', (req, res) => {
+            res.write('HelloWorld\n');
+            console.log(req.socket.remoteAddress);
+            res.write('远程地址:' + req.socket.remoteAddress + '\n');
+            res.write('本地地址:' + req.socket.localAddress + '\n');
+        }, {contentType: ContentType.TextPlain})
+        .start(3000);
+*******************************************************************************/
+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 * as http from 'http';
+export default class NSimpleHttpServer {
+    constructor(params) {
+        var _a;
+        this.server = null;
+        this.pages = {};
+        this.maxBodyBytes = (_a = params === null || params === void 0 ? void 0 : params.maxBodyBytes) !== null && _a !== void 0 ? _a : 8192;
+        this.server = http.createServer(this.onRequest.bind(this));
+        this.server.on('error', (err) => {
+            console.error(err.message);
+        });
+    }
+    /** 启动服务 host如果为null那么req.socket.remoteAddress格式如::ffff:127.0.0.1 */
+    start(port, host = '0.0.0.0', onListening) {
+        var _a;
+        (_a = this.server) === null || _a === void 0 ? void 0 : _a.listen(port, host, () => {
+            console.log(`[NSimpleHttpServer] 已启动 ${host}:${port}`);
+            onListening === null || onListening === void 0 ? void 0 : onListening();
+        });
+        return this;
+    }
+    close() {
+        var _a;
+        (_a = this.server) === null || _a === void 0 ? void 0 : _a.close();
+        return this;
+    }
+    /**
+     * 注册页面/路由
+     * @param url 路径，会做规范化（去掉尾斜杠，根路径'/'除外）
+     * @param requestDealer 请求处理函数；内部可主动调用 res.writeHead/res.end 自定义状态码
+     * @param options.contentType 响应头的 Content-Type；兼容旧 enum 整行写法与纯 MIME 写法
+     * @param options.allowCORS 开启简单 CORS，并自动应答 OPTIONS 预检
+     * @param options.method 仅允许指定 HTTP 方法（如 'POST' 或 ['GET','POST']），不传则放行所有方法
+     */
+    addPage(url, requestDealer, options) {
+        const normalizedUrl = this.normalizePath(url);
+        this.pages[normalizedUrl] = {
+            url: normalizedUrl,
+            contentType: (options === null || options === void 0 ? void 0 : options.contentType) || ContentType.TextHtml,
+            allowCORS: options === null || options === void 0 ? void 0 : options.allowCORS,
+            method: options === null || options === void 0 ? void 0 : options.method,
+            requestDealer
+        };
+        return this;
+    }
+    onRequest(req, res) {
+        // 用 new URL 替代已弃用的 url.parse；req.url 异常时返回 400
+        let parsed;
+        try {
+            parsed = new URL(req.url || '/', `http://${req.headers.host || 'localhost'}`);
+        }
+        catch (_a) {
+            res.writeHead(400, http.STATUS_CODES[400]);
+            res.end();
+            return;
+        }
+        // 路径规范化后再查表，使 /api 与 /api/ 行为一致
+        const pathname = this.normalizePath(parsed.pathname);
+        let page = this.pages[pathname];
+        if (!page) {
+            res.writeHead(404, http.STATUS_CODES[404]);
+            res.end();
+            return;
+        }
+        let heads = {};
+        if (page.contentType) {
+            const ct = this.parseContentType(page.contentType);
+            if (ct) {
+                heads[ct.key] = ct.value;
+            }
+        }
+        if (page.allowCORS) {
+            heads['Access-Control-Allow-Origin'] = '*';
+            heads['Access-Control-Allow-Methods'] = 'GET, POST, PUT, DELETE, OPTIONS';
+            heads['Access-Control-Allow-Headers'] = 'Content-Type, Authorization';
+        }
+        // CORS 预检请求：直接 204 返回，不再读 body 也不调 dealer
+        if (page.allowCORS && req.method === 'OPTIONS') {
+            res.writeHead(204, heads);
+            res.end();
+            return;
+        }
+        // method 校验：注册了 method 限制时，其他方法返回 405 + Allow
+        if (page.method) {
+            const allowed = (Array.isArray(page.method) ? page.method : [page.method]).map(m => m.toUpperCase());
+            if (!allowed.includes((req.method || '').toUpperCase())) {
+                res.writeHead(405, http.STATUS_CODES[405], { 'Allow': allowed.join(', ') });
+                res.end();
+                return;
+            }
+        }
+        const chunks = [];
+        let received = 0;
+        let aborted = false;
+        // 收集body：用 Buffer 数组累积，避免字符串拼接破坏二进制或跨包多字节字符
+        req.on('data', (chunk) => {
+            if (aborted)
+                return;
+            received += chunk.length;
+            if (received > this.maxBodyBytes) {
+                aborted = true;
+                if (!res.headersSent) {
+                    res.writeHead(413, http.STATUS_CODES[413]);
+                }
+                if (!res.writableEnded)
+                    res.end();
+                req.destroy();
+                return;
+            }
+            chunks.push(chunk);
+        });
+        req.on('end', () => __awaiter(this, void 0, void 0, function* () {
+            // 已被中止或响应已结束则不再处理，防止二次写入
+            if (aborted || res.writableEnded)
+                return;
+            // 整理query，url中多次为同名参数设置值可传递数组，对于数组参数直接保留第一个成员
+            let query = {};
+            for (const [key, val] of parsed.searchParams.entries()) {
+                if (!(key in query)) {
+                    query[key] = val;
+                }
+            }
+            // 注意：@types/node 在新版本中将 Buffer 的 ArrayBufferLike 与 Buffer.concat 期望的类型不完全兼容，需要做断言
+            const body = Buffer.concat(chunks).toString('utf-8');
+            try {
+                // 先设置默认响应头，但不提前写状态码，避免覆盖 dealer 的自定义 writeHead
+                if (!res.headersSent) {
+                    const headerEntries = Object.entries(heads);
+                    for (const [key, value] of headerEntries) {
+                        res.setHeader(key, value);
+                    }
+                }
+                if (page.requestDealer) {
+                    yield page.requestDealer(req, res, query, body);
+                }
+                // 若 dealer 未写入状态码/响应头，则默认返回 200
+                if (!res.headersSent) {
+                    res.writeHead(200, http.STATUS_CODES[200]);
+                }
+            }
+            catch (e) {
+                // dealer 内部异常兜底，避免 unhandledRejection 拖崩进程
+                console.error('[NSimpleHttpServer] dealer 异常:', e);
+                if (!res.headersSent) {
+                    res.writeHead(500, http.STATUS_CODES[500]);
+                }
+            }
+            finally {
+                if (!res.writableEnded)
+                    res.end();
+            }
+        }));
+    }
+    /** 路径规范化：去掉尾部多余斜杠，但保留根路径'/' */
+    normalizePath(p) {
+        if (!p)
+            return '/';
+        if (p.length > 1 && p.endsWith('/')) {
+            const trimmed = p.replace(/\/+$/, '');
+            return trimmed || '/';
+        }
+        return p;
+    }
+    /**
+     * 解析 contentType 配置，同时兼容两种写法：
+     *   1) 旧 enum 整行写法（含 ':'）：'Content-Type: text/html; charset=utf-8;'
+     *   2) 纯 MIME 写法：'application/json'
+     * 修正了原实现 split(':').length===2 才生效的限制（含多冒号会被丢弃）以及尾分号问题
+     */
+    parseContentType(contentType) {
+        if (!contentType)
+            return null;
+        const idx = contentType.indexOf(':');
+        if (idx > 0) {
+            // 仅按第一个冒号切，避免值里有冒号被截断
+            const key = contentType.slice(0, idx).trim();
+            const value = contentType.slice(idx + 1).trim().replace(/;\s*$/, '');
+            if (key && value)
+                return { key, value };
+            return null;
+        }
+        return { key: 'Content-Type', value: contentType.trim() };
+    }
+}
+export var ContentType;
+(function (ContentType) {
+    ContentType["TextHtml"] = "Content-Type: text/html; charset=utf-8;";
+    ContentType["TextPlain"] = "Content-Type: text/plain; charset=utf-8;";
+    ContentType["ApplicationJson"] = "Content-Type: application/json; charset=utf-8;";
+})(ContentType || (ContentType = {}));

package/lib/NType.d.ts

@@ -0,0 +1,64 @@
+/*******************************************************************************
+文件: NType.ts
+创建: 2026年05月06日
+作者: 老张
+描述:
+    类型定义
+*******************************************************************************/
+/** 普通类型值（不含 Date/Function/RegExp 等复杂对象） */
+export type PlainType = string | number | boolean | null | undefined;
+/** 递归定义允许的配置值类型：原始类型、普通对象、数组 */
+export type PlainValue = PlainType | {
+    [key: string]: PlainValue;
+} | PlainValue[];
+/**
+ * 递归提取对象所有属性的点号路径（仅支持字符串 key）
+ * 同时包含中间对象路径与叶子路径，方便监听整个子对象或单个字段的变化。
+ * 数组类型视为叶子（不展开 length / 数组方法等无意义路径）。
+ *
+ * @example
+ * interface Config {
+ *     port: number;
+ *     db: { host: string; port: number };
+ *     tags: string[];
+ * }
+ * type Keys = NestedKeyOf<Config>;
+ * // → 'port' | 'db' | 'db.host' | 'db.port' | 'tags'
+ *
+ * 推演过程：
+ *   NestedKeyOf<Config, ''>
+ *   ├── 'port':   非对象       → 'port'
+ *   ├── 'db':     是对象（非数组）→ 'db' | NestedKeyOf<{host, port}, 'db.'>
+ *   │              ├── 'host' → 'db.host'
+ *   │              └── 'port' → 'db.port'
+ *   └── 'tags':   是数组       → 'tags'（按叶子处理）
+ *
+ * @param T      目标对象类型
+ * @param Prefix 路径前缀，内部递归使用，外部调用无需传入
+ */
+export type NestedKeyOf<T, Prefix extends string = ''> = T extends object ? {
+    [K in keyof T & string]: T[K] extends readonly any[] ? `${Prefix}${K}` : T[K] extends object ? `${Prefix}${K}` | NestedKeyOf<T[K], `${Prefix}${K}.`> : `${Prefix}${K}`;
+}[keyof T & string] : never;
+/**
+ * 根据点号分隔的路径字符串，从对象类型中提取对应位置值的类型
+ *
+ * @example
+ * interface Config {
+ *     port: number;
+ *     db: { host: string; port: number };
+ * }
+ * type T1 = ValueAtPath<Config, 'db'>;       // → { host: string; port: number }
+ * type T2 = ValueAtPath<Config, 'db.host'>;  // → string
+ * type T3 = ValueAtPath<Config, 'db.port'>;  // → number
+ * type T4 = ValueAtPath<Config, 'foo'>;      // → never（路径不存在）
+ *
+ * 推演过程：
+ *   ValueAtPath<Config, 'db.host'>
+ *   → 匹配 `${infer K}.${infer Rest}` → K='db', Rest='host'
+ *   → 'db' extends keyof Config → ValueAtPath<Config['db'], 'host'>
+ *   → 不再含 '.' → 匹配 P extends keyof T → {host, port}['host'] → string
+ *
+ * @param T  目标对象类型
+ * @param P  点号分隔的路径字符串，如 'db.host'
+ */
+export type ValueAtPath<T, P extends string> = P extends `${infer K}.${infer Rest}` ? K extends keyof T ? ValueAtPath<T[K], Rest> : never : P extends keyof T ? T[P] : never;

package/lib/NType.js

@@ -0,0 +1,8 @@
+/*******************************************************************************
+文件: NType.ts
+创建: 2026年05月06日
+作者: 老张
+描述:
+    类型定义
+*******************************************************************************/
+export {};

package/lib/NWSClient.d.ts

@@ -0,0 +1,44 @@
+/*******************************************************************************
+文件: NWSClient.ts
+创建: 2024年1月30日
+作者: 老张
+描述:
+    websocket客户端模块，基于ws模块，另外nodejs还有socket.io模块可以实现ws
+
+websocket事件：
+    ✦onopen  网络连接建立时触发该事件
+    ✦onerror 网络发生错误时触发该事件
+    ✦onclose websocket关闭时触发该事件
+    ✦onmessage 接收到消息
+*******************************************************************************/
+import { EventEmitter } from 'events';
+export default class NWSClient extends EventEmitter {
+    static EventError: string;
+    static EventConnected: string;
+    static EventDisconnected: string;
+    static EventMessage: string;
+    static EventServiceStarted: string;
+    private log;
+    private get connected();
+    private url;
+    private socket;
+    private _connected;
+    /** 上次发起连接的时间 */
+    private lastConnectStartTime;
+    constructor(params?: {
+        log: boolean;
+    });
+    connect(_url?: string): Promise<boolean>;
+    /**
+     * 发送消息到服务器
+     * @param msg 文本或二进制消息
+     */
+    send(msg: Buffer | string): boolean;
+    /** 主动断开与服务器的连接 */
+    disconnect(): void;
+    private onConnected;
+    /** 收到服务器数据 */
+    private onData;
+    private onClose;
+    private onError;
+}

package/lib/NWSClient.js

@@ -0,0 +1,134 @@
+/*******************************************************************************
+文件: NWSClient.ts
+创建: 2024年1月30日
+作者: 老张
+描述:
+    websocket客户端模块，基于ws模块，另外nodejs还有socket.io模块可以实现ws
+
+websocket事件：
+    ✦onopen  网络连接建立时触发该事件
+    ✦onerror 网络发生错误时触发该事件
+    ✦onclose websocket关闭时触发该事件
+    ✦onmessage 接收到消息
+*******************************************************************************/
+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 WebSocket from 'ws';
+import { NWSSocket } from './NWSSocket';
+class NWSClient extends EventEmitter {
+    get connected() {
+        return this._connected;
+    }
+    constructor(params) {
+        super();
+        this.log = false;
+        this.socket = null;
+        this._connected = false;
+        /** 上次发起连接的时间 */
+        this.lastConnectStartTime = 0;
+        this.log = (params === null || params === void 0 ? void 0 : params.log) || false;
+    }
+    connect(_url) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._connected) {
+                return true;
+            }
+            this._connected = false;
+            let url = _url || this.url || '';
+            url = url.replace(new RegExp('^http(s){0,1}://'), 'ws$1://');
+            if (!url) {
+                console.error('URL异常');
+                return false;
+            }
+            this.url = url;
+            if (this.socket) {
+                // 重连前闭没必要让onclose触发事件
+                this.socket.onopen = null;
+                this.socket.onmessage = null;
+                this.socket.onclose = null;
+                this.socket.onerror = null;
+                this.socket.close();
+                this.socket = null;
+            }
+            try {
+                this.socket = new NWSSocket(url);
+            }
+            catch (err) {
+                console.error('URL异常:', err);
+                return false;
+            }
+            this.lastConnectStartTime = Date.now();
+            this.socket.onopen = this.onConnected.bind(this);
+            this.socket.onmessage = this.onData.bind(this);
+            this.socket.onclose = this.onClose.bind(this);
+            this.socket.onerror = this.onError.bind(this);
+        });
+    }
+    /**
+     * 发送消息到服务器
+     * @param msg 文本或二进制消息
+     */
+    send(msg) {
+        if (!this.socket || this.socket.readyState !== WebSocket.OPEN) {
+            return false;
+        }
+        this.socket.send(msg);
+        return true;
+    }
+    /** 主动断开与服务器的连接 */
+    disconnect() {
+        if (!this.socket) {
+            return;
+        }
+        const socket = this.socket;
+        this.socket = null;
+        this._connected = false;
+        // 清除事件监听，避免触发事件
+        socket.onopen = null;
+        socket.onmessage = null;
+        socket.onclose = null;
+        socket.onerror = null;
+        // 使用 terminate 强制立即断开，避免 close 异步报错
+        socket.terminate();
+    }
+    onConnected(event) {
+        console.log('onConnected');
+        this._connected = true;
+        this.emit(NWSClient.EventConnected);
+    }
+    /** 收到服务器数据 */
+    onData(event) {
+        var _a, _b;
+        console.log('onData');
+        let str = typeof event.data === 'string' ?
+            event.data :
+            ((_b = (_a = event.data) === null || _a === void 0 ? void 0 : _a.toString) === null || _b === void 0 ? void 0 : _b.call(_a));
+        if (typeof str !== 'string') {
+            return;
+        }
+        this.emit(NWSClient.EventMessage, str);
+    }
+    onClose(event) {
+        console.log('onClose');
+        this._connected = false;
+        this.emit(NWSClient.EventDisconnected, event.reason || '连接关闭');
+    }
+    onError(err) {
+        console.log('onError');
+        this.emit(NWSClient.EventError, err);
+    }
+}
+NWSClient.EventError = 'error';
+NWSClient.EventConnected = 'connected';
+NWSClient.EventDisconnected = 'disconnected';
+NWSClient.EventMessage = 'message';
+NWSClient.EventServiceStarted = 'started';
+export default NWSClient;

package/lib/NWSServer.d.ts

@@ -0,0 +1,46 @@
+/*******************************************************************************
+文件: NWSServer.ts
+创建: 2022年06月21日
+作者: 老张
+描述:
+    websocket服务模块，基于ws模块，另外nodejs还有socket.io模块可以实现ws
+
+websocket事件：
+    ✦onopen  网络连接建立时触发该事件
+    ✦onerror 网络发生错误时触发该事件
+    ✦onclose websocket关闭时触发该事件
+    ✦onmessage 接收到消息
+*******************************************************************************/
+import { EventEmitter } from 'events';
+import { NWSSocket } from './NWSSocket';
+export default class NWSServer extends EventEmitter {
+    static EventError: string;
+    static EventServiceStarted: string;
+    /** 客户端连入（或重连）事件 */
+    static EventClientConnected: string;
+    /** 客户端断开 */
+    static EventClientDisconnected: string;
+    /** 客户端发上来的消息，参数：linkId，data，isBinary */
+    static EventClientMessage: string;
+    private log;
+    private wsServer;
+    constructor(params?: {
+        log: boolean;
+    });
+    /** 启动服务 host如果为null那么req.socket.remoteAddress格式如::ffff:127.0.0.1 */
+    start(port: number, host?: string): void;
+    /**
+     * 发送消息给客户端
+     * @param linkId 连接id
+     * @param msg 要发送的消息
+     */
+    sendToClient(linkId: string, msg: Buffer | string): boolean;
+    getSocket(linkId: string): NWSSocket | null;
+    /** 主动断开某个客户端的连接 */
+    disconnectClient(linkId: string): void;
+    /** 停止服务 */
+    stop(): void;
+    private onClientConnect;
+    private onClientMessage;
+    private onClientDisconnect;
+}

package/lib/NWSServer.js

@@ -0,0 +1,133 @@
+/*******************************************************************************
+文件: NWSServer.ts
+创建: 2022年06月21日
+作者: 老张
+描述:
+    websocket服务模块，基于ws模块，另外nodejs还有socket.io模块可以实现ws
+
+websocket事件：
+    ✦onopen  网络连接建立时触发该事件
+    ✦onerror 网络发生错误时触发该事件
+    ✦onclose websocket关闭时触发该事件
+    ✦onmessage 接收到消息
+*******************************************************************************/
+import { EventEmitter } from 'events';
+import WebSocket from 'ws'; // 1. 替换导入
+import { NWSSocket } from './NWSSocket';
+import NHttpClient from './NHttpClient';
+class NWSServer extends EventEmitter {
+    constructor(params) {
+        super();
+        this.log = false;
+        this.wsServer = null;
+        this.log = (params === null || params === void 0 ? void 0 : params.log) || false;
+    }
+    /** 启动服务 host如果为null那么req.socket.remoteAddress格式如::ffff:127.0.0.1 */
+    start(port, host = '0.0.0.0') {
+        if (this.wsServer) {
+            this.wsServer.close();
+            this.wsServer = null;
+        }
+        this.wsServer = new WebSocket.Server({
+            port,
+            host,
+            WebSocket: NWSSocket,
+        });
+        this.wsServer.on('error', (err) => {
+            if (this.log)
+                console.log('NWSServer错误：' + err.message);
+            this.emit(NWSServer.EventError, err);
+        });
+        /** 监听启动 */
+        this.wsServer.on('listening', () => {
+            // 发出服务启动消息，外部可监听
+            this.emit(NWSServer.EventServiceStarted);
+        });
+        /** 监听客户端连接 */
+        this.wsServer.on('connection', this.onClientConnect.bind(this));
+    }
+    /**
+     * 发送消息给客户端
+     * @param linkId 连接id
+     * @param msg 要发送的消息
+     */
+    sendToClient(linkId, msg) {
+        let client = this.getSocket(linkId);
+        if (!client || client.readyState !== WebSocket.OPEN) {
+            return false;
+        }
+        client.send(msg);
+        return true;
+    }
+    getSocket(linkId) {
+        var _a;
+        let clients = (_a = this.wsServer) === null || _a === void 0 ? void 0 : _a.clients;
+        if (!linkId || !clients)
+            return null;
+        for (let client of clients) {
+            if (client.linkId === linkId) {
+                return client;
+            }
+        }
+        return null;
+    }
+    /** 主动断开某个客户端的连接 */
+    disconnectClient(linkId) {
+        let client = this.getSocket(linkId);
+        if (!client) {
+            return;
+        }
+        client.close();
+    }
+    /** 停止服务 */
+    stop() {
+        if (!this.wsServer) {
+            return;
+        }
+        this.wsServer.close();
+        this.wsServer = null;
+    }
+    onClientConnect(socket, req) {
+        if (!socket)
+            return;
+        if (!socket.linkId) {
+            socket.linkId = NWSSocket.genUniqueId();
+        }
+        if (this.log)
+            console.log(`新用户连入(ip:${NHttpClient.getClientIp(req)})，分配连接id：${socket.linkId}`);
+        // 下方的事件都是ws模块封装后的事件，而不是websocket的协议事件
+        socket.removeAllListeners('message');
+        socket.on('message', this.onClientMessage.bind(this, socket));
+        socket.on('close', this.onClientDisconnect.bind(this, socket));
+        socket.on('error', () => { });
+        // 抛出连接事件，外部调用本模块可以监听连接事件获取linkId
+        this.emit(NWSServer.EventClientConnected, socket.linkId);
+    }
+    onClientMessage(client, data, isBinary) {
+        if (!client)
+            return;
+        client.actTime = Date.now();
+        if (this.log)
+            console.log(`用户 ${client.linkId} 消息：${data}`);
+        this.emit(NWSServer.EventClientMessage, client.linkId, data, isBinary);
+    }
+    onClientDisconnect(client) {
+        if (!client)
+            return;
+        if (this.log)
+            console.log(`用户 ${client.linkId} 断开连接`);
+        client.removeAllListeners('message');
+        client.removeAllListeners('close');
+        client.removeAllListeners('error');
+        this.emit(NWSServer.EventClientDisconnected, client.linkId);
+    }
+}
+NWSServer.EventError = 'error';
+NWSServer.EventServiceStarted = 'started';
+/** 客户端连入（或重连）事件 */
+NWSServer.EventClientConnected = 'connected';
+/** 客户端断开 */
+NWSServer.EventClientDisconnected = 'disconnected';
+/** 客户端发上来的消息，参数：linkId，data，isBinary */
+NWSServer.EventClientMessage = 'message';
+export default NWSServer;