@pisell/pisellos 2.1.28 → 2.1.30

package/dist/solution/Checkout/index.js

@@ -1,4 +1,8 @@
 function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
 function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
 function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
 function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
@@ -55,6 +59,8 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
     _defineProperty(_assertThisInitialized(_this), "otherParams", {});
     _defineProperty(_assertThisInitialized(_this), "logger", void 0);
     // LoggerManager 实例
+    // 计算缓存（用于性能优化）
+    _defineProperty(_assertThisInitialized(_this), "calculationCache", {});
     // 直接挂载的模块
     _defineProperty(_assertThisInitialized(_this), "order", void 0);
     _defineProperty(_assertThisInitialized(_this), "payment", void 0);
@@ -539,7 +545,7 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
     value: (function () {
       var _createLocalOrderAsync = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee9(params) {
         var _params$orderData, _params$orderData2, _params$orderData3, _params$orderData4, _params$orderData5, _params$cartSummary;
-        var _params$totalInfo, _params$totalInfo2, _params$totalInfo3, _params$totalInfo4, validation, localOrderId, amountInfo, customerInfo, isNeedDeposit, paymentOrder;
+        var _params$totalInfo, _params$totalInfo2, _params$totalInfo3, _params$totalInfo4, validation, localOrderId, amountInfo, customerInfo, isNeedDeposit, paymentOrder, updateAmountStartTime, updateAmountDuration;
         return _regeneratorRuntime().wrap(function _callee9$(_context9) {
           while (1) switch (_context9.prev = _context9.next) {
             case 0:
@@ -554,17 +560,16 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
                 totalInfoKeys: params.totalInfo ? Object.keys(params.totalInfo) : []
               });
               _context9.prev = 1;
-              _context9.next = 4;
-              return this.resetStoreStateAsync();
-            case 4:
+              // 🔧 修改：在创建新订单前，直接重置 store 状态（同步执行）
+              this.resetStoreState();
               // 验证订单数据
               validation = validateLocalOrderData(params.orderData);
               if (validation.valid) {
-                _context9.next = 7;
+                _context9.next = 6;
                 break;
               }
               throw createCheckoutError(CheckoutErrorType.ValidationFailed, "\u8BA2\u5355\u6570\u636E\u9A8C\u8BC1\u5931\u8D25: ".concat(validation.errors.join(', ')));
-            case 7:
+            case 6:
               // 生成本地虚拟订单ID (后续可以被真实订单ID替换)
               localOrderId = generateLocalOrderId(); // 从购物车小计数据中提取金额信息
               amountInfo = extractAmountFromCartSummary(params.cartSummary); // TODO： 外面传的是 pos ，但是现在 后端只有 shop 和 kiosk
@@ -598,7 +603,7 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
 
               // 计算是否需要支付定金，如果需要默认切换到定金模式，以及记录定金总金额，并把当前默认待付金额调整为定金总金额
               isNeedDeposit = this.checkIsNeedDepositAsync(params.orderData.bookings, params.orderData.relation_products); // 创建支付订单对象
-              _context9.next = 22;
+              _context9.next = 21;
               return this.payment.createPaymentOrderAsync({
                 order_id: localOrderId,
                 total_amount: amountInfo.totalAmount,
@@ -615,23 +620,34 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
                   amount_breakdown: amountInfo
                 }
               });
-            case 22:
+            case 21:
               paymentOrder = _context9.sent;
               this.store.currentOrder = paymentOrder;
 
-              // 如果设置了自动支付，直接跳转到支付步骤
-              if (params.autoPayment) {
-                // 自动支付模式标记
-              }
+              // // 如果设置了自动支付，直接跳转到支付步骤
+              // if (params.autoPayment) {
+              //   // 自动支付模式标记
+              // }
+
               this.core.effects.emit(CheckoutHooks.OnOrderCreated, {
                 order: paymentOrder,
                 timestamp: Date.now()
               });
 
               // 自动设置 stateAmount 为剩余未支付金额
-              _context9.next = 28;
+              // 🚀 性能监控：记录 updateStateAmountToRemaining 操作耗时
+              updateAmountStartTime = Date.now();
+              _context9.next = 27;
               return this.updateStateAmountToRemaining(false);
-            case 28:
+            case 27:
+              updateAmountDuration = Date.now() - updateAmountStartTime;
+              this.logInfo('updateStateAmountToRemaining operation completed', {
+                operation: 'updateStateAmountToRemaining',
+                orderUuid: paymentOrder.uuid,
+                orderId: paymentOrder.order_id,
+                duration: "".concat(updateAmountDuration, "ms"),
+                performance: updateAmountDuration > 200 ? 'slow' : updateAmountDuration > 100 ? 'medium' : 'fast'
+              });
               this.logInfo('本地订单创建成功:', {
                 localOrderId: localOrderId,
                 uuid: paymentOrder.uuid,
@@ -642,23 +658,23 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
               });
               this.initWalletData();
               return _context9.abrupt("return", paymentOrder);
-            case 33:
-              _context9.prev = 33;
+            case 34:
+              _context9.prev = 34;
               _context9.t0 = _context9["catch"](1);
-              _context9.next = 37;
+              _context9.next = 38;
               return this.handleError(_context9.t0, CheckoutErrorType.OrderCreationFailed);
-            case 37:
+            case 38:
               this.logError('本地订单创建失败:', _context9.t0);
               this.core.effects.emit(CheckoutHooks.OnOrderCreationFailed, {
                 error: this.store.lastError,
                 timestamp: Date.now()
               });
               throw _context9.t0;
-            case 40:
+            case 41:
             case "end":
               return _context9.stop();
           }
-        }, _callee9, this, [[1, 33]]);
+        }, _callee9, this, [[1, 34]]);
       }));
       function createLocalOrderAsync(_x11) {
         return _createLocalOrderAsync.apply(this, arguments);
@@ -740,7 +756,7 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
               });
               paidAmount = activePayments.reduce(function (sum, p) {
                 var amt = new Decimal(p.amount || '0');
-                var rounding = new Decimal(p.rounding_amount || '0').abs();
+                var rounding = new Decimal(Number(p.rounding_amount) > 0 ? 0 : p.rounding_amount || '0').abs();
                 return sum.plus(amt).plus(rounding);
               }, new Decimal(0));
               remaining = Decimal.max(0, totalAmount.minus(paidAmount)).toFixed(2); // 计算是否需要支付定金，如果需要默认切换到定金模式，以及记录定金总金额，并把当前默认待付金额调整为定金总金额
@@ -795,7 +811,7 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
               // 需要减去已经同步给后端的支付过的钱
               syncedAmount = activePayments.reduce(function (sum, p) {
                 var amt = new Decimal(p.amount || '0');
-                var rounding = new Decimal(p.rounding_amount || '0').abs();
+                var rounding = new Decimal(Number(p.rounding_amount) > 0 ? 0 : p.rounding_amount || '0').abs();
                 return sum.plus(amt).plus(rounding);
               }, new Decimal(0));
               remainingExpectAmount = Decimal.max(0, totalAmount.minus(syncedAmount)).toFixed(2); // 要计算一个总价的差值和一个定金的差值，如果定金的差值>0，则需要使用定金的差值，否则使用总价的差值
@@ -882,28 +898,26 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
             case 11:
               console.log('[Checkout] 结账流程完成:', order.id);
 
-              // 🔧 新增：自动重置 store 状态
-              _context11.next = 14;
-              return this.resetStoreStateAsync();
-            case 14:
+              // 🔧 新增：自动重置 store 状态（同步执行）
+              this.resetStoreState();
               return _context11.abrupt("return", {
                 success: true,
                 orderId: String(order.id)
               });
-            case 17:
-              _context11.prev = 17;
+            case 16:
+              _context11.prev = 16;
               _context11.t0 = _context11["catch"](0);
-              _context11.next = 21;
+              _context11.next = 20;
               return this.handleError(_context11.t0, CheckoutErrorType.UnknownError);
-            case 21:
+            case 20:
               return _context11.abrupt("return", {
                 success: false
               });
-            case 22:
+            case 21:
             case "end":
               return _context11.stop();
           }
-        }, _callee11, this, [[0, 17]]);
+        }, _callee11, this, [[0, 16]]);
       }));
       function completeCheckoutAsync() {
         return _completeCheckoutAsync.apply(this, arguments);
@@ -1319,16 +1333,19 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
             case 12:
               this.logInfo('支付项添加成功');
 
+              // 🚀 清除计算缓存，确保获取最新数据
+              this.clearCalculationCache();
+
               // 支付项添加后，更新 stateAmount 为剩余未支付金额
-              _context16.next = 15;
+              _context16.next = 16;
               return this.updateStateAmountToRemaining();
-            case 15:
-              _context16.next = 17;
+            case 16:
+              _context16.next = 18;
               return this.calculateRemainingAmountAsync();
-            case 17:
+            case 18:
               remainingAmount = _context16.sent;
               if (!(Number(remainingAmount) > 0)) {
-                _context16.next = 38;
+                _context16.next = 39;
                 break;
               }
               this.logInfo('订单金额还有待付的，同步 EFTPOS 支付');
@@ -1343,30 +1360,30 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
                 currentOrderSynced: this.store.isOrderSynced
               });
               if (!(isEftposPayment || _isCashPayment || isCustomePayment)) {
-                _context16.next = 38;
+                _context16.next = 39;
                 break;
               }
               this.logInfo('检测到 EFTPOS 支付，立即同步订单到后端...');
-              _context16.prev = 26;
-              _context16.next = 29;
+              _context16.prev = 27;
+              _context16.next = 30;
               return this.syncOrderToBackendWithReturn(true);
-            case 29:
+            case 30:
               syncResult = _context16.sent;
               this.logInfo('EFTPOS 支付后订单同步完成 (已标记为手动同步):', {
                 orderId: syncResult.orderId,
                 isOrderSynced: this.store.isOrderSynced,
                 backendResponse: syncResult.response
               });
-              _context16.next = 38;
+              _context16.next = 39;
               break;
-            case 33:
-              _context16.prev = 33;
-              _context16.t0 = _context16["catch"](26);
+            case 34:
+              _context16.prev = 34;
+              _context16.t0 = _context16["catch"](27);
               this.logError('EFTPOS 支付后订单同步失败:', _context16.t0);
               // 不抛出错误，避免影响支付流程，但记录错误
-              _context16.next = 38;
+              _context16.next = 39;
               return this.handleError(new Error("EFTPOS \u652F\u4ED8\u540E\u8BA2\u5355\u540C\u6B65\u5931\u8D25: ".concat(_context16.t0 instanceof Error ? _context16.t0.message : String(_context16.t0))), CheckoutErrorType.OrderCreationFailed);
-            case 38:
+            case 39:
               // 触发支付项添加事件（可以复用支付开始事件）
               this.core.effects.emit(CheckoutHooks.OnPaymentItemAdded, {
                 orderUuid: this.store.currentOrder.uuid,
@@ -1375,21 +1392,21 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
                 amount: String(paymentItem.amount),
                 timestamp: Date.now()
               });
-              _context16.next = 47;
+              _context16.next = 48;
               break;
-            case 41:
-              _context16.prev = 41;
+            case 42:
+              _context16.prev = 42;
               _context16.t1 = _context16["catch"](1);
               this.logError('添加支付项失败:', _context16.t1);
-              _context16.next = 46;
+              _context16.next = 47;
               return this.handleError(_context16.t1, CheckoutErrorType.PaymentFailed);
-            case 46:
-              throw _context16.t1;
             case 47:
+              throw _context16.t1;
+            case 48:
             case "end":
               return _context16.stop();
           }
-        }, _callee16, this, [[1, 41], [26, 33]]);
+        }, _callee16, this, [[1, 42], [27, 34]]);
       }));
       function addPaymentItemAsync(_x15) {
         return _addPaymentItemAsync.apply(this, arguments);
@@ -1454,12 +1471,15 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
             case 13:
               this.logInfo('Payment支付项删除完成', paymentItem);
 
+              // 🚀 清除计算缓存，确保获取最新数据
+              this.clearCalculationCache();
+
               // 重新从Payment模块获取最新的订单数据，确保支付项同步
               currentOrderId = this.store.currentOrder.order_id; // 保存当前的订单ID
               isCurrentOrderReal = currentOrderId && !isVirtualOrderId(currentOrderId);
-              _context17.next = 18;
+              _context17.next = 19;
               return this.payment.getPaymentOrderByUuidAsync(this.store.currentOrder.uuid);
-            case 18:
+            case 19:
               updatedOrder = _context17.sent;
               if (updatedOrder) {
                 // 如果当前订单ID是真实ID，但获取到的订单ID是虚拟ID，需要保护真实ID
@@ -1474,10 +1494,10 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
               }
 
               // 更新 stateAmount 为剩余未支付金额
-              _context17.next = 22;
+              _context17.next = 23;
               return this.updateStateAmountToRemaining(false);
-            case 22:
-              _context17.next = 24;
+            case 23:
+              _context17.next = 25;
               return this.core.effects.emit(CheckoutHooks.OnPaymentStarted, {
                 orderUuid: this.store.currentOrder.uuid,
                 paymentMethodCode: paymentItem.code,
@@ -1485,22 +1505,22 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
                 // 负数表示删除
                 timestamp: Date.now()
               });
-            case 24:
-              _context17.next = 32;
+            case 25:
+              _context17.next = 33;
               break;
-            case 26:
-              _context17.prev = 26;
+            case 27:
+              _context17.prev = 27;
               _context17.t0 = _context17["catch"](0);
               this.logError('删除支付项失败:', _context17.t0);
-              _context17.next = 31;
+              _context17.next = 32;
               return this.handleError(_context17.t0, CheckoutErrorType.PaymentFailed);
-            case 31:
-              throw _context17.t0;
             case 32:
+              throw _context17.t0;
+            case 33:
             case "end":
               return _context17.stop();
           }
-        }, _callee17, this, [[0, 26]]);
+        }, _callee17, this, [[0, 27]]);
       }));
       function deletePaymentItemAsync(_x16) {
         return _deletePaymentItemAsync.apply(this, arguments);
@@ -1585,12 +1605,15 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
               _context18.next = 20;
               return this.payment.updateVoucherPaymentItemsAsync(this.store.currentOrder.uuid, voucherPaymentItemsWithType);
             case 20:
+              // 🚀 清除计算缓存，确保获取最新数据
+              this.clearCalculationCache();
+
               // 重新从Payment模块获取最新的订单数据，确保支付项同步
               currentOrderId = this.store.currentOrder.order_id; // 保存当前的订单ID
               isCurrentOrderReal = currentOrderId && !isVirtualOrderId(currentOrderId);
-              _context18.next = 24;
+              _context18.next = 25;
               return this.payment.getPaymentOrderByUuidAsync(this.store.currentOrder.uuid);
-            case 24:
+            case 25:
               updatedOrder = _context18.sent;
               if (updatedOrder) {
                 // 如果当前订单ID是真实ID，但获取到的订单ID是虚拟ID，需要保护真实ID
@@ -1605,10 +1628,10 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
               }
 
               // 更新 stateAmount 为剩余未支付金额
-              _context18.next = 28;
+              _context18.next = 29;
               return this.updateStateAmountToRemaining(false);
-            case 28:
-              _context18.next = 30;
+            case 29:
+              _context18.next = 31;
               return this.core.effects.emit(CheckoutHooks.OnPaymentStarted, {
                 orderUuid: this.store.currentOrder.uuid,
                 paymentMethodCode: 'VOUCHER_BATCH',
@@ -1617,23 +1640,23 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
                 }, 0).toFixed(2),
                 timestamp: Date.now()
               });
-            case 30:
+            case 31:
               this.logInfo('代金券支付项批量更新成功');
-              _context18.next = 39;
+              _context18.next = 40;
               break;
-            case 33:
-              _context18.prev = 33;
+            case 34:
+              _context18.prev = 34;
               _context18.t0 = _context18["catch"](0);
               this.logError('[Checkout] 批量更新代金券支付项失败:', _context18.t0);
-              _context18.next = 38;
+              _context18.next = 39;
               return this.handleError(_context18.t0, CheckoutErrorType.PaymentFailed);
-            case 38:
-              throw _context18.t0;
             case 39:
+              throw _context18.t0;
+            case 40:
             case "end":
               return _context18.stop();
           }
-        }, _callee18, this, [[0, 33]]);
+        }, _callee18, this, [[0, 34]]);
       }));
       function updateVoucherPaymentItemsAsync(_x17) {
         return _updateVoucherPaymentItemsAsync.apply(this, arguments);
@@ -1707,34 +1730,37 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
               if (this.store.localOrderData) {
                 this.store.localOrderData.is_deposit = newDepositValue;
               }
+
+              // 🚀 清除计算缓存，确保获取最新数据
+              this.clearCalculationCache();
               this.updateStateAmountToRemaining(false);
 
               // 触发订单更新事件
-              _context19.next = 20;
+              _context19.next = 21;
               return this.core.effects.emit(CheckoutHooks.OnOrderCreated, {
                 order: this.store.currentOrder,
                 timestamp: Date.now()
               });
-            case 20:
+            case 21:
               this.logInfo('订单定金状态更新成功:', {
                 isDeposit: newDepositValue,
                 depositAmount: this.store.currentOrder.deposit_amount
               });
-              _context19.next = 29;
+              _context19.next = 30;
               break;
-            case 23:
-              _context19.prev = 23;
+            case 24:
+              _context19.prev = 24;
               _context19.t0 = _context19["catch"](0);
               this.logError('更新订单定金状态失败:', _context19.t0);
-              _context19.next = 28;
+              _context19.next = 29;
               return this.handleError(_context19.t0, CheckoutErrorType.ValidationFailed);
-            case 28:
-              throw _context19.t0;
             case 29:
+              throw _context19.t0;
+            case 30:
             case "end":
               return _context19.stop();
           }
-        }, _callee19, this, [[0, 23]]);
+        }, _callee19, this, [[0, 24]]);
       }));
       function updateOrderDepositStatusAsync(_x18) {
         return _updateOrderDepositStatusAsync.apply(this, arguments);
@@ -1833,15 +1859,18 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
                   this.store.localOrderData.is_deposit = updateParams.is_deposit;
                 }
               }
+
+              // 🚀 清除计算缓存，确保获取最新数据
+              this.clearCalculationCache();
               this.updateStateAmountToRemaining(false);
 
               // 触发订单更新事件
-              _context20.next = 22;
+              _context20.next = 23;
               return this.core.effects.emit(CheckoutHooks.OnOrderCreated, {
                 order: this.store.currentOrder,
                 timestamp: Date.now()
               });
-            case 22:
+            case 23:
               this.logInfo('订单定金金额设置成功:', {
                 orderUuid: this.store.currentOrder.uuid,
                 orderId: this.store.currentOrder.order_id,
@@ -1850,21 +1879,21 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
                 isDeposit: this.store.currentOrder.is_deposit,
                 totalAmount: this.store.currentOrder.total_amount
               });
-              _context20.next = 31;
+              _context20.next = 32;
               break;
-            case 25:
-              _context20.prev = 25;
+            case 26:
+              _context20.prev = 26;
               _context20.t0 = _context20["catch"](1);
               this.logError('设置订单定金金额失败:', _context20.t0);
-              _context20.next = 30;
+              _context20.next = 31;
               return this.handleError(_context20.t0, CheckoutErrorType.ValidationFailed);
-            case 30:
-              throw _context20.t0;
             case 31:
+              throw _context20.t0;
+            case 32:
             case "end":
               return _context20.stop();
           }
-        }, _callee20, this, [[1, 25]]);
+        }, _callee20, this, [[1, 26]]);
       }));
       function setDepositAmountAsync(_x19) {
         return _setDepositAmountAsync.apply(this, arguments);
@@ -1886,6 +1915,7 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
         return _regeneratorRuntime().wrap(function _callee21$(_context21) {
           while (1) switch (_context21.prev = _context21.next) {
             case 0:
+              console.log('manualSyncOrderAsync called');
               this.logInfo('manualSyncOrderAsync called', {
                 hasCurrentOrder: !!this.store.currentOrder,
                 currentOrderId: (_this$store$currentOr11 = this.store.currentOrder) === null || _this$store$currentOr11 === void 0 ? void 0 : _this$store$currentOr11.order_id,
@@ -1894,16 +1924,16 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
                 isOrderSynced: this.store.isOrderSynced,
                 isVirtualOrderId: this.store.currentOrder ? isVirtualOrderId(this.store.currentOrder.order_id) : false
               });
-              _context21.prev = 1;
+              _context21.prev = 2;
               if (this.store.currentOrder) {
-                _context21.next = 4;
+                _context21.next = 5;
                 break;
               }
               return _context21.abrupt("return", {
                 success: false,
                 message: '当前没有活跃订单，无法同步'
               });
-            case 4:
+            case 5:
               orderUuid = this.store.currentOrder.uuid;
               oldOrderId = this.store.currentOrder.order_id; // 检查订单是否已经同步
               if (this.store.isOrderSynced) {
@@ -1913,9 +1943,9 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
               _context21.t1 = orderUuid;
               _context21.t2 = oldOrderId;
               _context21.t3 = this.store.currentOrder.total_amount;
-              _context21.next = 13;
+              _context21.next = 14;
               return this.calculateRemainingAmountAsync();
-            case 13:
+            case 14:
               _context21.t4 = _context21.sent;
               _context21.t5 = {
                 orderUuid: _context21.t1,
@@ -1924,10 +1954,14 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
                 remainingAmount: _context21.t4
               };
               _context21.t0.logInfo.call(_context21.t0, '开始手动同步订单到后端:', _context21.t5);
-              _context21.next = 18;
+              console.time('manualSyncOrderAsync');
+
+              // 强制同步订单到后端，并获取完整响应数据
+              _context21.next = 20;
               return this.syncOrderToBackendWithReturn(true);
-            case 18:
+            case 20:
               syncResult = _context21.sent;
+              console.timeEnd('manualSyncOrderAsync');
               this.logInfo('手动同步订单完成:', {
                 orderUuid: orderUuid,
                 syncResult: syncResult,
@@ -1948,13 +1982,13 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
               newRes = _objectSpread(_objectSpread({}, syncResult), {}, {
                 is_deposit: ((_this$store$currentOr14 = this.store.currentOrder) === null || _this$store$currentOr14 === void 0 ? void 0 : _this$store$currentOr14.is_deposit) || 0
               });
-              _context21.next = 27;
+              _context21.next = 30;
               return this.updateStateAmountToRemaining(false);
-            case 27:
-              return _context21.abrupt("return", newRes);
             case 30:
-              _context21.prev = 30;
-              _context21.t6 = _context21["catch"](1);
+              return _context21.abrupt("return", newRes);
+            case 33:
+              _context21.prev = 33;
+              _context21.t6 = _context21["catch"](2);
               this.logError('手动同步订单失败:', _context21.t6);
               errorMessage = _context21.t6 instanceof Error ? _context21.t6.message : '同步失败';
               return _context21.abrupt("return", {
@@ -1962,11 +1996,11 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
                 message: "\u8BA2\u5355\u540C\u6B65\u5931\u8D25: ".concat(errorMessage),
                 orderUuid: (_this$store$currentOr15 = this.store.currentOrder) === null || _this$store$currentOr15 === void 0 ? void 0 : _this$store$currentOr15.uuid
               });
-            case 35:
+            case 38:
             case "end":
               return _context21.stop();
           }
-        }, _callee21, this, [[1, 30]]);
+        }, _callee21, this, [[2, 33]]);
       }));
       function manualSyncOrderAsync() {
         return _manualSyncOrderAsync.apply(this, arguments);
@@ -2742,69 +2776,151 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
       return cleanupExpiredOrdersAsync;
     }()
     /**
-     * 计算已支付金额（从 Payment 模块获取最新数据）
+     * 清除计算缓存
      */
     )
   }, {
-    key: "calculatePaidAmountAsync",
+    key: "clearCalculationCache",
+    value: function clearCalculationCache() {
+      this.calculationCache = {};
+    }
+
+    /**
+     * 批量获取订单数据（用于性能优化）
+     * 一次性获取所有需要的数据，避免重复查询
+     */
+  }, {
+    key: "fetchOrderDataBatch",
     value: (function () {
-      var _calculatePaidAmountAsync = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee31() {
-        var payments, paidAmount, result;
+      var _fetchOrderDataBatch = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee31() {
+        var orderUuid, now, cacheValid, _yield$Promise$all, _yield$Promise$all2, paymentItems, currentOrder;
         return _regeneratorRuntime().wrap(function _callee31$(_context31) {
           while (1) switch (_context31.prev = _context31.next) {
             case 0:
               if (this.store.currentOrder) {
-                _context31.next = 3;
+                _context31.next = 2;
+                break;
+              }
+              return _context31.abrupt("return", {
+                paymentItems: [],
+                currentOrder: null
+              });
+            case 2:
+              orderUuid = this.store.currentOrder.uuid; // 检查缓存是否有效（5秒内的缓存认为有效）
+              now = Date.now();
+              cacheValid = this.calculationCache.orderUuid === orderUuid && this.calculationCache.timestamp && now - this.calculationCache.timestamp < 5000;
+              if (!(cacheValid && this.calculationCache.paymentItems && this.calculationCache.currentOrder)) {
+                _context31.next = 7;
+                break;
+              }
+              return _context31.abrupt("return", {
+                paymentItems: this.calculationCache.paymentItems,
+                currentOrder: this.calculationCache.currentOrder
+              });
+            case 7:
+              _context31.next = 9;
+              return Promise.all([this.payment.getPaymentItemsAsync(orderUuid, false), this.payment.getPaymentOrderByUuidAsync(orderUuid)]);
+            case 9:
+              _yield$Promise$all = _context31.sent;
+              _yield$Promise$all2 = _slicedToArray(_yield$Promise$all, 2);
+              paymentItems = _yield$Promise$all2[0];
+              currentOrder = _yield$Promise$all2[1];
+              // 更新缓存
+              this.calculationCache = {
+                paymentItems: paymentItems,
+                currentOrder: currentOrder,
+                orderUuid: orderUuid,
+                timestamp: now
+              };
+              return _context31.abrupt("return", {
+                paymentItems: paymentItems,
+                currentOrder: currentOrder
+              });
+            case 15:
+            case "end":
+              return _context31.stop();
+          }
+        }, _callee31, this);
+      }));
+      function fetchOrderDataBatch() {
+        return _fetchOrderDataBatch.apply(this, arguments);
+      }
+      return fetchOrderDataBatch;
+    }()
+    /**
+     * 从支付项数组计算已支付金额（纯计算，不查询数据库）
+     */
+    )
+  }, {
+    key: "calculatePaidAmountFromItems",
+    value: function calculatePaidAmountFromItems(payments) {
+      // 使用 Decimal.js 进行安全的金额计算
+      var paidAmount = payments.filter(function (payment) {
+        return payment.status !== 'voided';
+      }) // 只计算未撤销的支付项
+      .reduce(function (sum, payment) {
+        var amount = new Decimal(payment.amount || '0');
+        var roundingAmount = new Decimal(payment.rounding_amount || '0');
+
+        // 使用 Decimal.js 计算实际支付有效金额：
+        // 当 rounding_amount 为负数时，表示抹掉的金额，应该按绝对值加到实际支付中
+        // 例如：amount=15, rounding_amount=-0.2，实际相当于支付了15.2（抹掉了0.2元的零头）
+        var effectiveAmount = amount.add(roundingAmount.isNegative() ? roundingAmount.abs() : 0);
+        return sum.add(effectiveAmount);
+      }, new Decimal(0));
+      return paidAmount.toFixed(2);
+    }
+
+    /**
+     * 计算已支付金额（从 Payment 模块获取最新数据）
+     * 
+     * 注意：此方法保持独立性，可以单独调用。
+     * 在 updateStateAmountToRemaining 等批量操作中会使用缓存优化。
+     */
+  }, {
+    key: "calculatePaidAmountAsync",
+    value: (function () {
+      var _calculatePaidAmountAsync = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee32() {
+        var now, cacheValid, payments, result;
+        return _regeneratorRuntime().wrap(function _callee32$(_context32) {
+          while (1) switch (_context32.prev = _context32.next) {
+            case 0:
+              if (this.store.currentOrder) {
+                _context32.next = 3;
                 break;
               }
               this.logWarning('[Checkout] calculatePaidAmountAsync: 没有当前订单');
-              return _context31.abrupt("return", '0.00');
+              return _context32.abrupt("return", '0.00');
             case 3:
-              _context31.prev = 3;
-              _context31.next = 6;
+              _context32.prev = 3;
+              // 检查是否有缓存的已支付金额
+              now = Date.now();
+              cacheValid = this.calculationCache.orderUuid === this.store.currentOrder.uuid && this.calculationCache.timestamp && now - this.calculationCache.timestamp < 5000 && this.calculationCache.paidAmount;
+              if (!(cacheValid && this.calculationCache.paidAmount)) {
+                _context32.next = 8;
+                break;
+              }
+              return _context32.abrupt("return", this.calculationCache.paidAmount);
+            case 8:
+              _context32.next = 10;
               return this.payment.getPaymentItemsAsync(this.store.currentOrder.uuid, false // 不包括已撤销的支付项
               );
-            case 6:
-              payments = _context31.sent;
-              // 使用 Decimal.js 进行安全的金额计算
-              paidAmount = payments.filter(function (payment) {
-                return payment.status !== 'voided';
-              }) // 只计算未撤销的支付项
-              .reduce(function (sum, payment) {
-                var amount = new Decimal(payment.amount || '0');
-                var roundingAmount = new Decimal(payment.rounding_amount || '0');
-
-                // 使用 Decimal.js 计算实际支付有效金额：
-                // 当 rounding_amount 为负数时，表示抹掉的金额，应该按绝对值加到实际支付中
-                // 例如：amount=15, rounding_amount=-0.2，实际相当于支付了15.2（抹掉了0.2元的零头）
-                var effectiveAmount = amount.add(roundingAmount.abs());
-                console.log("[Checkout] \u8BA1\u7B97\u652F\u4ED8\u9879: ".concat(payment.code), {
-                  originalAmount: amount.toFixed(2),
-                  roundingAmount: roundingAmount.toFixed(2),
-                  effectiveAmount: effectiveAmount.toFixed(2),
-                  description: !roundingAmount.isZero() ? "\u62B9\u96F6\u91D1\u989D ".concat(roundingAmount.toFixed(2), " \u5143\uFF0C\u6709\u6548\u652F\u4ED8\u589E\u52A0 ").concat(roundingAmount.abs().toFixed(2), " \u5143") : '无抹零',
-                  // Decimal 精度验证
-                  preciseCalculationValues: {
-                    amount: amount.toString(),
-                    roundingAmount: roundingAmount.toString(),
-                    effectiveAmount: effectiveAmount.toString()
-                  }
-                });
-                return sum.add(effectiveAmount);
-              }, new Decimal(0));
-              result = paidAmount.toFixed(2);
+            case 10:
+              payments = _context32.sent;
+              result = this.calculatePaidAmountFromItems(payments); // 更新缓存
+              this.calculationCache.paidAmount = result;
               this.logInfo('calculatePaidAmountAsync: 计算结果 =', result);
-              return _context31.abrupt("return", result);
-            case 13:
-              _context31.prev = 13;
-              _context31.t0 = _context31["catch"](3);
-              this.logError('calculatePaidAmountAsync 失败:', _context31.t0);
-              return _context31.abrupt("return", '0.00');
+              return _context32.abrupt("return", result);
             case 17:
+              _context32.prev = 17;
+              _context32.t0 = _context32["catch"](3);
+              this.logError('calculatePaidAmountAsync 失败:', _context32.t0);
+              return _context32.abrupt("return", '0.00');
+            case 21:
             case "end":
-              return _context31.stop();
+              return _context32.stop();
           }
-        }, _callee31, this, [[3, 13]]);
+        }, _callee32, this, [[3, 17]]);
       }));
       function calculatePaidAmountAsync() {
         return _calculatePaidAmountAsync.apply(this, arguments);
@@ -2812,53 +2928,142 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
       return calculatePaidAmountAsync;
     }()
     /**
-     * 计算剩余未支付金额（从 Payment 模块获取最新数据）
+     * 从订单和支付项计算剩余金额（纯计算，不查询数据库）
      */
     )
+  }, {
+    key: "calculateRemainingAmountFromData",
+    value: function calculateRemainingAmountFromData(currentOrder, paidAmount) {
+      // 使用 Decimal.js 进行安全的金额计算
+      var totalAmount = new Decimal(currentOrder.total_amount || '0');
+
+      // 如果是定金订单，使用定金金额
+      if (currentOrder.is_deposit && currentOrder.deposit_amount && Number(currentOrder.deposit_amount) > 0) {
+        totalAmount = new Decimal(currentOrder.deposit_amount);
+      }
+      var paid = new Decimal(paidAmount);
+      var remainingAmount = totalAmount.sub(paid);
+
+      // 确保剩余金额不为负数
+      return Decimal.max(0, remainingAmount).toFixed(2);
+    }
+
+    /**
+     * 从订单和支付项计算剩余总金额（纯计算，排除定金）
+     */
+  }, {
+    key: "calculateRemainingTotalAmountFromData",
+    value: function calculateRemainingTotalAmountFromData(currentOrder, paidAmount) {
+      // 始终使用订单总金额，不进行定金相关的计算
+      var totalAmount = new Decimal(currentOrder.total_amount || '0');
+      var paid = new Decimal(paidAmount);
+      var remainingAmount = totalAmount.sub(paid);
+
+      // 确保剩余金额不为负数
+      return Decimal.max(0, remainingAmount).toFixed(2);
+    }
+
+    /**
+     * 计算剩余未支付金额（从 Payment 模块获取最新数据）
+     * 
+     * 注意：此方法保持独立性，可以单独调用。
+     * 在 updateStateAmountToRemaining 等批量操作中会使用缓存优化。
+     */
   }, {
     key: "calculateRemainingAmountAsync",
     value: (function () {
-      var _calculateRemainingAmountAsync = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee32() {
-        var totalAmount, currentOrder, paidAmountStr, paidAmount, remainingAmount, result;
-        return _regeneratorRuntime().wrap(function _callee32$(_context32) {
-          while (1) switch (_context32.prev = _context32.next) {
+      var _calculateRemainingAmountAsync = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee33() {
+        var _yield$this$fetchOrde, currentOrder, paidAmountStr, result;
+        return _regeneratorRuntime().wrap(function _callee33$(_context33) {
+          while (1) switch (_context33.prev = _context33.next) {
             case 0:
               if (this.store.currentOrder) {
-                _context32.next = 3;
+                _context33.next = 3;
                 break;
               }
               this.logWarning('calculateRemainingAmountAsync: 没有当前订单');
-              return _context32.abrupt("return", '0.00');
+              return _context33.abrupt("return", '0.00');
             case 3:
-              // 使用 Decimal.js 进行安全的金额计算
-              totalAmount = new Decimal(this.store.currentOrder.total_amount || '0');
-              _context32.next = 6;
-              return this.payment.getPaymentOrderByUuidAsync(this.store.currentOrder.uuid);
-            case 6:
-              currentOrder = _context32.sent;
-              if (currentOrder !== null && currentOrder !== void 0 && currentOrder.is_deposit && currentOrder !== null && currentOrder !== void 0 && currentOrder.deposit_amount && Number(currentOrder === null || currentOrder === void 0 ? void 0 : currentOrder.deposit_amount) > 0) {
-                totalAmount = new Decimal(currentOrder === null || currentOrder === void 0 ? void 0 : currentOrder.deposit_amount);
+              _context33.next = 5;
+              return this.fetchOrderDataBatch();
+            case 5:
+              _yield$this$fetchOrde = _context33.sent;
+              currentOrder = _yield$this$fetchOrde.currentOrder;
+              if (currentOrder) {
+                _context33.next = 9;
+                break;
               }
-              _context32.next = 10;
+              return _context33.abrupt("return", '0.00');
+            case 9:
+              _context33.next = 11;
               return this.calculatePaidAmountAsync();
-            case 10:
-              paidAmountStr = _context32.sent;
-              paidAmount = new Decimal(paidAmountStr);
-              remainingAmount = totalAmount.sub(paidAmount); // 确保剩余金额不为负数
-              result = Decimal.max(0, remainingAmount).toFixed(2);
+            case 11:
+              paidAmountStr = _context33.sent;
+              result = this.calculateRemainingAmountFromData(currentOrder, paidAmountStr);
               this.logInfo('calculateRemainingAmountAsync: 计算=', result);
-              return _context32.abrupt("return", result);
-            case 16:
+              return _context33.abrupt("return", result);
+            case 15:
             case "end":
-              return _context32.stop();
+              return _context33.stop();
           }
-        }, _callee32, this);
+        }, _callee33, this);
       }));
       function calculateRemainingAmountAsync() {
         return _calculateRemainingAmountAsync.apply(this, arguments);
       }
       return calculateRemainingAmountAsync;
     }()
+    /**
+     * 计算剩余未支付金额（排除定金计算，始终使用订单总金额）
+     * 
+     * 注意：此方法保持独立性，可以单独调用。
+     * 在 updateStateAmountToRemaining 等批量操作中会使用缓存优化。
+     */
+    )
+  }, {
+    key: "calculateRemainingTotalAmountAsync",
+    value: (function () {
+      var _calculateRemainingTotalAmountAsync = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee34() {
+        var _yield$this$fetchOrde2, currentOrder, paidAmountStr, result;
+        return _regeneratorRuntime().wrap(function _callee34$(_context34) {
+          while (1) switch (_context34.prev = _context34.next) {
+            case 0:
+              if (this.store.currentOrder) {
+                _context34.next = 3;
+                break;
+              }
+              this.logWarning('calculateRemainingTotalAmountAsync: 没有当前订单');
+              return _context34.abrupt("return", '0.00');
+            case 3:
+              _context34.next = 5;
+              return this.fetchOrderDataBatch();
+            case 5:
+              _yield$this$fetchOrde2 = _context34.sent;
+              currentOrder = _yield$this$fetchOrde2.currentOrder;
+              if (currentOrder) {
+                _context34.next = 9;
+                break;
+              }
+              return _context34.abrupt("return", '0.00');
+            case 9:
+              _context34.next = 11;
+              return this.calculatePaidAmountAsync();
+            case 11:
+              paidAmountStr = _context34.sent;
+              result = this.calculateRemainingTotalAmountFromData(currentOrder, paidAmountStr);
+              this.logInfo('calculateRemainingTotalAmountAsync: 计算=', result);
+              return _context34.abrupt("return", result);
+            case 15:
+            case "end":
+              return _context34.stop();
+          }
+        }, _callee34, this);
+      }));
+      function calculateRemainingTotalAmountAsync() {
+        return _calculateRemainingTotalAmountAsync.apply(this, arguments);
+      }
+      return calculateRemainingTotalAmountAsync;
+    }()
     /**
      * 更新 balanceDueAmount 为当前剩余未支付金额（系统内部计算）
      */
@@ -2866,54 +3071,59 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
   }, {
     key: "updateBalanceDueAmount",
     value: (function () {
-      var _updateBalanceDueAmount = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee33() {
-        var remainingAmount, currentBalanceDueAmount;
-        return _regeneratorRuntime().wrap(function _callee33$(_context33) {
-          while (1) switch (_context33.prev = _context33.next) {
+      var _updateBalanceDueAmount = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee35() {
+        var remainingAmount, remainingTotalAmount, currentBalanceDueAmount;
+        return _regeneratorRuntime().wrap(function _callee35$(_context35) {
+          while (1) switch (_context35.prev = _context35.next) {
             case 0:
-              _context33.prev = 0;
-              _context33.next = 3;
+              _context35.prev = 0;
+              _context35.next = 3;
               return this.calculateRemainingAmountAsync();
             case 3:
-              remainingAmount = _context33.sent;
+              remainingAmount = _context35.sent;
+              _context35.next = 6;
+              return this.calculateRemainingTotalAmountAsync();
+            case 6:
+              remainingTotalAmount = _context35.sent;
               currentBalanceDueAmount = this.store.balanceDueAmount; // 只有当剩余金额与当前 balanceDueAmount 不同时才更新
               if (!(remainingAmount !== currentBalanceDueAmount)) {
-                _context33.next = 12;
+                _context35.next = 15;
                 break;
               }
               this.store.balanceDueAmount = remainingAmount;
 
               // 发出 balanceDueAmount 变更事件
-              _context33.next = 9;
+              _context35.next = 12;
               return this.core.effects.emit(CheckoutHooks.OnBalanceDueAmountChanged, {
                 oldAmount: currentBalanceDueAmount,
                 newAmount: remainingAmount,
-                timestamp: Date.now()
+                timestamp: Date.now(),
+                totalAmount: remainingTotalAmount
               });
-            case 9:
+            case 12:
               this.logInfo('balanceDueAmount 已自动更新:', {
                 oldAmount: currentBalanceDueAmount,
                 newAmount: remainingAmount
               });
-              _context33.next = 13;
+              _context35.next = 16;
               break;
-            case 12:
+            case 15:
               this.logInfo('balanceDueAmount 无需更新，当前值已是最新:', {
                 balanceDueAmount: currentBalanceDueAmount,
                 remainingAmount: remainingAmount
               });
-            case 13:
-              _context33.next = 18;
+            case 16:
+              _context35.next = 21;
               break;
-            case 15:
-              _context33.prev = 15;
-              _context33.t0 = _context33["catch"](0);
-              this.logError('更新 balanceDueAmount 失败:', _context33.t0);
             case 18:
+              _context35.prev = 18;
+              _context35.t0 = _context35["catch"](0);
+              this.logError('更新 balanceDueAmount 失败:', _context35.t0);
+            case 21:
             case "end":
-              return _context33.stop();
+              return _context35.stop();
           }
-        }, _callee33, this, [[0, 15]]);
+        }, _callee35, this, [[0, 18]]);
       }));
       function updateBalanceDueAmount() {
         return _updateBalanceDueAmount.apply(this, arguments);
@@ -2922,150 +3132,323 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
     }()
     /**
      * 更新 stateAmount 为当前剩余未支付金额
+     * 
+     * 优化版本：批量获取数据，避免重复查询数据库
      */
     )
   }, {
     key: "updateStateAmountToRemaining",
     value: (function () {
-      var _updateStateAmountToRemaining = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee34() {
+      var _updateStateAmountToRemaining = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee36() {
+        var _this4 = this;
         var checkOrder,
-          _this$store$currentOr23,
-          _this$store$currentOr24,
-          _this$store$currentOr25,
+          _yield$this$fetchOrde3,
           paymentItems,
+          _currentOrder3,
+          paidAmount,
+          needUpdateDepositStatus,
           depositPaidAmount,
-          _this$store$currentOr26,
           remainingAmount,
+          remainingTotalAmount,
           currentStateAmount,
-          _args34 = arguments;
-        return _regeneratorRuntime().wrap(function _callee34$(_context34) {
-          while (1) switch (_context34.prev = _context34.next) {
+          currentBalanceDueAmount,
+          hasStateChanged,
+          _args36 = arguments;
+        return _regeneratorRuntime().wrap(function _callee36$(_context36) {
+          while (1) switch (_context36.prev = _context36.next) {
             case 0:
-              checkOrder = _args34.length > 0 && _args34[0] !== undefined ? _args34[0] : true;
-              _context34.prev = 1;
-              if (!(((_this$store$currentOr23 = this.store.currentOrder) === null || _this$store$currentOr23 === void 0 ? void 0 : _this$store$currentOr23.is_deposit) === 1)) {
-                _context34.next = 11;
+              checkOrder = _args36.length > 0 && _args36[0] !== undefined ? _args36[0] : true;
+              _context36.prev = 1;
+              if (this.store.currentOrder) {
+                _context36.next = 4;
                 break;
               }
-              _context34.next = 5;
-              return this.payment.getPaymentItemsAsync((_this$store$currentOr24 = this.store.currentOrder) === null || _this$store$currentOr24 === void 0 ? void 0 : _this$store$currentOr24.uuid);
-            case 5:
-              paymentItems = _context34.sent;
-              depositPaidAmount = paymentItems.filter(function (item) {
-                return item.order_payment_type === 'deposit' && item.status !== 'voided';
-              }).reduce(function (sum, item) {
-                // 如果是 wallet，并且还没同步到后端，则不计入这一部分金额
-                if (item.voucher_id && !item.isSynced) {
-                  return sum;
+              return _context36.abrupt("return");
+            case 4:
+              console.time('updateStateAmountToRemaining');
+              // 🚀 性能优化：一次性批量获取所有需要的数据
+              _context36.next = 7;
+              return this.fetchOrderDataBatch();
+            case 7:
+              _yield$this$fetchOrde3 = _context36.sent;
+              paymentItems = _yield$this$fetchOrde3.paymentItems;
+              _currentOrder3 = _yield$this$fetchOrde3.currentOrder;
+              console.timeEnd('updateStateAmountToRemaining');
+              if (_currentOrder3) {
+                _context36.next = 14;
+                break;
+              }
+              this.logWarning('updateStateAmountToRemaining: 未找到当前订单');
+              return _context36.abrupt("return");
+            case 14:
+              // 🚀 性能优化：一次性计算所有金额（纯计算，不查询数据库）
+              paidAmount = this.calculatePaidAmountFromItems(paymentItems); // 缓存已支付金额，供其他方法使用
+              this.calculationCache.paidAmount = paidAmount;
+
+              // 检查定金支付状态，可能需要切换支付模式
+              needUpdateDepositStatus = false;
+              if (_currentOrder3.is_deposit === 1) {
+                depositPaidAmount = paymentItems.filter(function (item) {
+                  return item.order_payment_type === 'deposit' && item.status !== 'voided';
+                }).reduce(function (sum, item) {
+                  // 如果是 wallet，并且还没同步到后端，则不计入这一部分金额
+                  if (item.voucher_id && !item.isSynced) {
+                    return sum;
+                  }
+                  var amount = new Decimal(item.amount || '0');
+                  var roundingAmount = new Decimal(item.rounding_amount || '0');
+                  return sum.add(amount.add(roundingAmount.isNegative() ? roundingAmount.abs() : 0));
+                }, new Decimal(0));
+                if (depositPaidAmount.gte(_currentOrder3.deposit_amount || '0')) {
+                  needUpdateDepositStatus = true;
+                  // 更新缓存中的订单状态
+                  _currentOrder3.is_deposit = 0;
                 }
-                var amount = new Decimal(item.amount || '0');
-                var roundingAmount = new Decimal(item.rounding_amount || '0');
-                return sum.add(amount.add(roundingAmount.abs()));
-              }, new Decimal(0));
-              if (!depositPaidAmount.gte((_this$store$currentOr25 = this.store.currentOrder) === null || _this$store$currentOr25 === void 0 ? void 0 : _this$store$currentOr25.deposit_amount)) {
-                _context34.next = 11;
+              }
+
+              // 计算剩余金额（使用缓存的数据）
+              remainingAmount = this.calculateRemainingAmountFromData(_currentOrder3, paidAmount);
+              remainingTotalAmount = this.calculateRemainingTotalAmountFromData(_currentOrder3, paidAmount);
+              currentStateAmount = this.store.stateAmount;
+              currentBalanceDueAmount = this.store.balanceDueAmount; // 批量更新状态，减少操作次数
+              hasStateChanged = false; // 如果需要更新定金状态
+              if (!needUpdateDepositStatus) {
+                _context36.next = 28;
                 break;
               }
               this.store.currentOrder = _objectSpread(_objectSpread({}, this.store.currentOrder), {}, {
                 is_deposit: 0
               });
-              _context34.next = 11;
-              return this.payment.updateOrderAsync((_this$store$currentOr26 = this.store.currentOrder) === null || _this$store$currentOr26 === void 0 ? void 0 : _this$store$currentOr26.uuid, {
+              _context36.next = 27;
+              return this.payment.updateOrderAsync(this.store.currentOrder.uuid, {
                 is_deposit: 0
               });
-            case 11:
-              _context34.next = 13;
-              return this.calculateRemainingAmountAsync();
-            case 13:
-              remainingAmount = _context34.sent;
-              currentStateAmount = this.store.stateAmount; // 只有当剩余金额与当前 stateAmount 不同时才更新
+            case 27:
+              hasStateChanged = true;
+            case 28:
+              console.time('updateStateAmountToRemaining: remainingAmount');
+              // 更新 stateAmount
               if (remainingAmount !== currentStateAmount) {
                 this.store.stateAmount = remainingAmount;
-
-                // 发出 stateAmount 变更事件
-                this.core.effects.emit(CheckoutHooks.OnStateAmountChanged, {
-                  oldAmount: currentStateAmount,
-                  newAmount: remainingAmount,
-                  timestamp: Date.now()
-                });
+                hasStateChanged = true;
+                setTimeout(function () {
+                  // 发出 stateAmount 变更事件
+                  _this4.core.effects.emit("".concat(_this4.name, ":onStateAmountChanged"), {
+                    oldAmount: currentStateAmount,
+                    newAmount: remainingAmount,
+                    timestamp: Date.now(),
+                    totalAmount: remainingTotalAmount
+                  });
+                }, 0);
                 this.logInfo('stateAmount 已自动更新为剩余金额:', {
                   oldAmount: currentStateAmount,
                   newAmount: remainingAmount
                 });
-              } else {
-                this.logInfo('stateAmount 无需更新，当前值已是最新:', {
+              }
+              console.timeEnd('updateStateAmountToRemaining: remainingAmount');
+              console.time('updateStateAmountToRemaining: updateStateAmountToRemaining');
+              // 更新 balanceDueAmount
+              if (remainingAmount !== currentBalanceDueAmount) {
+                this.store.balanceDueAmount = remainingAmount;
+                hasStateChanged = true;
+
+                // 发出 balanceDueAmount 变更事件
+                setTimeout(function () {
+                  _this4.core.effects.emit("".concat(_this4.name, ":onBalanceDueAmountChanged"), {
+                    oldAmount: currentBalanceDueAmount,
+                    newAmount: remainingAmount,
+                    timestamp: Date.now(),
+                    totalAmount: remainingTotalAmount
+                  });
+                }, 0);
+                this.logInfo('balanceDueAmount 已自动更新:', {
+                  oldAmount: currentBalanceDueAmount,
+                  newAmount: remainingAmount
+                });
+              }
+              console.timeEnd('updateStateAmountToRemaining: updateStateAmountToRemaining');
+              if (!hasStateChanged) {
+                this.logInfo('状态无需更新，当前值已是最新:', {
                   stateAmount: currentStateAmount,
                   remainingAmount: remainingAmount
                 });
               }
-              // 同步更新系统内部的 balanceDueAmount
-              _context34.next = 18;
-              return this.updateBalanceDueAmount();
-            case 18:
+
+              // 检查订单支付完成（复用已获取的数据）
               if (!checkOrder) {
-                _context34.next = 23;
+                _context36.next = 40;
                 break;
               }
-              _context34.next = 21;
-              return this.checkOrderPaymentCompletion();
-            case 21:
-              _context34.next = 24;
+              _context36.next = 38;
+              return this.checkOrderPaymentCompletionOptimized(paymentItems, remainingAmount);
+            case 38:
+              _context36.next = 41;
               break;
-            case 23:
+            case 40:
               this.logInfo('外部传入无需 checkOrder，不执行订单支付完成检测和同步');
-            case 24:
-              _context34.next = 29;
+            case 41:
+              _context36.next = 46;
               break;
-            case 26:
-              _context34.prev = 26;
-              _context34.t0 = _context34["catch"](1);
-              this.logError('更新 stateAmount 为剩余金额失败:', _context34.t0);
-            case 29:
+            case 43:
+              _context36.prev = 43;
+              _context36.t0 = _context36["catch"](1);
+              this.logError('更新 stateAmount 为剩余金额失败:', _context36.t0);
+            case 46:
             case "end":
-              return _context34.stop();
+              return _context36.stop();
           }
-        }, _callee34, this, [[1, 26]]);
+        }, _callee36, this, [[1, 43]]);
       }));
       function updateStateAmountToRemaining() {
         return _updateStateAmountToRemaining.apply(this, arguments);
       }
       return updateStateAmountToRemaining;
     }()
+    /**
+     * 检查订单支付是否完成（优化版，复用已获取的数据）
+     * 
+     * @param paymentItems 已获取的支付项数据
+     * @param remainingAmount 已计算的剩余金额
+     */
+    )
+  }, {
+    key: "checkOrderPaymentCompletionOptimized",
+    value: (function () {
+      var _checkOrderPaymentCompletionOptimized = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee37(paymentItems, remainingAmount) {
+        var remainingValue, totalAmount, paidAmount, hasPaymentItems, allPaymentsHaveVoucherId, shouldAutoSync;
+        return _regeneratorRuntime().wrap(function _callee37$(_context37) {
+          while (1) switch (_context37.prev = _context37.next) {
+            case 0:
+              _context37.prev = 0;
+              if (this.store.currentOrder) {
+                _context37.next = 3;
+                break;
+              }
+              return _context37.abrupt("return");
+            case 3:
+              remainingValue = new Decimal(remainingAmount); // 当剩余金额小于等于0时，认为订单已完成支付
+              if (!remainingValue.lte(0)) {
+                _context37.next = 21;
+                break;
+              }
+              totalAmount = this.store.currentOrder.total_amount;
+              paidAmount = this.calculationCache.paidAmount || '0.00';
+              this.logInfo('检测到订单支付完成:', {
+                orderUuid: this.store.currentOrder.uuid,
+                orderId: this.store.currentOrder.order_id,
+                totalAmount: totalAmount,
+                paidAmount: paidAmount,
+                remainingAmount: remainingAmount,
+                isOrderSynced: this.store.isOrderSynced
+              });
+
+              // 检查自动同步条件（复用已获取的支付项数据）
+              hasPaymentItems = paymentItems.length > 0;
+              allPaymentsHaveVoucherId = hasPaymentItems && paymentItems.every(function (item) {
+                return item.status !== 'voided' && item.voucher_id;
+              });
+              shouldAutoSync = hasPaymentItems && !allPaymentsHaveVoucherId;
+              this.logInfo('自动同步订单条件检查:', {
+                paymentCount: paymentItems.length,
+                hasPaymentItems: hasPaymentItems,
+                allHaveVoucherId: allPaymentsHaveVoucherId,
+                isOrderSynced: this.store.isOrderSynced,
+                shouldAutoSync: shouldAutoSync,
+                reason: shouldAutoSync ? '支付完成，需要同步最终支付状态' : '跳过同步',
+                paymentItems: paymentItems.map(function (p) {
+                  return {
+                    uuid: p.uuid,
+                    code: p.code,
+                    amount: p.amount,
+                    rounding_amount: p.rounding_amount,
+                    effective_amount: (parseFloat(p.amount || '0') + Math.abs(parseFloat(Number(p.rounding_amount) > 0 ? '0' : p.rounding_amount || '0'))).toFixed(2),
+                    voucher_id: p.voucher_id,
+                    status: p.status
+                  };
+                })
+              });
+              if (!shouldAutoSync) {
+                _context37.next = 18;
+                break;
+              }
+              this.logInfo('满足自动同步条件，开始同步订单到后端...');
+              _context37.next = 16;
+              return this.syncOrderToBackendWithReturn(false);
+            case 16:
+              _context37.next = 19;
+              break;
+            case 18:
+              if (!hasPaymentItems) {
+                this.logInfo('没有支付项，跳过订单同步');
+              } else if (allPaymentsHaveVoucherId) {
+                this.logInfo('所有支付项均为代金券类型，跳过订单同步');
+              }
+            case 19:
+              _context37.next = 21;
+              return this.core.effects.emit("".concat(this.name, ":onOrderPaymentCompleted"), {
+                orderUuid: this.store.currentOrder.uuid,
+                orderId: this.store.currentOrder.order_id,
+                totalAmount: totalAmount,
+                paidAmount: paidAmount,
+                remainingAmount: remainingAmount,
+                timestamp: Date.now()
+              });
+            case 21:
+              _context37.next = 26;
+              break;
+            case 23:
+              _context37.prev = 23;
+              _context37.t0 = _context37["catch"](0);
+              this.logError('检查订单支付完成状态失败:', _context37.t0);
+            case 26:
+            case "end":
+              return _context37.stop();
+          }
+        }, _callee37, this, [[0, 23]]);
+      }));
+      function checkOrderPaymentCompletionOptimized(_x27, _x28) {
+        return _checkOrderPaymentCompletionOptimized.apply(this, arguments);
+      }
+      return checkOrderPaymentCompletionOptimized;
+    }()
     /**
      * 检查订单支付是否完成
      *
      * 当剩余待付款金额 <= 0 时，触发订单支付完成事件
+     * 
+     * 注意：此方法保持独立性，可以单独调用。
+     * 在 updateStateAmountToRemaining 中会使用优化版本。
      */
     )
   }, {
     key: "checkOrderPaymentCompletion",
     value: (function () {
-      var _checkOrderPaymentCompletion = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee35() {
+      var _checkOrderPaymentCompletion = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee38() {
         var remainingAmount, remainingValue, totalAmount, paidAmount, currentPayments, hasPaymentItems, allPaymentsHaveVoucherId, shouldAutoSync;
-        return _regeneratorRuntime().wrap(function _callee35$(_context35) {
-          while (1) switch (_context35.prev = _context35.next) {
+        return _regeneratorRuntime().wrap(function _callee38$(_context38) {
+          while (1) switch (_context38.prev = _context38.next) {
             case 0:
-              _context35.prev = 0;
+              _context38.prev = 0;
               if (this.store.currentOrder) {
-                _context35.next = 3;
+                _context38.next = 3;
                 break;
               }
-              return _context35.abrupt("return");
+              return _context38.abrupt("return");
             case 3:
-              _context35.next = 5;
+              _context38.next = 5;
               return this.calculateRemainingAmountAsync();
             case 5:
-              remainingAmount = _context35.sent;
+              remainingAmount = _context38.sent;
               remainingValue = new Decimal(remainingAmount); // 当剩余金额小于等于0时，认为订单已完成支付
               if (!remainingValue.lte(0)) {
-                _context35.next = 29;
+                _context38.next = 29;
                 break;
               }
               totalAmount = this.store.currentOrder.total_amount;
-              _context35.next = 11;
+              _context38.next = 11;
               return this.calculatePaidAmountAsync();
             case 11:
-              paidAmount = _context35.sent;
+              paidAmount = _context38.sent;
               this.logInfo('检测到订单支付完成:', {
                 orderUuid: this.store.currentOrder.uuid,
                 orderId: this.store.currentOrder.order_id,
@@ -3076,11 +3459,11 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
               });
 
               // 从 Payment 模块获取最新支付项，检查自动同步条件
-              _context35.next = 15;
+              _context38.next = 15;
               return this.payment.getPaymentItemsAsync(this.store.currentOrder.uuid, false // 不包括已撤销的支付项
               );
             case 15:
-              currentPayments = _context35.sent;
+              currentPayments = _context38.sent;
               // 检查自动同步条件：
               // 1. 待付金额为 0 ✓ (已在上面检查)
               // 2. 需要有支付项
@@ -3107,21 +3490,21 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
                     code: p.code,
                     amount: p.amount,
                     rounding_amount: p.rounding_amount,
-                    effective_amount: (parseFloat(p.amount || '0') + Math.abs(parseFloat(p.rounding_amount || '0'))).toFixed(2),
+                    effective_amount: (parseFloat(p.amount || '0') + Math.abs(parseFloat(Number(p.rounding_amount) > 0 ? '0' : p.rounding_amount || '0'))).toFixed(2),
                     voucher_id: p.voucher_id,
                     status: p.status
                   };
                 })
               });
               if (!shouldAutoSync) {
-                _context35.next = 26;
+                _context38.next = 26;
                 break;
               }
               this.logInfo('满足自动同步条件，开始同步订单到后端...');
-              _context35.next = 24;
+              _context38.next = 24;
               return this.syncOrderToBackendWithReturn(false);
             case 24:
-              _context35.next = 27;
+              _context38.next = 27;
               break;
             case 26:
               if (!hasPaymentItems) {
@@ -3130,7 +3513,7 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
                 this.logInfo('所有支付项均为代金券类型，跳过订单同步');
               }
             case 27:
-              _context35.next = 29;
+              _context38.next = 29;
               return this.core.effects.emit(CheckoutHooks.OnOrderPaymentCompleted, {
                 orderUuid: this.store.currentOrder.uuid,
                 orderId: this.store.currentOrder.order_id,
@@ -3140,17 +3523,17 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
                 timestamp: Date.now()
               });
             case 29:
-              _context35.next = 34;
+              _context38.next = 34;
               break;
             case 31:
-              _context35.prev = 31;
-              _context35.t0 = _context35["catch"](0);
-              this.logError('检查订单支付完成状态失败:', _context35.t0);
+              _context38.prev = 31;
+              _context38.t0 = _context38["catch"](0);
+              this.logError('检查订单支付完成状态失败:', _context38.t0);
             case 34:
             case "end":
-              return _context35.stop();
+              return _context38.stop();
           }
-        }, _callee35, this, [[0, 31]]);
+        }, _callee38, this, [[0, 31]]);
       }));
       function checkOrderPaymentCompletion() {
         return _checkOrderPaymentCompletion.apply(this, arguments);
@@ -3168,12 +3551,12 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
   }, {
     key: "syncOrderToBackendWithReturn",
     value: (function () {
-      var _syncOrderToBackendWithReturn = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee36() {
-        var _this4 = this,
-          _this$store$currentOr27,
-          _this$store$currentOr28,
+      var _syncOrderToBackendWithReturn = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee39() {
+        var _this5 = this,
+          _this$store$currentOr23,
+          _this$store$currentOr24,
           _this$store$currentCu2,
-          _this$store$currentOr29,
+          _this$store$currentOr25,
           _this$store$localOrde,
           _this$store$localOrde2,
           _checkoutResponse3,
@@ -3208,14 +3591,14 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
           _iterator3,
           _step3,
           paymentUuid,
-          _args36 = arguments;
-        return _regeneratorRuntime().wrap(function _callee36$(_context36) {
-          while (1) switch (_context36.prev = _context36.next) {
+          _args39 = arguments;
+        return _regeneratorRuntime().wrap(function _callee39$(_context39) {
+          while (1) switch (_context39.prev = _context39.next) {
             case 0:
-              isManual = _args36.length > 0 && _args36[0] !== undefined ? _args36[0] : false;
-              customPaymentItems = _args36.length > 1 ? _args36[1] : undefined;
+              isManual = _args39.length > 0 && _args39[0] !== undefined ? _args39[0] : false;
+              customPaymentItems = _args39.length > 1 ? _args39[1] : undefined;
               if (!(!this.store.localOrderData || !this.store.currentOrder)) {
-                _context36.next = 4;
+                _context39.next = 4;
                 break;
               }
               throw new Error('缺少必要的订单数据，无法同步到后端');
@@ -3234,28 +3617,28 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
               });
 
               // 获取当前订单的支付项
-              _context36.t0 = customPaymentItems;
-              if (_context36.t0) {
-                _context36.next = 13;
+              _context39.t0 = customPaymentItems;
+              if (_context39.t0) {
+                _context39.next = 13;
                 break;
               }
-              _context36.next = 12;
+              _context39.next = 12;
               return this.payment.getPaymentItemsAsync(this.store.currentOrder.uuid);
             case 12:
-              _context36.t0 = _context36.sent;
+              _context39.t0 = _context39.sent;
             case 13:
-              paymentItems = _context36.t0;
+              paymentItems = _context39.t0;
               // 处理支付项数据，确保包含完整的 metadata
               processedPaymentItems = paymentItems.map(function (item) {
                 var _item$metadata, _item$metadata2;
                 return _objectSpread(_objectSpread({}, item), {}, {
                   metadata: _objectSpread(_objectSpread({}, item.metadata), {}, {
-                    rounding_rule: ((_item$metadata = item.metadata) === null || _item$metadata === void 0 ? void 0 : _item$metadata.rounding_rule) || _this4.otherParams.order_rounding_setting,
-                    shop_wallet_pass_id: ((_item$metadata2 = item.metadata) === null || _item$metadata2 === void 0 ? void 0 : _item$metadata2.shop_wallet_pass_id) || _this4.otherParams.shop_wallet_pass_id
+                    rounding_rule: ((_item$metadata = item.metadata) === null || _item$metadata === void 0 ? void 0 : _item$metadata.rounding_rule) || _this5.otherParams.order_rounding_setting,
+                    shop_wallet_pass_id: ((_item$metadata2 = item.metadata) === null || _item$metadata2 === void 0 ? void 0 : _item$metadata2.shop_wallet_pass_id) || _this5.otherParams.shop_wallet_pass_id
                   })
                 });
               }); // 确定最终的定金金额：优先使用手动设置的值，否则从支付项中计算
-              manualDepositAmount = ((_this$store$currentOr27 = this.store.currentOrder) === null || _this$store$currentOr27 === void 0 ? void 0 : _this$store$currentOr27.deposit_amount) || '0.00'; // 优先级逻辑：手动设置的定金金额 > 从支付项计算的金额
+              manualDepositAmount = ((_this$store$currentOr23 = this.store.currentOrder) === null || _this$store$currentOr23 === void 0 ? void 0 : _this$store$currentOr23.deposit_amount) || '0.00'; // 优先级逻辑：手动设置的定金金额 > 从支付项计算的金额
               manualDepositValue = new Decimal(manualDepositAmount);
               if (manualDepositValue.gt(0)) {
                 // 如果手动设置了定金金额且大于0，使用手动设置的值
@@ -3315,7 +3698,7 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
                 }),
                 manualDepositAmount: manualDepositAmount,
                 finalDepositAmount: finalDepositAmount,
-                isDeposit: ((_this$store$currentOr28 = this.store.currentOrder) === null || _this$store$currentOr28 === void 0 ? void 0 : _this$store$currentOr28.is_deposit) || 0
+                isDeposit: ((_this$store$currentOr24 = this.store.currentOrder) === null || _this$store$currentOr24 === void 0 ? void 0 : _this$store$currentOr24.is_deposit) || 0
               });
 
               // 构造订单参数，直接使用 localOrderData 中已处理好的数据
@@ -3337,7 +3720,7 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
                 currency_code: this.otherParams.currency_code,
                 currency_symbol: this.otherParams.currency_symbol,
                 currency_format: this.otherParams.currency_format,
-                is_deposit: ((_this$store$currentOr29 = this.store.currentOrder) !== null && _this$store$currentOr29 !== void 0 && _this$store$currentOr29.is_deposit || Number(finalDepositAmount) > 0 ? 1 : 0) || 0,
+                is_deposit: ((_this$store$currentOr25 = this.store.currentOrder) !== null && _this$store$currentOr25 !== void 0 && _this$store$currentOr25.is_deposit || Number(finalDepositAmount) > 0 ? 1 : 0) || 0,
                 deposit_amount: finalDepositAmount,
                 // 使用最终确定的定金金额（手动设置优先）
                 product_tax_fee: this.store.localOrderData.tax_fee,
@@ -3368,7 +3751,7 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
 
               // 发送下单接口请求开始事件
               startTime = Date.now();
-              _context36.next = 27;
+              _context39.next = 27;
               return this.core.effects.emit(CheckoutHooks.OnOrderSubmitStart, {
                 orderUuid: this.store.currentOrder.uuid,
                 operation: isUpdateOperation ? 'update' : 'create',
@@ -3378,7 +3761,7 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
               });
             case 27:
               submitSuccess = false;
-              _context36.prev = 28;
+              _context39.prev = 28;
               // 记录接口调用参数
               this.logInfo('Calling backend checkout API', _objectSpread({
                 url: '/order/checkout',
@@ -3386,23 +3769,23 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
               }, orderParams));
 
               // 调用 Order 模块的专用 createOrderByCheckout 方法
-              _context36.next = 32;
+              _context39.next = 32;
               return this.order.createOrderByCheckout(orderParams);
             case 32:
-              checkoutResponse = _context36.sent;
+              checkoutResponse = _context39.sent;
               submitSuccess = true;
               this.logInfo('下单接口调用成功', checkoutResponse);
-              _context36.next = 45;
+              _context39.next = 45;
               break;
             case 37:
-              _context36.prev = 37;
-              _context36.t1 = _context36["catch"](28);
+              _context39.prev = 37;
+              _context39.t1 = _context39["catch"](28);
               submitSuccess = false;
-              submitError = _context36.t1 instanceof Error ? _context36.t1.message : String(_context36.t1);
+              submitError = _context39.t1 instanceof Error ? _context39.t1.message : String(_context39.t1);
               this.logError('下单接口调用失败:', submitError);
 
               // 发送订单同步失败事件（网络错误或请求失败）
-              _context36.next = 44;
+              _context39.next = 44;
               return this.core.effects.emit(CheckoutHooks.OnOrderSyncFailed, {
                 orderUuid: this.store.currentOrder.uuid,
                 operation: isUpdateOperation ? 'update' : 'create',
@@ -3413,10 +3796,10 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
                 timestamp: Date.now()
               });
             case 44:
-              throw _context36.t1;
+              throw _context39.t1;
             case 45:
-              _context36.prev = 45;
-              _context36.next = 48;
+              _context39.prev = 45;
+              _context39.next = 48;
               return this.core.effects.emit(CheckoutHooks.OnOrderSubmitEnd, {
                 success: submitSuccess,
                 orderUuid: this.store.currentOrder.uuid,
@@ -3428,17 +3811,17 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
                 timestamp: Date.now()
               });
             case 48:
-              return _context36.finish(45);
+              return _context39.finish(45);
             case 49:
               // 检查响应状态是否为成功状态
               responseStatus = (_checkoutResponse3 = checkoutResponse) === null || _checkoutResponse3 === void 0 ? void 0 : _checkoutResponse3.status;
               isSuccessResponse = responseStatus === true || responseStatus === 200 || responseStatus === 'success' || responseStatus === 1 && ((_checkoutResponse4 = checkoutResponse) === null || _checkoutResponse4 === void 0 ? void 0 : _checkoutResponse4.code) === 200;
               if (isSuccessResponse) {
-                _context36.next = 56;
+                _context39.next = 56;
                 break;
               }
               errorMessage = ((_checkoutResponse5 = checkoutResponse) === null || _checkoutResponse5 === void 0 ? void 0 : _checkoutResponse5.message) || '订单同步失败，后端返回非成功状态'; // 发送订单同步失败事件
-              _context36.next = 55;
+              _context39.next = 55;
               return this.core.effects.emit(CheckoutHooks.OnOrderSyncFailed, {
                 orderUuid: this.store.currentOrder.uuid,
                 operation: isUpdateOperation ? 'update' : 'create',
@@ -3453,12 +3836,12 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
               throw new Error(errorMessage);
             case 56:
               if (!isUpdateOperation) {
-                _context36.next = 60;
+                _context39.next = 60;
                 break;
               }
               // 更新操作：使用现有的订单ID
               realOrderId = currentOrderId;
-              _context36.next = 79;
+              _context39.next = 79;
               break;
             case 60:
               // 创建操作：从响应中提取新的订单ID
@@ -3482,11 +3865,11 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
                 oldOrderId: this.store.currentOrder.order_id,
                 newOrderId: realOrderId
               });
-              _context36.prev = 66;
-              _context36.next = 69;
+              _context39.prev = 66;
+              _context39.next = 69;
               return this.payment.replaceOrderIdByUuidAsync(this.store.currentOrder.uuid, realOrderId);
             case 69:
-              updatedOrder = _context36.sent;
+              updatedOrder = _context39.sent;
               this.logInfo('Payment模块替换订单ID结果:', {
                 wasSuccessful: !!updatedOrder,
                 returnedOrderId: updatedOrder === null || updatedOrder === void 0 ? void 0 : updatedOrder.order_id,
@@ -3512,66 +3895,69 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
                   目标ID: realOrderId
                 });
               }
-              _context36.next = 79;
+              _context39.next = 79;
               break;
             case 74:
-              _context36.prev = 74;
-              _context36.t2 = _context36["catch"](66);
-              this.logError('调用Payment模块替换订单ID时发生错误:', _context36.t2);
+              _context39.prev = 74;
+              _context39.t2 = _context39["catch"](66);
+              this.logError('调用Payment模块替换订单ID时发生错误:', _context39.t2);
 
               // 发生错误时也进行手动替换
               this.store.currentOrder.order_id = realOrderId;
               this.logInfo('错误恢复：手动设置订单ID:', realOrderId);
             case 79:
-              _context36.prev = 79;
+              _context39.prev = 79;
               syncedPaymentUuids = processedPaymentItems.filter(function (item) {
                 return item.status !== 'voided';
               }).map(function (item) {
                 return item.uuid;
               }).filter(Boolean);
               _iterator3 = _createForOfIteratorHelper(syncedPaymentUuids);
-              _context36.prev = 82;
+              _context39.prev = 82;
               _iterator3.s();
             case 84:
               if ((_step3 = _iterator3.n()).done) {
-                _context36.next = 90;
+                _context39.next = 90;
                 break;
               }
               paymentUuid = _step3.value;
-              _context36.next = 88;
+              _context39.next = 88;
               return this.payment.updatePaymentAsync(this.store.currentOrder.uuid, paymentUuid, {
                 isSynced: true,
                 syncError: undefined
               });
             case 88:
-              _context36.next = 84;
+              _context39.next = 84;
               break;
             case 90:
-              _context36.next = 95;
+              _context39.next = 95;
               break;
             case 92:
-              _context36.prev = 92;
-              _context36.t3 = _context36["catch"](82);
-              _iterator3.e(_context36.t3);
+              _context39.prev = 92;
+              _context39.t3 = _context39["catch"](82);
+              _iterator3.e(_context39.t3);
             case 95:
-              _context36.prev = 95;
+              _context39.prev = 95;
               _iterator3.f();
-              return _context36.finish(95);
+              return _context39.finish(95);
             case 98:
-              _context36.next = 103;
+              _context39.next = 103;
               break;
             case 100:
-              _context36.prev = 100;
-              _context36.t4 = _context36["catch"](79);
+              _context39.prev = 100;
+              _context39.t4 = _context39["catch"](79);
               this.logWarning('标记支付项已同步失败（不阻塞主流程）', {
-                error: _context36.t4
+                error: _context39.t4
               });
             case 103:
               // 标记订单已同步
               this.store.isOrderSynced = true;
 
+              // 🚀 清除计算缓存，订单已同步，数据可能已变更
+              this.clearCalculationCache();
+
               // 触发订单同步完成事件
-              _context36.next = 106;
+              _context39.next = 107;
               return this.core.effects.emit(CheckoutHooks.OnOrderSynced, {
                 orderUuid: this.store.currentOrder.uuid,
                 realOrderId: realOrderId,
@@ -3580,18 +3966,18 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
                 isManual: isManual,
                 response: checkoutResponse
               });
-            case 106:
-              return _context36.abrupt("return", {
+            case 107:
+              return _context39.abrupt("return", {
                 success: true,
                 orderId: realOrderId,
                 orderUuid: this.store.currentOrder.uuid,
                 response: checkoutResponse
               });
-            case 107:
+            case 108:
             case "end":
-              return _context36.stop();
+              return _context39.stop();
           }
-        }, _callee36, this, [[28, 37, 45, 49], [66, 74], [79, 100], [82, 92, 95, 98]]);
+        }, _callee39, this, [[28, 37, 45, 49], [66, 74], [79, 100], [82, 92, 95, 98]]);
       }));
       function syncOrderToBackendWithReturn() {
         return _syncOrderToBackendWithReturn.apply(this, arguments);
@@ -3601,15 +3987,15 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
   }, {
     key: "setOtherParams",
     value: function () {
-      var _setOtherParams = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee37(params) {
+      var _setOtherParams = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee40(params) {
         var _ref5,
           _ref5$cover,
           cover,
-          _args37 = arguments;
-        return _regeneratorRuntime().wrap(function _callee37$(_context37) {
-          while (1) switch (_context37.prev = _context37.next) {
+          _args40 = arguments;
+        return _regeneratorRuntime().wrap(function _callee40$(_context40) {
+          while (1) switch (_context40.prev = _context40.next) {
             case 0:
-              _ref5 = _args37.length > 1 && _args37[1] !== undefined ? _args37[1] : {}, _ref5$cover = _ref5.cover, cover = _ref5$cover === void 0 ? false : _ref5$cover;
+              _ref5 = _args40.length > 1 && _args40[1] !== undefined ? _args40[1] : {}, _ref5$cover = _ref5.cover, cover = _ref5$cover === void 0 ? false : _ref5$cover;
               if (cover) {
                 this.otherParams = params;
               } else {
@@ -3617,11 +4003,11 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
               }
             case 2:
             case "end":
-              return _context37.stop();
+              return _context40.stop();
           }
-        }, _callee37, this);
+        }, _callee40, this);
       }));
-      function setOtherParams(_x27) {
+      function setOtherParams(_x29) {
         return _setOtherParams.apply(this, arguments);
       }
       return setOtherParams;
@@ -3638,22 +4024,22 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
   }, {
     key: "editOrderNoteByOrderIdAsync",
     value: (function () {
-      var _editOrderNoteByOrderIdAsync = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee38(orderId, note) {
+      var _editOrderNoteByOrderIdAsync = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee41(orderId, note) {
         var response, previousNote, errorMessage, _errorMessage;
-        return _regeneratorRuntime().wrap(function _callee38$(_context38) {
-          while (1) switch (_context38.prev = _context38.next) {
+        return _regeneratorRuntime().wrap(function _callee41$(_context41) {
+          while (1) switch (_context41.prev = _context41.next) {
             case 0:
               this.logInfo('editOrderNoteByOrderIdAsync called', {
                 orderId: orderId,
                 note: note,
                 noteLength: note.length
               });
-              _context38.prev = 1;
+              _context41.prev = 1;
               if (orderId) {
-                _context38.next = 4;
+                _context41.next = 4;
                 break;
               }
-              return _context38.abrupt("return", {
+              return _context41.abrupt("return", {
                 success: false,
                 message: '订单ID不能为空',
                 orderId: orderId
@@ -3669,12 +4055,12 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
               });
 
               // 调用后端API修改订单备注
-              _context38.next = 7;
+              _context41.next = 7;
               return this.request.put("/order/order/".concat(orderId, "/note"), {
                 note: note
               });
             case 7:
-              response = _context38.sent;
+              response = _context41.sent;
               this.logInfo('订单备注编辑响应:', {
                 orderId: orderId,
                 status: response.status,
@@ -3684,11 +4070,11 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
 
               // 检查响应状态
               if (!(response.status === true || response.status === 200)) {
-                _context38.next = 18;
+                _context41.next = 18;
                 break;
               }
               if (!(this.store.currentOrder && (String(this.store.currentOrder.order_id) === String(orderId) || String(this.store.currentOrder.id) === String(orderId)))) {
-                _context38.next = 15;
+                _context41.next = 15;
                 break;
               }
               // 获取修改前的备注用于事件
@@ -3698,7 +4084,7 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
               }
 
               // 触发订单备注变更事件
-              _context38.next = 15;
+              _context41.next = 15;
               return this.core.effects.emit(CheckoutHooks.OnOrderNoteChanged, {
                 orderUuid: this.store.currentOrder.uuid,
                 oldNote: previousNote,
@@ -3706,7 +4092,7 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
                 timestamp: Date.now()
               });
             case 15:
-              return _context38.abrupt("return", {
+              return _context41.abrupt("return", {
                 success: true,
                 message: response.message || '订单备注修改成功',
                 orderId: orderId
@@ -3715,31 +4101,31 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
               // API返回失败状态
               errorMessage = response.message || '订单备注修改失败';
               this.logError("\u8BA2\u5355 ".concat(orderId, " \u5907\u6CE8\u4FEE\u6539\u5931\u8D25:"), errorMessage);
-              return _context38.abrupt("return", {
+              return _context41.abrupt("return", {
                 success: false,
                 message: errorMessage,
                 orderId: orderId
               });
             case 21:
-              _context38.next = 28;
+              _context41.next = 28;
               break;
             case 23:
-              _context38.prev = 23;
-              _context38.t0 = _context38["catch"](1);
-              this.logError('编辑订单备注失败:', _context38.t0);
-              _errorMessage = _context38.t0 instanceof Error ? _context38.t0.message : '网络错误或服务器异常';
-              return _context38.abrupt("return", {
+              _context41.prev = 23;
+              _context41.t0 = _context41["catch"](1);
+              this.logError('编辑订单备注失败:', _context41.t0);
+              _errorMessage = _context41.t0 instanceof Error ? _context41.t0.message : '网络错误或服务器异常';
+              return _context41.abrupt("return", {
                 success: false,
                 message: "\u7F16\u8F91\u8BA2\u5355\u5907\u6CE8\u5931\u8D25: ".concat(_errorMessage),
                 orderId: orderId
               });
             case 28:
             case "end":
-              return _context38.stop();
+              return _context41.stop();
           }
-        }, _callee38, this, [[1, 23]]);
+        }, _callee41, this, [[1, 23]]);
       }));
-      function editOrderNoteByOrderIdAsync(_x28, _x29) {
+      function editOrderNoteByOrderIdAsync(_x30, _x31) {
         return _editOrderNoteByOrderIdAsync.apply(this, arguments);
       }
       return editOrderNoteByOrderIdAsync;
@@ -3756,11 +4142,11 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
   }, {
     key: "sendCustomerPayLinkAsync",
     value: (function () {
-      var _sendCustomerPayLinkAsync = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee39(params) {
+      var _sendCustomerPayLinkAsync = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee42(params) {
         var _params$order_ids, _params$emails;
         var emailRegex, invalidEmails, requestBody, response, errorMessage, _errorMessage2;
-        return _regeneratorRuntime().wrap(function _callee39$(_context39) {
-          while (1) switch (_context39.prev = _context39.next) {
+        return _regeneratorRuntime().wrap(function _callee42$(_context42) {
+          while (1) switch (_context42.prev = _context42.next) {
             case 0:
               this.logInfo('sendCustomerPayLinkAsync called', {
                 orderIds: params.order_ids,
@@ -3769,21 +4155,21 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
                 emailsCount: ((_params$emails = params.emails) === null || _params$emails === void 0 ? void 0 : _params$emails.length) || 0,
                 notifyAction: params.notify_action || 'order_payment_reminder'
               });
-              _context39.prev = 1;
+              _context42.prev = 1;
               if (!(!params.order_ids || params.order_ids.length === 0)) {
-                _context39.next = 4;
+                _context42.next = 4;
                 break;
               }
-              return _context39.abrupt("return", {
+              return _context42.abrupt("return", {
                 success: false,
                 message: '订单ID列表不能为空'
               });
             case 4:
               if (!(!params.emails || params.emails.length === 0)) {
-                _context39.next = 6;
+                _context42.next = 6;
                 break;
               }
-              return _context39.abrupt("return", {
+              return _context42.abrupt("return", {
                 success: false,
                 message: '邮箱地址列表不能为空'
               });
@@ -3794,10 +4180,10 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
                 return !emailRegex.test(email);
               });
               if (!(invalidEmails.length > 0)) {
-                _context39.next = 10;
+                _context42.next = 10;
                 break;
               }
-              return _context39.abrupt("return", {
+              return _context42.abrupt("return", {
                 success: false,
                 message: "\u90AE\u7BB1\u683C\u5F0F\u65E0\u6548: ".concat(invalidEmails.join(', '))
               });
@@ -3813,10 +4199,10 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
               }, requestBody));
 
               // 调用后端API发送邮件
-              _context39.next = 14;
+              _context42.next = 14;
               return this.request.post('/order/batch-email', requestBody);
             case 14:
-              response = _context39.sent;
+              response = _context42.sent;
               this.logInfo('支付链接邮件发送响应:', {
                 status: response.status,
                 message: response.message,
@@ -3826,10 +4212,10 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
 
               // 检查响应状态
               if (!(response.status === true || response.status === 200)) {
-                _context39.next = 20;
+                _context42.next = 20;
                 break;
               }
-              return _context39.abrupt("return", {
+              return _context42.abrupt("return", {
                 success: true,
                 message: response.message || '支付链接邮件发送成功'
               });
@@ -3837,29 +4223,29 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
               // API返回失败状态
               errorMessage = response.message || '支付链接邮件发送失败';
               console.error('[Checkout] 支付链接邮件发送失败:', errorMessage);
-              return _context39.abrupt("return", {
+              return _context42.abrupt("return", {
                 success: false,
                 message: errorMessage
               });
             case 23:
-              _context39.next = 30;
+              _context42.next = 30;
               break;
             case 25:
-              _context39.prev = 25;
-              _context39.t0 = _context39["catch"](1);
-              this.logError('发送客户支付链接邮件失败:', _context39.t0);
-              _errorMessage2 = _context39.t0 instanceof Error ? _context39.t0.message : '网络错误或服务器异常';
-              return _context39.abrupt("return", {
+              _context42.prev = 25;
+              _context42.t0 = _context42["catch"](1);
+              this.logError('发送客户支付链接邮件失败:', _context42.t0);
+              _errorMessage2 = _context42.t0 instanceof Error ? _context42.t0.message : '网络错误或服务器异常';
+              return _context42.abrupt("return", {
                 success: false,
                 message: "\u53D1\u9001\u652F\u4ED8\u94FE\u63A5\u90AE\u4EF6\u5931\u8D25: ".concat(_errorMessage2)
               });
             case 30:
             case "end":
-              return _context39.stop();
+              return _context42.stop();
           }
-        }, _callee39, this, [[1, 25]]);
+        }, _callee42, this, [[1, 25]]);
       }));
-      function sendCustomerPayLinkAsync(_x30) {
+      function sendCustomerPayLinkAsync(_x32) {
         return _sendCustomerPayLinkAsync.apply(this, arguments);
       }
       return sendCustomerPayLinkAsync;
@@ -3874,24 +4260,38 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
   }, {
     key: "roundAmountAsync",
     value: (function () {
-      var _roundAmountAsync = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee40(amount) {
-        var _this$otherParams$ord, _this$otherParams$ord2;
-        var result;
-        return _regeneratorRuntime().wrap(function _callee40$(_context40) {
-          while (1) switch (_context40.prev = _context40.next) {
+      var _roundAmountAsync = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee43(amount) {
+        var _cashManualPayment$me, _this$otherParams$ord, _this$otherParams$ord2;
+        var cashManualPayment, result;
+        return _regeneratorRuntime().wrap(function _callee43$(_context43) {
+          while (1) switch (_context43.prev = _context43.next) {
             case 0:
-              _context40.next = 2;
+              // 检查 CASHMANUAL 的支付项是否开启了舍入，如果没开直接返回 amount
+              cashManualPayment = this.store.paymentMethods.find(function (p) {
+                return p.code === 'CASHMANUAL';
+              });
+              if (cashManualPayment !== null && cashManualPayment !== void 0 && (_cashManualPayment$me = cashManualPayment.metadata) !== null && _cashManualPayment$me !== void 0 && _cashManualPayment$me.order_rounding_switch) {
+                _context43.next = 3;
+                break;
+              }
+              return _context43.abrupt("return", {
+                originalAmount: amount.toString(),
+                roundedAmount: amount.toString(),
+                roundingDifference: '0.00'
+              });
+            case 3:
+              _context43.next = 5;
               return this.payment.roundAmountAsync(amount, (_this$otherParams$ord = this.otherParams.order_rounding_setting) === null || _this$otherParams$ord === void 0 ? void 0 : _this$otherParams$ord.interval, (_this$otherParams$ord2 = this.otherParams.order_rounding_setting) === null || _this$otherParams$ord2 === void 0 ? void 0 : _this$otherParams$ord2.type);
-            case 2:
-              result = _context40.sent;
-              return _context40.abrupt("return", result);
-            case 4:
+            case 5:
+              result = _context43.sent;
+              return _context43.abrupt("return", result);
+            case 7:
             case "end":
-              return _context40.stop();
+              return _context43.stop();
           }
-        }, _callee40, this);
+        }, _callee43, this);
       }));
-      function roundAmountAsync(_x31) {
+      function roundAmountAsync(_x33) {
         return _roundAmountAsync.apply(this, arguments);
       }
       return roundAmountAsync;
@@ -3899,10 +4299,10 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
   }, {
     key: "destroy",
     value: function () {
-      var _destroy = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee41() {
+      var _destroy = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee44() {
         var _this$order, _this$order$destroy, _this$payment, _this$payment$destroy;
-        return _regeneratorRuntime().wrap(function _callee41$(_context41) {
-          while (1) switch (_context41.prev = _context41.next) {
+        return _regeneratorRuntime().wrap(function _callee44$(_context44) {
+          while (1) switch (_context44.prev = _context44.next) {
             case 0:
               // 清理钱包模块的所有缓存数据
               this.payment.wallet.clearAllCache();
@@ -3911,10 +4311,10 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
               this.core.effects.offByModuleDestroy(this.name);
 
               // 销毁子模块
-              _context41.next = 4;
+              _context44.next = 4;
               return (_this$order = this.order) === null || _this$order === void 0 || (_this$order$destroy = _this$order.destroy) === null || _this$order$destroy === void 0 ? void 0 : _this$order$destroy.call(_this$order);
             case 4:
-              _context41.next = 6;
+              _context44.next = 6;
               return (_this$payment = this.payment) === null || _this$payment === void 0 || (_this$payment$destroy = _this$payment.destroy) === null || _this$payment$destroy === void 0 ? void 0 : _this$payment$destroy.call(_this$payment);
             case 6:
               // 取消注册模块
@@ -3922,9 +4322,9 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
               console.log('[Checkout] 已销毁');
             case 8:
             case "end":
-              return _context41.stop();
+              return _context44.stop();
           }
-        }, _callee41, this);
+        }, _callee44, this);
       }));
       function destroy() {
         return _destroy.apply(this, arguments);
@@ -3935,70 +4335,57 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
      * 重置 store 状态
      *
      * 在创建新订单前调用，确保状态完全干净
+     * 
+     * 🚀 性能优化：改为同步方法，事件发射不阻塞主流程
      */
   }, {
-    key: "resetStoreStateAsync",
-    value: (function () {
-      var _resetStoreStateAsync = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee42() {
-        var prevOrderInfo;
-        return _regeneratorRuntime().wrap(function _callee42$(_context42) {
-          while (1) switch (_context42.prev = _context42.next) {
-            case 0:
-              _context42.prev = 0;
-              prevOrderInfo = this.store.currentOrder ? {
-                uuid: this.store.currentOrder.uuid,
-                orderId: this.store.currentOrder.order_id
-              } : null;
-              console.log('[Checkout] 重置 store 状态，准备创建新订单', prevOrderInfo);
-
-              // 重置订单相关的 store 状态（保留 paymentMethods，因为支付方式数据变更不频繁）
-              this.store.currentOrder = undefined;
-              this.store.localOrderData = undefined;
-              this.store.cartSummary = undefined;
-              this.store.stateAmount = '0.00';
-              this.store.balanceDueAmount = '0.00';
-              this.store.isOrderSynced = false;
-              this.store.currentCustomer = undefined;
-              this.store.lastError = undefined;
+    key: "resetStoreState",
+    value: function resetStoreState() {
+      var _this6 = this;
+      try {
+        var prevOrderInfo = this.store.currentOrder ? {
+          uuid: this.store.currentOrder.uuid,
+          orderId: this.store.currentOrder.order_id
+        } : null;
+        console.log('[Checkout] 重置 store 状态，准备创建新订单', prevOrderInfo);
 
-              // 清空购物车项目
-              this.store.cartItems = [];
+        // 重置订单相关的 store 状态（保留 paymentMethods，因为支付方式数据变更不频繁）
+        this.store.currentOrder = undefined;
+        this.store.localOrderData = undefined;
+        this.store.cartSummary = undefined;
+        this.store.stateAmount = '0.00';
+        this.store.balanceDueAmount = '0.00';
+        this.store.isOrderSynced = false;
+        this.store.currentCustomer = undefined;
+        this.store.lastError = undefined;
 
-              // 清理钱包缓存
-              this.payment.wallet.clearAllCache();
+        // 清空购物车项目
+        this.store.cartItems = [];
 
-              // 注意：故意保留 this.store.paymentMethods，因为支付方式数据不易变更，保留在内存中提高性能
+        // 清理钱包缓存（同步操作）
+        this.payment.wallet.clearAllCache();
 
-              console.log('[Checkout] Store 状态重置完成');
+        // 🚀 清除计算缓存
+        this.clearCalculationCache();
 
-              // 触发订单清理事件（如果之前有订单）
-              if (!prevOrderInfo) {
-                _context42.next = 17;
-                break;
-              }
-              _context42.next = 17;
-              return this.core.effects.emit(CheckoutHooks.OnOrderCleared, {
-                previousOrder: prevOrderInfo,
-                timestamp: Date.now()
-              });
-            case 17:
-              _context42.next = 22;
-              break;
-            case 19:
-              _context42.prev = 19;
-              _context42.t0 = _context42["catch"](0);
-              console.error('[Checkout] 重置 store 状态失败:', _context42.t0);
-            case 22:
-            case "end":
-              return _context42.stop();
-          }
-        }, _callee42, this, [[0, 19]]);
-      }));
-      function resetStoreStateAsync() {
-        return _resetStoreStateAsync.apply(this, arguments);
+        // 注意：故意保留 this.store.paymentMethods，因为支付方式数据不易变更，保留在内存中提高性能
+
+        console.log('[Checkout] Store 状态重置完成');
+
+        // 🚀 性能优化：异步触发订单清理事件（不阻塞主流程）
+        // 使用 setTimeout 确保事件处理不会阻塞状态重置
+        if (prevOrderInfo) {
+          setTimeout(function () {
+            _this6.core.effects.emit(CheckoutHooks.OnOrderCleared, {
+              previousOrder: prevOrderInfo,
+              timestamp: Date.now()
+            });
+          }, 0);
+        }
+      } catch (error) {
+        console.error('[Checkout] 重置 store 状态失败:', error);
       }
-      return resetStoreStateAsync;
-    }())
+    }
   }]);
   return CheckoutImpl;
 }(BaseModule);