@pisell/pisellos 2.1.28 → 2.1.30

package/lib/solution/Checkout/index.js

@@ -49,6 +49,9 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
     this.defaultVersion = "1.0.0";
     this.isSolution = true;
     this.otherParams = {};
+    // LoggerManager 实例
+    // 计算缓存（用于性能优化）
+    this.calculationCache = {};
   }
   async initialize(core, options) {
     this.core = core;
@@ -344,7 +347,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       totalInfoKeys: params.totalInfo ? Object.keys(params.totalInfo) : []
     });
     try {
-      await this.resetStoreStateAsync();
+      this.resetStoreState();
       const validation = (0, import_utils.validateLocalOrderData)(params.orderData);
       if (!validation.valid) {
         throw (0, import_utils.createCheckoutError)(
@@ -394,13 +397,20 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         }
       });
       this.store.currentOrder = paymentOrder;
-      if (params.autoPayment) {
-      }
       this.core.effects.emit(import_types.CheckoutHooks.OnOrderCreated, {
         order: paymentOrder,
         timestamp: Date.now()
       });
+      const updateAmountStartTime = Date.now();
       await this.updateStateAmountToRemaining(false);
+      const updateAmountDuration = Date.now() - updateAmountStartTime;
+      this.logInfo("updateStateAmountToRemaining operation completed", {
+        operation: "updateStateAmountToRemaining",
+        orderUuid: paymentOrder.uuid,
+        orderId: paymentOrder.order_id,
+        duration: `${updateAmountDuration}ms`,
+        performance: updateAmountDuration > 200 ? "slow" : updateAmountDuration > 100 ? "medium" : "fast"
+      });
       this.logInfo("本地订单创建成功:", {
         localOrderId,
         uuid: paymentOrder.uuid,
@@ -475,7 +485,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       );
       const paidAmount = activePayments.reduce((sum, p) => {
         const amt = new import_decimal.default(p.amount || "0");
-        const rounding = new import_decimal.default(p.rounding_amount || "0").abs();
+        const rounding = new import_decimal.default(Number(p.rounding_amount) > 0 ? 0 : p.rounding_amount || "0").abs();
         return sum.plus(amt).plus(rounding);
       }, new import_decimal.default(0));
       const remaining = import_decimal.default.max(0, totalAmount.minus(paidAmount)).toFixed(
@@ -524,7 +534,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       });
       const syncedAmount = activePayments.reduce((sum, p) => {
         const amt = new import_decimal.default(p.amount || "0");
-        const rounding = new import_decimal.default(p.rounding_amount || "0").abs();
+        const rounding = new import_decimal.default(Number(p.rounding_amount) > 0 ? 0 : p.rounding_amount || "0").abs();
         return sum.plus(amt).plus(rounding);
       }, new import_decimal.default(0));
       const remainingExpectAmount = import_decimal.default.max(0, totalAmount.minus(syncedAmount)).toFixed(
@@ -589,7 +599,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         timestamp: Date.now()
       });
       console.log("[Checkout] 结账流程完成:", order.id);
-      await this.resetStoreStateAsync();
+      this.resetStoreState();
       return {
         success: true,
         orderId: String(order.id)
@@ -854,6 +864,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         paymentItemWithType
       );
       this.logInfo("支付项添加成功");
+      this.clearCalculationCache();
       await this.updateStateAmountToRemaining();
       const remainingAmount = await this.calculateRemainingAmountAsync();
       if (Number(remainingAmount) > 0) {
@@ -944,6 +955,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         paymentUuid
       );
       this.logInfo("Payment支付项删除完成", paymentItem);
+      this.clearCalculationCache();
       const currentOrderId = this.store.currentOrder.order_id;
       const isCurrentOrderReal = currentOrderId && !(0, import_utils.isVirtualOrderId)(currentOrderId);
       const updatedOrder = await this.payment.getPaymentOrderByUuidAsync(
@@ -1038,6 +1050,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         this.store.currentOrder.uuid,
         voucherPaymentItemsWithType
       );
+      this.clearCalculationCache();
       const currentOrderId = this.store.currentOrder.order_id;
       const isCurrentOrderReal = currentOrderId && !(0, import_utils.isVirtualOrderId)(currentOrderId);
       const updatedOrder = await this.payment.getPaymentOrderByUuidAsync(
@@ -1117,6 +1130,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       if (this.store.localOrderData) {
         this.store.localOrderData.is_deposit = newDepositValue;
       }
+      this.clearCalculationCache();
       this.updateStateAmountToRemaining(false);
       await this.core.effects.emit(import_types.CheckoutHooks.OnOrderCreated, {
         order: this.store.currentOrder,
@@ -1208,6 +1222,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
           this.store.localOrderData.is_deposit = updateParams.is_deposit;
         }
       }
+      this.clearCalculationCache();
       this.updateStateAmountToRemaining(false);
       await this.core.effects.emit(import_types.CheckoutHooks.OnOrderCreated, {
         order: this.store.currentOrder,
@@ -1237,6 +1252,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
    */
   async manualSyncOrderAsync() {
     var _a, _b, _c, _d, _e;
+    console.log("manualSyncOrderAsync called");
     this.logInfo("manualSyncOrderAsync called", {
       hasCurrentOrder: !!this.store.currentOrder,
       currentOrderId: (_a = this.store.currentOrder) == null ? void 0 : _a.order_id,
@@ -1263,7 +1279,9 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         totalAmount: this.store.currentOrder.total_amount,
         remainingAmount: await this.calculateRemainingAmountAsync()
       });
+      console.time("manualSyncOrderAsync");
       const syncResult = await this.syncOrderToBackendWithReturn(true);
+      console.timeEnd("manualSyncOrderAsync");
       this.logInfo("手动同步订单完成:", {
         orderUuid,
         syncResult,
@@ -1756,8 +1774,58 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       this.logError("Expired orders cleanup failed", { error: errorMessage });
     }
   }
+  /**
+   * 清除计算缓存
+   */
+  clearCalculationCache() {
+    this.calculationCache = {};
+  }
+  /**
+   * 批量获取订单数据（用于性能优化）
+   * 一次性获取所有需要的数据，避免重复查询
+   */
+  async fetchOrderDataBatch() {
+    if (!this.store.currentOrder) {
+      return { paymentItems: [], currentOrder: null };
+    }
+    const orderUuid = this.store.currentOrder.uuid;
+    const now = Date.now();
+    const cacheValid = this.calculationCache.orderUuid === orderUuid && this.calculationCache.timestamp && now - this.calculationCache.timestamp < 5e3;
+    if (cacheValid && this.calculationCache.paymentItems && this.calculationCache.currentOrder) {
+      return {
+        paymentItems: this.calculationCache.paymentItems,
+        currentOrder: this.calculationCache.currentOrder
+      };
+    }
+    const [paymentItems, currentOrder] = await Promise.all([
+      this.payment.getPaymentItemsAsync(orderUuid, false),
+      this.payment.getPaymentOrderByUuidAsync(orderUuid)
+    ]);
+    this.calculationCache = {
+      paymentItems,
+      currentOrder,
+      orderUuid,
+      timestamp: now
+    };
+    return { paymentItems, currentOrder };
+  }
+  /**
+   * 从支付项数组计算已支付金额（纯计算，不查询数据库）
+   */
+  calculatePaidAmountFromItems(payments) {
+    const paidAmount = payments.filter((payment) => payment.status !== "voided").reduce((sum, payment) => {
+      const amount = new import_decimal.default(payment.amount || "0");
+      const roundingAmount = new import_decimal.default(payment.rounding_amount || "0");
+      const effectiveAmount = amount.add(roundingAmount.isNegative() ? roundingAmount.abs() : 0);
+      return sum.add(effectiveAmount);
+    }, new import_decimal.default(0));
+    return paidAmount.toFixed(2);
+  }
   /**
    * 计算已支付金额（从 Payment 模块获取最新数据）
+   * 
+   * 注意：此方法保持独立性，可以单独调用。
+   * 在 updateStateAmountToRemaining 等批量操作中会使用缓存优化。
    */
   async calculatePaidAmountAsync() {
     if (!this.store.currentOrder) {
@@ -1765,30 +1833,18 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       return "0.00";
     }
     try {
+      const now = Date.now();
+      const cacheValid = this.calculationCache.orderUuid === this.store.currentOrder.uuid && this.calculationCache.timestamp && now - this.calculationCache.timestamp < 5e3 && this.calculationCache.paidAmount;
+      if (cacheValid && this.calculationCache.paidAmount) {
+        return this.calculationCache.paidAmount;
+      }
       const payments = await this.payment.getPaymentItemsAsync(
         this.store.currentOrder.uuid,
         false
         // 不包括已撤销的支付项
       );
-      const paidAmount = payments.filter((payment) => payment.status !== "voided").reduce((sum, payment) => {
-        const amount = new import_decimal.default(payment.amount || "0");
-        const roundingAmount = new import_decimal.default(payment.rounding_amount || "0");
-        const effectiveAmount = amount.add(roundingAmount.abs());
-        console.log(`[Checkout] 计算支付项: ${payment.code}`, {
-          originalAmount: amount.toFixed(2),
-          roundingAmount: roundingAmount.toFixed(2),
-          effectiveAmount: effectiveAmount.toFixed(2),
-          description: !roundingAmount.isZero() ? `抹零金额 ${roundingAmount.toFixed(2)} 元，有效支付增加 ${roundingAmount.abs().toFixed(2)} 元` : "无抹零",
-          // Decimal 精度验证
-          preciseCalculationValues: {
-            amount: amount.toString(),
-            roundingAmount: roundingAmount.toString(),
-            effectiveAmount: effectiveAmount.toString()
-          }
-        });
-        return sum.add(effectiveAmount);
-      }, new import_decimal.default(0));
-      const result = paidAmount.toFixed(2);
+      const result = this.calculatePaidAmountFromItems(payments);
+      this.calculationCache.paidAmount = result;
       this.logInfo("calculatePaidAmountAsync: 计算结果 =", result);
       return result;
     } catch (error) {
@@ -1796,41 +1852,82 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       return "0.00";
     }
   }
+  /**
+   * 从订单和支付项计算剩余金额（纯计算，不查询数据库）
+   */
+  calculateRemainingAmountFromData(currentOrder, paidAmount) {
+    let totalAmount = new import_decimal.default(currentOrder.total_amount || "0");
+    if (currentOrder.is_deposit && currentOrder.deposit_amount && Number(currentOrder.deposit_amount) > 0) {
+      totalAmount = new import_decimal.default(currentOrder.deposit_amount);
+    }
+    const paid = new import_decimal.default(paidAmount);
+    const remainingAmount = totalAmount.sub(paid);
+    return import_decimal.default.max(0, remainingAmount).toFixed(2);
+  }
+  /**
+   * 从订单和支付项计算剩余总金额（纯计算，排除定金）
+   */
+  calculateRemainingTotalAmountFromData(currentOrder, paidAmount) {
+    const totalAmount = new import_decimal.default(currentOrder.total_amount || "0");
+    const paid = new import_decimal.default(paidAmount);
+    const remainingAmount = totalAmount.sub(paid);
+    return import_decimal.default.max(0, remainingAmount).toFixed(2);
+  }
   /**
    * 计算剩余未支付金额（从 Payment 模块获取最新数据）
+   * 
+   * 注意：此方法保持独立性，可以单独调用。
+   * 在 updateStateAmountToRemaining 等批量操作中会使用缓存优化。
    */
   async calculateRemainingAmountAsync() {
     if (!this.store.currentOrder) {
       this.logWarning("calculateRemainingAmountAsync: 没有当前订单");
       return "0.00";
     }
-    let totalAmount = new import_decimal.default(this.store.currentOrder.total_amount || "0");
-    const currentOrder = await this.payment.getPaymentOrderByUuidAsync(
-      this.store.currentOrder.uuid
-    );
-    if ((currentOrder == null ? void 0 : currentOrder.is_deposit) && (currentOrder == null ? void 0 : currentOrder.deposit_amount) && Number(currentOrder == null ? void 0 : currentOrder.deposit_amount) > 0) {
-      totalAmount = new import_decimal.default(currentOrder == null ? void 0 : currentOrder.deposit_amount);
+    const { currentOrder } = await this.fetchOrderDataBatch();
+    if (!currentOrder) {
+      return "0.00";
     }
     const paidAmountStr = await this.calculatePaidAmountAsync();
-    const paidAmount = new import_decimal.default(paidAmountStr);
-    const remainingAmount = totalAmount.sub(paidAmount);
-    const result = import_decimal.default.max(0, remainingAmount).toFixed(2);
+    const result = this.calculateRemainingAmountFromData(currentOrder, paidAmountStr);
     this.logInfo("calculateRemainingAmountAsync: 计算=", result);
     return result;
   }
+  /**
+   * 计算剩余未支付金额（排除定金计算，始终使用订单总金额）
+   * 
+   * 注意：此方法保持独立性，可以单独调用。
+   * 在 updateStateAmountToRemaining 等批量操作中会使用缓存优化。
+   */
+  async calculateRemainingTotalAmountAsync() {
+    if (!this.store.currentOrder) {
+      this.logWarning("calculateRemainingTotalAmountAsync: 没有当前订单");
+      return "0.00";
+    }
+    const { currentOrder } = await this.fetchOrderDataBatch();
+    if (!currentOrder) {
+      return "0.00";
+    }
+    const paidAmountStr = await this.calculatePaidAmountAsync();
+    const result = this.calculateRemainingTotalAmountFromData(currentOrder, paidAmountStr);
+    this.logInfo("calculateRemainingTotalAmountAsync: 计算=", result);
+    return result;
+  }
   /**
    * 更新 balanceDueAmount 为当前剩余未支付金额（系统内部计算）
    */
   async updateBalanceDueAmount() {
     try {
       const remainingAmount = await this.calculateRemainingAmountAsync();
+      const remainingTotalAmount = await this.calculateRemainingTotalAmountAsync();
       const currentBalanceDueAmount = this.store.balanceDueAmount;
       if (remainingAmount !== currentBalanceDueAmount) {
         this.store.balanceDueAmount = remainingAmount;
         await this.core.effects.emit(import_types.CheckoutHooks.OnBalanceDueAmountChanged, {
           oldAmount: currentBalanceDueAmount,
           newAmount: remainingAmount,
-          timestamp: Date.now()
+          timestamp: Date.now(),
+          totalAmount: remainingTotalAmount
         });
         this.logInfo("balanceDueAmount 已自动更新:", {
           oldAmount: currentBalanceDueAmount,
@@ -1848,14 +1945,25 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
   }
   /**
    * 更新 stateAmount 为当前剩余未支付金额
+   * 
+   * 优化版本：批量获取数据，避免重复查询数据库
    */
   async updateStateAmountToRemaining(checkOrder = true) {
-    var _a, _b, _c, _d;
     try {
-      if (((_a = this.store.currentOrder) == null ? void 0 : _a.is_deposit) === 1) {
-        const paymentItems = await this.payment.getPaymentItemsAsync(
-          (_b = this.store.currentOrder) == null ? void 0 : _b.uuid
-        );
+      if (!this.store.currentOrder) {
+        return;
+      }
+      console.time("updateStateAmountToRemaining");
+      const { paymentItems, currentOrder } = await this.fetchOrderDataBatch();
+      console.timeEnd("updateStateAmountToRemaining");
+      if (!currentOrder) {
+        this.logWarning("updateStateAmountToRemaining: 未找到当前订单");
+        return;
+      }
+      const paidAmount = this.calculatePaidAmountFromItems(paymentItems);
+      this.calculationCache.paidAmount = paidAmount;
+      let needUpdateDepositStatus = false;
+      if (currentOrder.is_deposit === 1) {
         const depositPaidAmount = paymentItems.filter(
           (item) => item.order_payment_type === "deposit" && item.status !== "voided"
         ).reduce((sum, item) => {
@@ -1864,40 +1972,72 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
           }
           const amount = new import_decimal.default(item.amount || "0");
           const roundingAmount = new import_decimal.default(item.rounding_amount || "0");
-          return sum.add(amount.add(roundingAmount.abs()));
+          return sum.add(amount.add(roundingAmount.isNegative() ? roundingAmount.abs() : 0));
         }, new import_decimal.default(0));
-        if (depositPaidAmount.gte((_c = this.store.currentOrder) == null ? void 0 : _c.deposit_amount)) {
-          this.store.currentOrder = {
-            ...this.store.currentOrder,
-            is_deposit: 0
-          };
-          await this.payment.updateOrderAsync((_d = this.store.currentOrder) == null ? void 0 : _d.uuid, {
-            is_deposit: 0
-          });
+        if (depositPaidAmount.gte(currentOrder.deposit_amount || "0")) {
+          needUpdateDepositStatus = true;
+          currentOrder.is_deposit = 0;
         }
       }
-      const remainingAmount = await this.calculateRemainingAmountAsync();
+      const remainingAmount = this.calculateRemainingAmountFromData(currentOrder, paidAmount);
+      const remainingTotalAmount = this.calculateRemainingTotalAmountFromData(currentOrder, paidAmount);
       const currentStateAmount = this.store.stateAmount;
+      const currentBalanceDueAmount = this.store.balanceDueAmount;
+      let hasStateChanged = false;
+      if (needUpdateDepositStatus) {
+        this.store.currentOrder = {
+          ...this.store.currentOrder,
+          is_deposit: 0
+        };
+        await this.payment.updateOrderAsync(this.store.currentOrder.uuid, {
+          is_deposit: 0
+        });
+        hasStateChanged = true;
+      }
+      console.time("updateStateAmountToRemaining: remainingAmount");
       if (remainingAmount !== currentStateAmount) {
         this.store.stateAmount = remainingAmount;
-        this.core.effects.emit(import_types.CheckoutHooks.OnStateAmountChanged, {
-          oldAmount: currentStateAmount,
-          newAmount: remainingAmount,
-          timestamp: Date.now()
-        });
+        hasStateChanged = true;
+        setTimeout(() => {
+          this.core.effects.emit(`${this.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");
+      if (remainingAmount !== currentBalanceDueAmount) {
+        this.store.balanceDueAmount = remainingAmount;
+        hasStateChanged = true;
+        setTimeout(() => {
+          this.core.effects.emit(`${this.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
         });
       }
-      await this.updateBalanceDueAmount();
       if (checkOrder) {
-        await this.checkOrderPaymentCompletion();
+        await this.checkOrderPaymentCompletionOptimized(paymentItems, remainingAmount);
       } else {
         this.logInfo("外部传入无需 checkOrder，不执行订单支付完成检测和同步");
       }
@@ -1905,10 +2045,81 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       this.logError("更新 stateAmount 为剩余金额失败:", error);
     }
   }
+  /**
+   * 检查订单支付是否完成（优化版，复用已获取的数据）
+   * 
+   * @param paymentItems 已获取的支付项数据
+   * @param remainingAmount 已计算的剩余金额
+   */
+  async checkOrderPaymentCompletionOptimized(paymentItems, remainingAmount) {
+    try {
+      if (!this.store.currentOrder) {
+        return;
+      }
+      const remainingValue = new import_decimal.default(remainingAmount);
+      if (remainingValue.lte(0)) {
+        const totalAmount = this.store.currentOrder.total_amount;
+        const paidAmount = this.calculationCache.paidAmount || "0.00";
+        this.logInfo("检测到订单支付完成:", {
+          orderUuid: this.store.currentOrder.uuid,
+          orderId: this.store.currentOrder.order_id,
+          totalAmount,
+          paidAmount,
+          remainingAmount,
+          isOrderSynced: this.store.isOrderSynced
+        });
+        const hasPaymentItems = paymentItems.length > 0;
+        const allPaymentsHaveVoucherId = hasPaymentItems && paymentItems.every(
+          (item) => item.status !== "voided" && item.voucher_id
+        );
+        const shouldAutoSync = hasPaymentItems && !allPaymentsHaveVoucherId;
+        this.logInfo("自动同步订单条件检查:", {
+          paymentCount: paymentItems.length,
+          hasPaymentItems,
+          allHaveVoucherId: allPaymentsHaveVoucherId,
+          isOrderSynced: this.store.isOrderSynced,
+          shouldAutoSync,
+          reason: shouldAutoSync ? "支付完成，需要同步最终支付状态" : "跳过同步",
+          paymentItems: paymentItems.map((p) => ({
+            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) {
+          this.logInfo("满足自动同步条件，开始同步订单到后端...");
+          await this.syncOrderToBackendWithReturn(false);
+        } else {
+          if (!hasPaymentItems) {
+            this.logInfo("没有支付项，跳过订单同步");
+          } else if (allPaymentsHaveVoucherId) {
+            this.logInfo("所有支付项均为代金券类型，跳过订单同步");
+          }
+        }
+        await this.core.effects.emit(`${this.name}:onOrderPaymentCompleted`, {
+          orderUuid: this.store.currentOrder.uuid,
+          orderId: this.store.currentOrder.order_id,
+          totalAmount,
+          paidAmount,
+          remainingAmount,
+          timestamp: Date.now()
+        });
+      }
+    } catch (error) {
+      this.logError("检查订单支付完成状态失败:", error);
+    }
+  }
   /**
    * 检查订单支付是否完成
    *
    * 当剩余待付款金额 <= 0 时，触发订单支付完成事件
+   * 
+   * 注意：此方法保持独立性，可以单独调用。
+   * 在 updateStateAmountToRemaining 中会使用优化版本。
    */
   async checkOrderPaymentCompletion() {
     try {
@@ -1950,7 +2161,7 @@ var CheckoutImpl = class extends import_BaseModule.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
           }))
@@ -2247,6 +2458,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       this.logWarning("标记支付项已同步失败（不阻塞主流程）", { error: e });
     }
     this.store.isOrderSynced = true;
+    this.clearCalculationCache();
     await this.core.effects.emit(import_types.CheckoutHooks.OnOrderSynced, {
       orderUuid: this.store.currentOrder.uuid,
       realOrderId,
@@ -2433,11 +2645,19 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
    * @returns 舍入结果详情，包含原始金额、舍入后金额和舍入差额
    */
   async roundAmountAsync(amount) {
-    var _a, _b;
+    var _a, _b, _c;
+    const cashManualPayment = this.store.paymentMethods.find((p) => p.code === "CASHMANUAL");
+    if (!((_a = cashManualPayment == null ? void 0 : cashManualPayment.metadata) == null ? void 0 : _a.order_rounding_switch)) {
+      return {
+        originalAmount: amount.toString(),
+        roundedAmount: amount.toString(),
+        roundingDifference: "0.00"
+      };
+    }
     const result = await this.payment.roundAmountAsync(
       amount,
-      (_a = this.otherParams.order_rounding_setting) == null ? void 0 : _a.interval,
-      (_b = this.otherParams.order_rounding_setting) == null ? void 0 : _b.type
+      (_b = this.otherParams.order_rounding_setting) == null ? void 0 : _b.interval,
+      (_c = this.otherParams.order_rounding_setting) == null ? void 0 : _c.type
     );
     return result;
   }
@@ -2454,8 +2674,10 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
    * 重置 store 状态
    *
    * 在创建新订单前调用，确保状态完全干净
+   * 
+   * 🚀 性能优化：改为同步方法，事件发射不阻塞主流程
    */
-  async resetStoreStateAsync() {
+  resetStoreState() {
     try {
       const prevOrderInfo = this.store.currentOrder ? {
         uuid: this.store.currentOrder.uuid,
@@ -2472,12 +2694,15 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       this.store.lastError = void 0;
       this.store.cartItems = [];
       this.payment.wallet.clearAllCache();
+      this.clearCalculationCache();
       console.log("[Checkout] Store 状态重置完成");
       if (prevOrderInfo) {
-        await this.core.effects.emit(import_types.CheckoutHooks.OnOrderCleared, {
-          previousOrder: prevOrderInfo,
-          timestamp: Date.now()
-        });
+        setTimeout(() => {
+          this.core.effects.emit(import_types.CheckoutHooks.OnOrderCleared, {
+            previousOrder: prevOrderInfo,
+            timestamp: Date.now()
+          });
+        }, 0);
       }
     } catch (error) {
       console.error("[Checkout] 重置 store 状态失败:", error);

package/package.json

@@ -1,7 +1,7 @@
 {
   "private": false,
   "name": "@pisell/pisellos",
-  "version": "2.1.28",
+  "version": "2.1.30",
   "description": "一个可扩展的前端模块化SDK框架，支持插件系统",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",