@pixelhue/event-controller-sdk 0.0.1

package/dist/packages/tcp/tcpWrapper.d.ts

@@ -0,0 +1,168 @@
+import * as net from 'net';
+import type { SocketConnectOptions, HeartbeatResponseChecker } from './types.js';
+/**
+ * tcp连接管理器
+ * 负责处理 TCP 连接、重连、超时检测等
+ */
+export declare class TcpWrapper {
+    /** TCP Socket 实例 */
+    private socket;
+    /** 连接超时定时器 */
+    private connectTimeout;
+    /** 重连定时器 */
+    private retryConnectTimeout;
+    /** 心跳发送定时器 */
+    private heartbeatInterval;
+    /** 心跳响应超时定时器 */
+    private heartbeatTimeout;
+    /** 连接地址 */
+    private address;
+    /** 连接端口 */
+    private port;
+    /** 连接配置选项 */
+    private connectOptions;
+    /** 运行时的连接状态 */
+    private connectionActive;
+    /** 是否启用自动重连 */
+    private autoReconnect;
+    /** 心跳间隔（毫秒） */
+    private heartbeatIntervalMs;
+    /** 心跳超时时间（毫秒） */
+    private heartbeatTimeoutMs;
+    /** 是否有待响应的心跳 */
+    private pendingHeartbeat;
+    /** 连续心跳超时次数 */
+    private heartbeatTimeoutCount;
+    /** 心跳响应识别函数 */
+    private heartbeatResponseChecker;
+    /** 最大重连次数，0 表示无限制 */
+    private maxReconnectAttempts;
+    /** 是否启用指数退避 */
+    private enableExponentialBackoff;
+    /** 指数退避的最大间隔（毫秒） */
+    private maxReconnectInterval;
+    /** 当前重连次数 */
+    private reconnectAttempts;
+    /** 基础重连间隔（毫秒） */
+    private reconnectInterval;
+    /** 连接开始时间（用于计算握手时间） */
+    private connectStartTime;
+    /** 握手超时尝试次数 */
+    private handshakeTimeoutAttempts;
+    /** 最大握手超时尝试次数 */
+    private readonly maxHandshakeTimeoutAttempts;
+    /** 基础握手重试间隔（毫秒） */
+    private readonly baseHandshakeRetryInterval;
+    /** 最大握手重试间隔（毫秒） */
+    private readonly maxHandshakeRetryInterval;
+    /** 连接成功回调 */
+    private onConnected?;
+    /** 连接断开回调（自动重连时会触发） */
+    private onDisconnected?;
+    /** 接收数据回调 */
+    private onData?;
+    /** 错误回调 */
+    private onError?;
+    /** 连接关闭回调（手动断开或重连失败时触发） */
+    private onClose?;
+    constructor();
+    /**
+     * 设置 Socket 事件监听
+     */
+    private setupSocketEvents;
+    /**
+     * 检查是否达到最大重连次数
+     */
+    private hasReachedMaxAttempts;
+    /**
+     * 计算重连间隔（考虑指数退避）
+     */
+    private calculateReconnectInterval;
+    /**
+     * 计算握手超时重试间隔（使用指数退避）
+     */
+    private calculateHandshakeRetryInterval;
+    /**
+     * 触发重连
+     */
+    private triggerRetryConnection;
+    /**
+     * 执行重连
+     */
+    private retryConnection;
+    /**
+     * 启动心跳
+     */
+    private startHeartbeat;
+    /**
+     * 停止心跳
+     */
+    private stopHeartbeat;
+    /**
+     * 发送心跳包
+     */
+    private sendHeartbeat;
+    /**
+     * 清除心跳响应超时定时器
+     */
+    private clearHeartbeatTimeout;
+    /**
+     * 设置连接超时
+     */
+    private setConnectTimeout;
+    /**
+     * 清除连接超时定时器
+     */
+    private clearConnectTimeout;
+    /**
+     * 清除重连定时器
+     */
+    private clearRetryConnectTimeout;
+    /**
+     * 清理资源
+     */
+    private cleanup;
+    /**
+     * 设置事件回调
+     */
+    setEventHandlers(handlers: {
+        onConnected?: () => void;
+        onDisconnected?: () => void;
+        onData?: (data: Buffer) => void;
+        onError?: (error: Error) => void;
+        onClose?: () => void;
+    }): void;
+    /**
+     * 连接
+     */
+    connect(host: string, port: number, options: SocketConnectOptions): void;
+    /**
+     * 断开连接
+     */
+    disconnect(): void;
+    /**
+     * 获取 Socket 实例
+     */
+    getSocket(): net.Socket | null;
+    /**
+     * 检查是否已连接
+     */
+    isConnected(): boolean;
+    /**
+     * 设置心跳响应识别函数
+     */
+    setHeartbeatResponseChecker(checker: HeartbeatResponseChecker): void;
+    /**
+     * 获取当前连接地址
+     */
+    getAddress(): string | null;
+    /**
+     * 获取当前连接端口
+     */
+    getPort(): number | null;
+    /**
+     * 获取当前重连次数
+     */
+    getReconnectAttempts(): number;
+}
+//# sourceMappingURL=tcpWrapper.d.ts.map

package/dist/packages/tcp/tcpWrapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tcpWrapper.d.ts","sourceRoot":"","sources":["../../../src/packages/tcp/tcpWrapper.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,GAAG,MAAM,KAAK,CAAC;AAC3B,OAAO,KAAK,EAAE,oBAAoB,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AAWjF;;;GAGG;AACH,qBAAa,UAAU;IACtB,oBAAoB;IACpB,OAAO,CAAC,MAAM,CAA2B;IACzC,cAAc;IACd,OAAO,CAAC,cAAc,CAA+B;IACrD,YAAY;IACZ,OAAO,CAAC,mBAAmB,CAA+B;IAC1D,cAAc;IACd,OAAO,CAAC,iBAAiB,CAA+B;IACxD,gBAAgB;IAChB,OAAO,CAAC,gBAAgB,CAA+B;IAEvD,WAAW;IACX,OAAO,CAAC,OAAO,CAAuB;IACtC,WAAW;IACX,OAAO,CAAC,IAAI,CAAuB;IACnC,aAAa;IACb,OAAO,CAAC,cAAc,CAAqC;IAE3D,eAAe;IACf,OAAO,CAAC,gBAAgB,CAAkB;IAC1C,eAAe;IACf,OAAO,CAAC,aAAa,CAAkB;IACvC,eAAe;IACf,OAAO,CAAC,mBAAmB,CAAgB;IAC3C,iBAAiB;IACjB,OAAO,CAAC,kBAAkB,CAAgB;IAC1C,gBAAgB;IAChB,OAAO,CAAC,gBAAgB,CAAkB;IAC1C,eAAe;IACf,OAAO,CAAC,qBAAqB,CAAa;IAC1C,eAAe;IACf,OAAO,CAAC,wBAAwB,CAqB9B;IACF,qBAAqB;IACrB,OAAO,CAAC,oBAAoB,CAAa;IACzC,eAAe;IACf,OAAO,CAAC,wBAAwB,CAAiB;IACjD,oBAAoB;IACpB,OAAO,CAAC,oBAAoB,CAAiB;IAC7C,aAAa;IACb,OAAO,CAAC,iBAAiB,CAAa;IACtC,iBAAiB;IACjB,OAAO,CAAC,iBAAiB,CAAgB;IACzC,uBAAuB;IACvB,OAAO,CAAC,gBAAgB,CAAa;IACrC,eAAe;IACf,OAAO,CAAC,wBAAwB,CAAa;IAC7C,iBAAiB;IACjB,OAAO,CAAC,QAAQ,CAAC,2BAA2B,CAAa;IACzD,mBAAmB;IACnB,OAAO,CAAC,QAAQ,CAAC,0BAA0B,CAAgB;IAC3D,mBAAmB;IACnB,OAAO,CAAC,QAAQ,CAAC,yBAAyB,CAAgB;IAE1D,aAAa;IACb,OAAO,CAAC,WAAW,CAAC,CAAa;IACjC,uBAAuB;IACvB,OAAO,CAAC,cAAc,CAAC,CAAa;IACpC,aAAa;IACb,OAAO,CAAC,MAAM,CAAC,CAAyB;IACxC,WAAW;IACX,OAAO,CAAC,OAAO,CAAC,CAAyB;IACzC,2BAA2B;IAC3B,OAAO,CAAC,OAAO,CAAC,CAAa;;IAI7B;;OAEG;IACH,OAAO,CAAC,iBAAiB;IA8DzB;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAI7B;;OAEG;IACH,OAAO,CAAC,0BAA0B;IAOlC;;OAEG;IACH,OAAO,CAAC,+BAA+B;IASvC;;OAEG;IACH,OAAO,CAAC,sBAAsB;IAmB9B;;OAEG;IACH,OAAO,CAAC,eAAe;IAuBvB;;OAEG;IACH,OAAO,CAAC,cAAc;IAYtB;;OAEG;IACH,OAAO,CAAC,aAAa;IAUrB;;OAEG;IACH,OAAO,CAAC,aAAa;IAgCrB;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAO7B;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAgDzB;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAO3B;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAOhC;;OAEG;IACH,OAAO,CAAC,OAAO;IAIf;;OAEG;IACH,gBAAgB,CAAC,QAAQ,EAAE;QAC1B,WAAW,CAAC,EAAE,MAAM,IAAI,CAAC;QACzB,cAAc,CAAC,EAAE,MAAM,IAAI,CAAC;QAC5B,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;QAChC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;QACjC,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;KACrB,GAAG,IAAI;IAQR;;OAEG;IACH,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,oBAAoB,GAAG,IAAI;IAoDxE;;OAEG;IACH,UAAU,IAAI,IAAI;IAuBlB;;OAEG;IACH,SAAS,IAAI,GAAG,CAAC,MAAM,GAAG,IAAI;IAI9B;;OAEG;IACH,WAAW,IAAI,OAAO;IAItB;;OAEG;IACH,2BAA2B,CAAC,OAAO,EAAE,wBAAwB,GAAG,IAAI;IAIpE;;OAEG;IACH,UAAU,IAAI,MAAM,GAAG,IAAI;IAI3B;;OAEG;IACH,OAAO,IAAI,MAAM,GAAG,IAAI;IAIxB;;OAEG;IACH,oBAAoB,IAAI,MAAM;CAG9B"}

package/dist/packages/tcp/tcpWrapper.js

@@ -0,0 +1,472 @@
+// ALL_CODE_LINE: 450
+// AI_CODE_LINE: 40
+import * as net from 'net';
+import { DEFAULT_AUTO_RECONNECT, DEFAULT_RECONNECT_INTERVAL, DEFAULT_HEARTBEAT_INTERVAL, DEFAULT_HEARTBEAT_TIMEOUT, DEFAULT_MAX_RECONNECT_INTERVAL, DEFAULT_ENABLE_EXPONENTIAL_BACKOFF, DEFAULT_MAX_RECONNECT_ATTEMPTS, } from './constants.js';
+/**
+ * tcp连接管理器
+ * 负责处理 TCP 连接、重连、超时检测等
+ */
+export class TcpWrapper {
+    /** TCP Socket 实例 */
+    socket = null;
+    /** 连接超时定时器 */
+    connectTimeout = null;
+    /** 重连定时器 */
+    retryConnectTimeout = null;
+    /** 心跳发送定时器 */
+    heartbeatInterval = null;
+    /** 心跳响应超时定时器 */
+    heartbeatTimeout = null;
+    /** 连接地址 */
+    address = null;
+    /** 连接端口 */
+    port = null;
+    /** 连接配置选项 */
+    connectOptions = null;
+    /** 运行时的连接状态 */
+    connectionActive = false;
+    /** 是否启用自动重连 */
+    autoReconnect = false;
+    /** 心跳间隔（毫秒） */
+    heartbeatIntervalMs = 5000;
+    /** 心跳超时时间（毫秒） */
+    heartbeatTimeoutMs = 5000;
+    /** 是否有待响应的心跳 */
+    pendingHeartbeat = false;
+    /** 连续心跳超时次数 */
+    heartbeatTimeoutCount = 0;
+    /** 心跳响应识别函数 */
+    heartbeatResponseChecker = (data) => {
+        // data 是 Buffer 对象，需要转换为字符串比较
+        // 心跳响应可能是 "pong"（4字节）或 "pong\n"（5字节，带换行符）
+        if (data.length === 4) {
+            // 精确匹配 4 字节的 "pong"
+            return data.toString('utf8') === 'pong';
+        }
+        else if (data.length === 5) {
+            // 匹配 5 字节的 "pong\n" 或 "pong\r"
+            const dataStr = data.toString('utf8');
+            return dataStr === 'pong\n' || dataStr === 'pong\r';
+        }
+        else if (data.length > 4) {
+            // 检查数据开头是否是 "pong"（处理粘包情况：pong + 其他数据）
+            const first4Bytes = data.slice(0, 4);
+            if (first4Bytes.toString('utf8') === 'pong') {
+                // 检查第5个字节是否是换行符或数据结束
+                if (data.length === 5 || data[4] === 0x0a || data[4] === 0x0d) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    };
+    /** 最大重连次数，0 表示无限制 */
+    maxReconnectAttempts = 0;
+    /** 是否启用指数退避 */
+    enableExponentialBackoff = true;
+    /** 指数退避的最大间隔（毫秒） */
+    maxReconnectInterval = 60000;
+    /** 当前重连次数 */
+    reconnectAttempts = 0;
+    /** 基础重连间隔（毫秒） */
+    reconnectInterval = 5000;
+    /** 连接开始时间（用于计算握手时间） */
+    connectStartTime = 0;
+    /** 握手超时尝试次数 */
+    handshakeTimeoutAttempts = 0;
+    /** 最大握手超时尝试次数 */
+    maxHandshakeTimeoutAttempts = 3;
+    /** 基础握手重试间隔（毫秒） */
+    baseHandshakeRetryInterval = 1000;
+    /** 最大握手重试间隔（毫秒） */
+    maxHandshakeRetryInterval = 3000;
+    /** 连接成功回调 */
+    onConnected;
+    /** 连接断开回调（自动重连时会触发） */
+    onDisconnected;
+    /** 接收数据回调 */
+    onData;
+    /** 错误回调 */
+    onError;
+    /** 连接关闭回调（手动断开或重连失败时触发） */
+    onClose;
+    constructor() { }
+    /**
+     * 设置 Socket 事件监听
+     */
+    setupSocketEvents() {
+        if (!this.socket)
+            return;
+        this.socket.on('connect', () => {
+            this.clearConnectTimeout();
+            // 计算TCP握手时间
+            if (this.connectStartTime > 0) {
+                this.connectStartTime = 0; // 重置时间戳
+            }
+            // 连接成功，重置所有计数器
+            this.reconnectAttempts = 0;
+            this.heartbeatTimeoutCount = 0;
+            this.handshakeTimeoutAttempts = 0; // 重置握手超时计数
+            this.startHeartbeat();
+            // 触发连接成功回调
+            this.onConnected?.();
+        });
+        this.socket.on('data', (data) => {
+            // 检查是否是心跳响应
+            if (this.heartbeatResponseChecker?.(data)) {
+                this.clearHeartbeatTimeout();
+                this.pendingHeartbeat = false;
+                this.heartbeatTimeoutCount = 0; // 重置超时计数
+                return;
+            }
+            this.onData?.(data);
+        });
+        this.socket.on('close', (_hadError) => {
+            this.clearConnectTimeout();
+            this.stopHeartbeat();
+            this.cleanup();
+            if (this.connectionActive && this.autoReconnect) {
+                this.onDisconnected?.();
+                this.triggerRetryConnection();
+            }
+            else {
+                this.connectionActive = false;
+                this.onClose?.();
+            }
+        });
+        this.socket.on('error', (error) => {
+            this.clearConnectTimeout();
+            this.onError?.(error);
+            if (this.connectionActive && this.autoReconnect && this.socket?.destroyed) {
+                this.triggerRetryConnection();
+            }
+        });
+        this.socket.on('timeout', () => {
+            this.clearConnectTimeout();
+            this.socket?.destroy();
+            this.onError?.(new Error('Connection timeout'));
+        });
+    }
+    /**
+     * 检查是否达到最大重连次数
+     */
+    hasReachedMaxAttempts() {
+        return this.maxReconnectAttempts > 0 && this.reconnectAttempts >= this.maxReconnectAttempts;
+    }
+    /**
+     * 计算重连间隔（考虑指数退避）
+     */
+    calculateReconnectInterval() {
+        // 指数退避：interval = baseInterval * 2^attempts，但不超过 maxReconnectInterval
+        return !this.enableExponentialBackoff
+            ? this.reconnectInterval
+            : Math.min(this.reconnectInterval * Math.pow(2, this.reconnectAttempts), this.maxReconnectInterval);
+    }
+    /**
+     * 计算握手超时重试间隔（使用指数退避）
+     */
+    calculateHandshakeRetryInterval() {
+        // 指数退避：interval = baseInterval * 2^attempts，但不超过 maxHandshakeRetryInterval
+        // attempts 从 0 开始，所以第一次重试是 baseInterval * 2^0 = baseInterval
+        return Math.min(this.baseHandshakeRetryInterval * Math.pow(2, this.handshakeTimeoutAttempts - 1), this.maxHandshakeRetryInterval);
+    }
+    /**
+     * 触发重连
+     */
+    triggerRetryConnection() {
+        if (!this.connectionActive || !this.autoReconnect)
+            return;
+        // 检查最大重连次数
+        if (this.hasReachedMaxAttempts()) {
+            this.connectionActive = false;
+            this.onClose?.();
+            return;
+        }
+        // 如果已有重连定时器，不重复设置
+        if (this.retryConnectTimeout)
+            return;
+        const interval = this.calculateReconnectInterval();
+        this.retryConnectTimeout = setTimeout(() => {
+            this.retryConnection();
+        }, interval);
+    }
+    /**
+     * 执行重连
+     */
+    retryConnection() {
+        this.clearRetryConnectTimeout();
+        if (!this.connectionActive)
+            return;
+        if (this.isConnected())
+            return;
+        // 再次检查最大重连次数（防止在等待期间达到上限）||如果连接信息缺失，停止重连，避免无限递归
+        if (this.hasReachedMaxAttempts() || !this.connectOptions || !this.address || !this.port) {
+            this.connectionActive = false;
+            this.onClose?.();
+            return;
+        }
+        // 增加重连计数
+        this.reconnectAttempts++;
+        try {
+            this.connect(this.address, this.port, this.connectOptions);
+        }
+        catch (error) {
+            this.onError?.(error);
+        }
+    }
+    /**
+     * 启动心跳
+     */
+    startHeartbeat() {
+        if (this.heartbeatInterval)
+            return;
+        // 立即发送一次心跳
+        this.sendHeartbeat();
+        // 设置定时发送心跳
+        this.heartbeatInterval = setInterval(() => {
+            this.sendHeartbeat();
+        }, this.heartbeatIntervalMs);
+    }
+    /**
+     * 停止心跳
+     */
+    stopHeartbeat() {
+        if (this.heartbeatInterval) {
+            clearInterval(this.heartbeatInterval);
+            this.heartbeatInterval = null;
+        }
+        this.clearHeartbeatTimeout();
+        this.pendingHeartbeat = false;
+        this.heartbeatTimeoutCount = 0; // 重置超时计数
+    }
+    /**
+     * 发送心跳包
+     */
+    sendHeartbeat() {
+        if (!this.socket?.writable || this.socket.destroyed)
+            return;
+        try {
+            this.socket.write('ping');
+            this.pendingHeartbeat = true;
+            // 设置心跳响应超时
+            this.clearHeartbeatTimeout();
+            this.heartbeatTimeout = setTimeout(() => {
+                if (this.pendingHeartbeat) {
+                    this.heartbeatTimeoutCount++;
+                    // 只有连续2次心跳超时才清理socket
+                    if (this.heartbeatTimeoutCount >= 2) {
+                        this.connectionActive = false;
+                        this.onDisconnected?.();
+                        this.socket?.destroy();
+                        // 如果启用了自动重连，触发重连
+                        if (this.autoReconnect) {
+                            this.connectionActive = true;
+                            this.triggerRetryConnection();
+                        }
+                    }
+                }
+            }, this.heartbeatTimeoutMs);
+        }
+        catch (error) {
+            this.onError?.(error);
+        }
+    }
+    /**
+     * 清除心跳响应超时定时器
+     */
+    clearHeartbeatTimeout() {
+        if (this.heartbeatTimeout) {
+            clearTimeout(this.heartbeatTimeout);
+            this.heartbeatTimeout = null;
+        }
+    }
+    /**
+     * 设置连接超时
+     */
+    setConnectTimeout() {
+        this.clearConnectTimeout();
+        this.connectTimeout = setTimeout(() => {
+            if (this.socket && !this.socket.destroyed) {
+                this.handshakeTimeoutAttempts++;
+                // 如果未达到最大尝试次数，重试连接
+                if (this.handshakeTimeoutAttempts < this.maxHandshakeTimeoutAttempts) {
+                    // 清理当前socket
+                    this.socket.destroy();
+                    this.socket = null;
+                    // 计算重试延迟（使用指数退避）
+                    const retryDelay = this.calculateHandshakeRetryInterval();
+                    // 重新尝试连接
+                    if (this.address && this.port && this.connectOptions) {
+                        setTimeout(() => {
+                            if (this.connectionActive && !this.isConnected()) {
+                                try {
+                                    // 重新创建连接
+                                    this.socket = net.createConnection({
+                                        host: this.address,
+                                        port: this.port,
+                                        keepAlive: true,
+                                        keepAliveInitialDelay: 1000,
+                                    });
+                                    // 重新设置超时和事件
+                                    this.setConnectTimeout();
+                                    this.setupSocketEvents();
+                                }
+                                catch (error) {
+                                    this.onError?.(error);
+                                }
+                            }
+                        }, retryDelay);
+                    }
+                }
+                else {
+                    // 超过最大尝试次数，断开连接
+                    this.connectionActive = false;
+                    this.socket.destroy();
+                    this.onError?.(new Error(`Connection timeout after ${this.maxHandshakeTimeoutAttempts} attempts`));
+                    this.onClose?.();
+                }
+            }
+        }, 1000);
+    }
+    /**
+     * 清除连接超时定时器
+     */
+    clearConnectTimeout() {
+        if (this.connectTimeout) {
+            clearTimeout(this.connectTimeout);
+            this.connectTimeout = null;
+        }
+    }
+    /**
+     * 清除重连定时器
+     */
+    clearRetryConnectTimeout() {
+        if (this.retryConnectTimeout) {
+            clearTimeout(this.retryConnectTimeout);
+            this.retryConnectTimeout = null;
+        }
+    }
+    /**
+     * 清理资源
+     */
+    cleanup() {
+        this.clearConnectTimeout();
+    }
+    /**
+     * 设置事件回调
+     */
+    setEventHandlers(handlers) {
+        this.onConnected = handlers.onConnected;
+        this.onDisconnected = handlers.onDisconnected;
+        this.onData = handlers.onData;
+        this.onError = handlers.onError;
+        this.onClose = handlers.onClose;
+    }
+    /**
+     * 连接
+     */
+    connect(host, port, options) {
+        if (!host || !port) {
+            this.onError?.(new Error(`Invalid connection parameters: host=${host}, port=${port}`));
+            return;
+        }
+        // 保存连接信息用于重连
+        this.address = host;
+        this.port = port;
+        this.connectOptions = { ...options };
+        this.connectionActive = true;
+        // 配置重连和心跳
+        this.autoReconnect = options.autoReconnect ?? DEFAULT_AUTO_RECONNECT;
+        this.reconnectInterval = options.reconnectInterval ?? DEFAULT_RECONNECT_INTERVAL;
+        this.heartbeatIntervalMs = options.heartbeatInterval ?? DEFAULT_HEARTBEAT_INTERVAL;
+        this.heartbeatTimeoutMs = options.heartbeatTimeout ?? DEFAULT_HEARTBEAT_TIMEOUT;
+        this.maxReconnectAttempts = options.maxReconnectAttempts ?? DEFAULT_MAX_RECONNECT_ATTEMPTS;
+        this.enableExponentialBackoff = options.enableExponentialBackoff ?? DEFAULT_ENABLE_EXPONENTIAL_BACKOFF;
+        this.maxReconnectInterval = options.maxReconnectInterval ?? DEFAULT_MAX_RECONNECT_INTERVAL;
+        // 重置重连计数器和握手超时计数器（新连接时）
+        this.reconnectAttempts = 0;
+        this.handshakeTimeoutAttempts = 0;
+        // 如果已有 socket，先清理
+        if (this.socket) {
+            this.socket.removeAllListeners();
+            if (!this.socket.destroyed) {
+                this.socket.destroy();
+            }
+            this.socket = null;
+        }
+        // 记录连接开始时间（用于计算握手时间）
+        this.connectStartTime = Date.now();
+        // 创建 TCP 连接
+        this.socket = net.createConnection({
+            host,
+            port,
+            keepAlive: true,
+            keepAliveInitialDelay: 1000, // TCP keepalive 初始延迟时间（毫秒）
+        });
+        // 设置连接超时（ 1000ms）
+        this.setConnectTimeout();
+        // 绑定事件
+        this.setupSocketEvents();
+    }
+    /**
+     * 断开连接
+     */
+    disconnect() {
+        this.connectionActive = false;
+        this.clearConnectTimeout();
+        this.clearRetryConnectTimeout();
+        this.stopHeartbeat();
+        if (this.socket) {
+            if (this.socket.writable) {
+                this.socket.end();
+            }
+            else {
+                this.socket.destroy();
+            }
+            this.socket = null;
+        }
+        // 重置连接信息和所有计数器
+        this.address = null;
+        this.port = null;
+        this.connectOptions = null;
+        this.reconnectAttempts = 0;
+        this.handshakeTimeoutAttempts = 0;
+    }
+    /**
+     * 获取 Socket 实例
+     */
+    getSocket() {
+        return this.socket;
+    }
+    /**
+     * 检查是否已连接
+     */
+    isConnected() {
+        return this.socket !== null && !this.socket.destroyed && this.socket.writable;
+    }
+    /**
+     * 设置心跳响应识别函数
+     */
+    setHeartbeatResponseChecker(checker) {
+        this.heartbeatResponseChecker = checker || ((data) => data.toString() === 'pong');
+    }
+    /**
+     * 获取当前连接地址
+     */
+    getAddress() {
+        return this.address;
+    }
+    /**
+     * 获取当前连接端口
+     */
+    getPort() {
+        return this.port;
+    }
+    /**
+     * 获取当前重连次数
+     */
+    getReconnectAttempts() {
+        return this.reconnectAttempts;
+    }
+}
+//# sourceMappingURL=tcpWrapper.js.map