crh-jssdk 0.10.30 → 0.10.31

package/dist/business/base/crh-app-sdk-lczq.js

@@ -243,22 +243,14 @@ exports.default = {
     /**
      * 跳转个股详情页
      */
-    goStockDetail: function (params, type) {
-        if (type === void 0) { type = "StockSnap"; }
-        var code = params.code, market = params.market;
-        var instanceId = "hxqRequestBridge" + Math.floor(Math.random() * 999 + 1);
-        var data = {
-            instanceId: instanceId,
-            type: type,
-            params: {
-                stockCode: code,
-                stockmarket: market,
-            },
-            cancel: "",
-            subscribe: ""
-        };
+    goStockDetail: function (params) {
+        var stockcode = params.stockcode, stockmarket = params.stockmarket;
         try {
-            utils_1.globalBridge.bridgeCallHandler("", "hxqRequestBridge", data);
+            console.error("跳转个股详情数据:", stockcode, stockmarket);
+            utils_1.globalBridge.bridgeCallHandler("Promise", "HXJumpToStockFenshi", {
+                stockcode: stockcode,
+                stockmarket: stockmarket,
+            });
         }
         catch (error) {
             console.error("跳转个股详情失败:", error);

package/dist/business/index.js

@@ -146,11 +146,19 @@ var BUSINESS = /** @class */ (function () {
                         this.isApp = this.sdkObj.isApp();
                         this.webviewType = this.sdkObj.webviewType();
                         // 异步等待Bridge准备就绪，但不阻塞初始化
-                        this.bridge.waitForReady().then(function () {
-                            console.log("Bridge通信已准备就绪");
-                        }).catch(function (error) {
-                            console.warn("Bridge初始化超时或失败:", error);
-                        });
+                        // 使用 try-catch 包裹，避免未捕获的 Promise 错误
+                        try {
+                            this.bridge.waitForReady(5000).then(function () {
+                                console.log("Bridge通信已准备就绪");
+                            }).catch(function (error) {
+                                // 静默处理超时错误，不影响SDK初始化流程
+                                console.warn("Bridge初始化超时或失败:", error);
+                            });
+                        }
+                        catch (error) {
+                            // 捕获同步错误
+                            console.warn("Bridge waitForReady调用异常:", error);
+                        }
                         _l.label = 11;
                     case 11:
                         // 设置Bridge实例到sdkObj中，供各模块使用

package/dist/business/user/crh-app-sdk-lczq.js

@@ -122,23 +122,30 @@ exports.default = {
     },
     /**
      * 获取交易登录Token（会弹出登录框）
-     * @param appid 应用ID
+     * @param appidOrOptions 应用ID字符串，或包含appId和accountType的对象
      */
-    getTradeLoginToken: function () {
-        return __awaiter(this, arguments, void 0, function (appid) {
-            var params, response, error_2;
-            if (appid === void 0) { appid = APPID; }
+    getTradeLoginToken: function (appidOrOptions) {
+        return __awaiter(this, void 0, void 0, function () {
+            var appId, params, response, error_2;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         _a.trys.push([0, 2, , 3]);
+                        appId = APPID;
+                        if (typeof appidOrOptions === 'string') {
+                            appId = appidOrOptions;
+                        }
+                        else if (appidOrOptions && typeof appidOrOptions === 'object') {
+                            appId = appidOrOptions.appId || APPID;
+                            // accountType 参数暂时保留，但当前Bridge版本可能不支持，需要根据实际需求调整
+                        }
                         params = {
                             info_type: "wt",
                             call_type: "callback_after_login", // 强制登录
                             info_complete_check: "0",
                             key_type: "lccommon",
                             needEncryptTraceInfo: true,
-                            appId: appid,
+                            appId: appId,
                         };
                         console.log('获取交易登录Token，参数:', params);
                         return [4 /*yield*/, utils_1.globalBridge.bridgeCallHandler('Promise', 'getUserInfoByRsa', params)];

package/dist/business/utils/bridge.js

@@ -9,6 +9,7 @@ var Bridge = /** @class */ (function () {
     function Bridge() {
         this.bridge = null;
         this.initPromise = null;
+        this.isConnecting = false; // 标记是否正在连接，避免重复添加监听器
         this.initPromise = this.init();
     }
     /**
@@ -19,25 +20,70 @@ var Bridge = /** @class */ (function () {
         return new Promise(function (resolve) {
             _this.connectWebViewJavascriptBridge(function (bridge) {
                 _this.bridge = bridge;
-                bridge.init(function () {
-                    console.log('Bridge初始化完成');
+                // 确保bridge.init存在且是函数
+                if (bridge && typeof bridge.init === 'function') {
+                    bridge.init(function () {
+                        console.log('Bridge初始化完成');
+                        resolve();
+                    });
+                }
+                else {
+                    // 如果bridge已经初始化过，直接resolve
+                    console.log('Bridge已存在，跳过初始化');
                     resolve();
-                });
+                }
             });
         });
     };
     /**
      * 连接WebViewJavascriptBridge
+     * 避免重复添加事件监听器
      */
     Bridge.prototype.connectWebViewJavascriptBridge = function (callback) {
+        var _this = this;
+        // 如果Bridge已经存在，直接使用
         if (window.WebViewJavascriptBridge) {
             callback(window.WebViewJavascriptBridge);
+            return;
         }
-        else {
-            document.addEventListener('WebViewJavascriptBridgeReady', function () {
-                callback(window.WebViewJavascriptBridge);
-            }, false);
+        // 如果正在连接中，等待连接完成
+        if (this.isConnecting) {
+            // 等待Bridge准备就绪
+            var checkBridge_1 = function () {
+                if (window.WebViewJavascriptBridge) {
+                    callback(window.WebViewJavascriptBridge);
+                }
+                else {
+                    // 继续等待
+                    setTimeout(checkBridge_1, 100);
+                }
+            };
+            checkBridge_1();
+            return;
         }
+        // 标记为正在连接
+        this.isConnecting = true;
+        // 添加事件监听器（只添加一次）
+        var bridgeReadyHandler = function () {
+            _this.isConnecting = false;
+            if (window.WebViewJavascriptBridge) {
+                callback(window.WebViewJavascriptBridge);
+            }
+            // 移除监听器，避免重复调用
+            document.removeEventListener('WebViewJavascriptBridgeReady', bridgeReadyHandler);
+        };
+        document.addEventListener('WebViewJavascriptBridgeReady', bridgeReadyHandler, false);
+        // 设置超时，避免永久等待
+        setTimeout(function () {
+            if (_this.isConnecting) {
+                _this.isConnecting = false;
+                document.removeEventListener('WebViewJavascriptBridgeReady', bridgeReadyHandler);
+                // 如果超时后Bridge仍然不存在，尝试直接调用callback（可能Bridge已经通过其他方式加载）
+                if (window.WebViewJavascriptBridge) {
+                    callback(window.WebViewJavascriptBridge);
+                }
+            }
+        }, 10000); // 10秒超时
     };
     /**
      * 调用App方法（Promise版本）
@@ -53,7 +99,12 @@ var Bridge = /** @class */ (function () {
         if (type === 'Promise') {
             return new Promise(function (resolve, reject) {
                 try {
-                    _this.connectWebViewJavascriptBridge(function (bridge) {
+                    // 如果Bridge已初始化，直接使用；否则等待初始化完成
+                    var useBridge_1 = function (bridge) {
+                        if (!bridge || typeof bridge.callHandler !== 'function') {
+                            reject(new Error("Bridge\u672A\u6B63\u786E\u521D\u59CB\u5316\u6216callHandler\u65B9\u6CD5\u4E0D\u5B58\u5728"));
+                            return;
+                        }
                         bridge.callHandler(name, params, function (response) {
                             if (response) {
                                 resolve(response);
@@ -62,7 +113,39 @@ var Bridge = /** @class */ (function () {
                                 reject(new Error("\u8C03\u7528".concat(name, "\u65B9\u6CD5\u5931\u8D25\u4E86!")));
                             }
                         });
-                    });
+                    };
+                    if (_this.bridge) {
+                        // Bridge已初始化，直接使用
+                        useBridge_1(_this.bridge);
+                    }
+                    else {
+                        // Bridge未初始化，等待初始化完成
+                        _this.waitForReady(5000)
+                            .then(function () {
+                            if (_this.bridge) {
+                                useBridge_1(_this.bridge);
+                            }
+                            else {
+                                // 如果等待后仍然没有bridge，尝试重新连接（可能是动态加载的情况）
+                                _this.connectWebViewJavascriptBridge(function (bridge) {
+                                    _this.bridge = bridge;
+                                    useBridge_1(bridge);
+                                });
+                            }
+                        })
+                            .catch(function (error) {
+                            // 如果等待超时，尝试直接连接（可能是Bridge已经存在但未初始化）
+                            _this.connectWebViewJavascriptBridge(function (bridge) {
+                                if (bridge) {
+                                    _this.bridge = bridge;
+                                    useBridge_1(bridge);
+                                }
+                                else {
+                                    reject(new Error("Bridge\u521D\u59CB\u5316\u5931\u8D25: ".concat(error.message)));
+                                }
+                            });
+                        });
+                    }
                 }
                 catch (e) {
                     reject(e);
@@ -71,11 +154,37 @@ var Bridge = /** @class */ (function () {
         }
         // 不需要回调，只需要执行
         try {
-            this.connectWebViewJavascriptBridge(function (bridge) {
-                bridge.callHandler(name, params, function () {
-                    // dosomething
+            var useBridge_2 = function (bridge) {
+                if (bridge && typeof bridge.callHandler === 'function') {
+                    bridge.callHandler(name, params, function () {
+                        // dosomething
+                    });
+                }
+            };
+            if (this.bridge) {
+                useBridge_2(this.bridge);
+            }
+            else {
+                // 等待初始化或直接连接
+                this.waitForReady(3000)
+                    .then(function () {
+                    if (_this.bridge) {
+                        useBridge_2(_this.bridge);
+                    }
+                    else {
+                        _this.connectWebViewJavascriptBridge(function (bridge) {
+                            _this.bridge = bridge;
+                            useBridge_2(bridge);
+                        });
+                    }
+                })
+                    .catch(function () {
+                    _this.connectWebViewJavascriptBridge(function (bridge) {
+                        _this.bridge = bridge;
+                        useBridge_2(bridge);
+                    });
                 });
-            });
+            }
         }
         catch (e) {
             // dosomething
@@ -88,15 +197,42 @@ var Bridge = /** @class */ (function () {
      * @param callback 回调函数
      */
     Bridge.prototype.registerHandler = function (name, callback) {
+        var _this = this;
         if (name === void 0) { name = ''; }
         if (callback === void 0) { callback = function () { }; }
         try {
-            this.connectWebViewJavascriptBridge(function (bridge) {
-                bridge.registerHandler(name, function (data, responseCallback) {
-                    callback(data);
-                    responseCallback(data);
+            var useBridge_3 = function (bridge) {
+                if (bridge && typeof bridge.registerHandler === 'function') {
+                    bridge.registerHandler(name, function (data, responseCallback) {
+                        callback(data);
+                        responseCallback(data);
+                    });
+                }
+            };
+            if (this.bridge) {
+                useBridge_3(this.bridge);
+            }
+            else {
+                // 等待初始化或直接连接
+                this.waitForReady(3000)
+                    .then(function () {
+                    if (_this.bridge) {
+                        useBridge_3(_this.bridge);
+                    }
+                    else {
+                        _this.connectWebViewJavascriptBridge(function (bridge) {
+                            _this.bridge = bridge;
+                            useBridge_3(bridge);
+                        });
+                    }
+                })
+                    .catch(function () {
+                    _this.connectWebViewJavascriptBridge(function (bridge) {
+                        _this.bridge = bridge;
+                        useBridge_3(bridge);
+                    });
                 });
-            });
+            }
         }
         catch (e) {
             // dosomething
@@ -114,9 +250,11 @@ var Bridge = /** @class */ (function () {
      */
     Bridge.prototype.waitForReady = function (timeout) {
         if (timeout === void 0) { timeout = 5000; }
+        // 如果Bridge已经初始化，直接返回成功
         if (this.bridge) {
             return Promise.resolve();
         }
+        // 如果正在初始化，等待初始化完成
         if (this.initPromise) {
             return Promise.race([
                 this.initPromise,
@@ -125,7 +263,16 @@ var Bridge = /** @class */ (function () {
                 })
             ]);
         }
-        return Promise.reject(new Error('Bridge未开始初始化'));
+        // 如果初始化Promise不存在，尝试重新初始化
+        // 这可能是Bridge实例创建后，初始化还没有开始的情况
+        console.warn('Bridge未开始初始化，尝试重新初始化...');
+        this.initPromise = this.init();
+        return Promise.race([
+            this.initPromise,
+            new Promise(function (_, reject) {
+                setTimeout(function () { return reject(new Error('Bridge初始化超时')); }, timeout);
+            })
+        ]);
     };
     return Bridge;
 }());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "crh-jssdk",
-  "version": "0.10.30",
+  "version": "0.10.31",
   "description": "crh-jssdk",
   "main": "dist/index.js",
   "scripts": {

package/dist/package.json

@@ -1,20 +0,0 @@
-{
-  "name": "crh-jssdk",
-  "version": "0.10.28",
-  "description": "crh-jssdk",
-  "main": "dist/index.js",
-  "scripts": {
-    "build": "node build.js"
-  },
-  "keywords": [
-    "typescript"
-  ],
-  "publishConfig": {
-    "access": "public"
-  },
-  "author": "crh-fe",
-  "license": "ISC",
-  "devDependencies": {
-    "typescript": "^5.5.2"
-  }
-}