ztxkutils 2.10.66-45 → 2.10.66-46

package/dist/stompClient.d.ts

@@ -30,12 +30,25 @@ declare class StompClient {
     isInit: boolean;
     constructor(connectWsConfig: IConnectWsConfig);
     init(): void;
+    /**
+     * 连接失败后，将所有注册过的订阅、回调执行状态置为未执行状态。
+     * @param isExecute 连接通道、回调的执行状态
+     */
+    setExecuteFail(): void;
+    /**
+     * 连接成功后，需要将当前已注册的，未执行的连接通道重新执行连接
+     * 还有成功回调
+     * 失败回调的执行状态重置为未执行状态
+     * @returns 执行订阅相关回调
+     */
+    executeSubscribe(): void;
     getReconnectionTime(): number;
     subscribeSuccessCall(subscribeId: string, callback: () => void): void;
     subscribeErrorCall(subscribeId: string, callback: () => void): void;
     subscribe(subscribeId: string, pipe: string, callback?: (response: any) => void, headers?: any): void;
     getSubscriptions(key: any): any;
     disconnect(callback: () => void): Promise<unknown>;
+    reconnect(): Promise<unknown>;
     send(pipe: string, headers: object, message: string): void;
 }
 export default StompClient;

package/dist/stompClient.js

@@ -122,35 +122,7 @@ var StompClient = /** @class */ (function () {
                 slot1: _this.connectWsConfig.systemType,
                 slot2: Date.now(),
             }));
-            // 连接成功后，将当前已注册的，未执行的 连接通道 连接
-            var subscriptionsFnKeys = Object.keys(_this.subscriptionsFn);
-            if (Array.isArray(subscriptionsFnKeys)) {
-                subscriptionsFnKeys.forEach(function (key) {
-                    var _a = _this.subscriptionsFn[key], isExecute = _a.isExecute, subscriptionsFn = _a.subscriptionsFn;
-                    if (!isExecute) {
-                        subscriptionsFn === null || subscriptionsFn === void 0 ? void 0 : subscriptionsFn();
-                        _this.subscriptionsFn[key].isExecute = true;
-                    }
-                });
-            }
-            // 连接成功后，统一执行连接成功函数
-            var successCallbackKeys = Object.keys(_this.successCallbacks);
-            if (Array.isArray(successCallbackKeys)) {
-                successCallbackKeys.forEach(function (key) {
-                    var _a = _this.successCallbacks[key], isExecute = _a.isExecute, callback = _a.callback;
-                    if (!isExecute) {
-                        callback && callback();
-                    }
-                    _this.successCallbacks[key].isExecute = true;
-                });
-            }
-            // 将失败回调 的执行状态 重置为未执行状态
-            var errorCallbackKeys = Object.keys(_this.errorCallbacks);
-            if (Array.isArray(errorCallbackKeys)) {
-                errorCallbackKeys.forEach(function (key) {
-                    _this.errorCallbacks[key].isExecute = false;
-                });
-            }
+            _this.executeSubscribe();
         }, 
         // 连接失败回调
         function (err) {
@@ -170,6 +142,8 @@ var StompClient = /** @class */ (function () {
                     clearTimeout(_this.clearIsClientYes);
                     _this.clearIsClientYes = null;
                 }
+                // 连接失败后，将所有注册过的订阅、回调执行状态置为未执行状态。
+                _this.setExecuteFail();
                 console.log(instance.t('用户主动关闭'));
                 return;
             }
@@ -186,32 +160,8 @@ var StompClient = /** @class */ (function () {
                 clearTimeout(_this.clearIsClientYes);
                 _this.clearIsClientYes = null;
             }
-            // this.errorCallback(err);
-            // 连接失败后，将当前已注册的 连接通道 全部置为未执行状态
-            var subscriptionsFnKeys = Object.keys(_this.subscriptionsFn);
-            if (Array.isArray(subscriptionsFnKeys)) {
-                subscriptionsFnKeys.forEach(function (key) {
-                    _this.subscriptionsFn[key].isExecute = false;
-                });
-            }
-            // 连接失败后，统一执行连接失败函数
-            var errorCallbackKeys = Object.keys(_this.errorCallbacks);
-            if (Array.isArray(errorCallbackKeys)) {
-                errorCallbackKeys.forEach(function (key) {
-                    var _a = _this.errorCallbacks[key], isExecute = _a.isExecute, callback = _a.callback;
-                    if (!isExecute) {
-                        callback && callback();
-                    }
-                    _this.errorCallbacks[key].isExecute = true;
-                });
-            }
-            // 将成功回调 的执行状态 重置为未执行状态
-            var successCallbackKeys = Object.keys(_this.successCallbacks);
-            if (Array.isArray(successCallbackKeys)) {
-                successCallbackKeys.forEach(function (key) {
-                    _this.successCallbacks[key].isExecute = false;
-                });
-            }
+            // 连接失败后，将所有注册过的订阅、回调执行状态置为未执行状态。
+            _this.setExecuteFail();
             // 重连逻辑, 默认3秒后重连
             // 重连间隔，每隔5秒递增，超过最大间隔时间后，取最大间隔时间重连
             try {
@@ -223,9 +173,6 @@ var StompClient = /** @class */ (function () {
                 console.log(instance.t('---连接已建立的关闭出错 time={{slot0}}system={{slot1}}---', { slot0: Date.now(), slot1: _this.connectWsConfig.systemType }), err);
             }
             _this.reconnectionNum++;
-            // const timeInterval =
-            //   Math.ceil(this.reconnectionNum / 5) *
-            //   (this.connectWsConfig.reconnectionTime ?? 3000);
             var timeInterval = _this.getReconnectionTime();
             console.log(instance.t('---第{{slot0}}次重连！time={{slot1}}system={{slot2}}', {
                 slot0: _this.reconnectionNum,
@@ -239,6 +186,76 @@ var StompClient = /** @class */ (function () {
                 : timeInterval);
         });
     };
+    /**
+     * 连接失败后，将所有注册过的订阅、回调执行状态置为未执行状态。
+     * @param isExecute 连接通道、回调的执行状态
+     */
+    StompClient.prototype.setExecuteFail = function () {
+        var _this = this;
+        // 连接失败后，将当前已注册的 连接通道 全部置为未执行状态
+        var subscriptionsFnKeys = Object.keys(this.subscriptionsFn);
+        if (Array.isArray(subscriptionsFnKeys)) {
+            subscriptionsFnKeys.forEach(function (key) {
+                _this.subscriptionsFn[key].isExecute = false;
+            });
+        }
+        // 连接失败后，统一执行连接失败函数
+        var errorCallbackKeys = Object.keys(this.errorCallbacks);
+        if (Array.isArray(errorCallbackKeys)) {
+            errorCallbackKeys.forEach(function (key) {
+                var _a = _this.errorCallbacks[key], isExecute = _a.isExecute, callback = _a.callback;
+                if (!isExecute) {
+                    callback && callback();
+                }
+                _this.errorCallbacks[key].isExecute = true;
+            });
+        }
+        // 将成功回调 的执行状态 重置为未执行状态
+        var successCallbackKeys = Object.keys(this.successCallbacks);
+        if (Array.isArray(successCallbackKeys)) {
+            successCallbackKeys.forEach(function (key) {
+                _this.successCallbacks[key].isExecute = false;
+            });
+        }
+    };
+    /**
+     * 连接成功后，需要将当前已注册的，未执行的连接通道重新执行连接
+     * 还有成功回调
+     * 失败回调的执行状态重置为未执行状态
+     * @returns 执行订阅相关回调
+     */
+    StompClient.prototype.executeSubscribe = function () {
+        var _this = this;
+        // 连接成功后，将当前已注册的，未执行的 连接通道 连接
+        var subscriptionsFnKeys = Object.keys(this.subscriptionsFn);
+        if (Array.isArray(subscriptionsFnKeys)) {
+            subscriptionsFnKeys.forEach(function (key) {
+                var _a = _this.subscriptionsFn[key], isExecute = _a.isExecute, subscriptionsFn = _a.subscriptionsFn;
+                if (!isExecute) {
+                    subscriptionsFn === null || subscriptionsFn === void 0 ? void 0 : subscriptionsFn();
+                    _this.subscriptionsFn[key].isExecute = true;
+                }
+            });
+        }
+        // 连接成功后，统一执行连接成功函数
+        var successCallbackKeys = Object.keys(this.successCallbacks);
+        if (Array.isArray(successCallbackKeys)) {
+            successCallbackKeys.forEach(function (key) {
+                var _a = _this.successCallbacks[key], isExecute = _a.isExecute, callback = _a.callback;
+                if (!isExecute) {
+                    callback && callback();
+                }
+                _this.successCallbacks[key].isExecute = true;
+            });
+        }
+        // 将失败回调 的执行状态 重置为未执行状态
+        var errorCallbackKeys = Object.keys(this.errorCallbacks);
+        if (Array.isArray(errorCallbackKeys)) {
+            errorCallbackKeys.forEach(function (key) {
+                _this.errorCallbacks[key].isExecute = false;
+            });
+        }
+    };
     // 重连时间计算
     StompClient.prototype.getReconnectionTime = function () {
         var _a;
@@ -323,6 +340,28 @@ var StompClient = /** @class */ (function () {
             }
         });
     };
+    // 手动重新连接
+    StompClient.prototype.reconnect = function () {
+        var _this = this;
+        this.isInit = false;
+        this.userClose = true;
+        return new Promise(function (resolve, reject) {
+            try {
+                _this.setExecuteFail();
+                _this.client.disconnect(function () {
+                    _this.client = null;
+                    resolve(null);
+                });
+                setTimeout(function () {
+                    _this.userClose = false;
+                    _this.init();
+                }, 400);
+            }
+            catch (err) {
+                resolve(null);
+            }
+        });
+    };
     // 发送消息
     StompClient.prototype.send = function (pipe, headers, message) {
         if (typeof headers === 'string') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ztxkutils",
-  "version": "2.10.66-45",
+  "version": "2.10.66-46",
   "description": "",
   "main": "./dist/index.js",
   "module": "./dist/index.js",