@pisell/pisellos 2.1.38 → 2.2.1

package/lib/solution/Checkout/index.js

@@ -49,9 +49,6 @@ 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;
@@ -81,7 +78,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
     await this.preloadPaymentMethods();
     await this.cleanupExpiredOrdersAsync();
     console.log("[Checkout] 初始化完成");
-    await this.core.effects.emit(import_types.CheckoutHooks.OnCheckoutInitialized, {
+    await this.core.effects.emit(`${this.name}:onCheckoutInitialized`, {
       timestamp: Date.now()
     });
     this.logInfo("CheckoutModule initialized successfully");
@@ -265,7 +262,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
     this.logInfo("initWalletData currentOrder found", {
       currentOrder: this.store.currentOrder
     });
-    await this.core.effects.emit(import_types.CheckoutHooks.OnWalletDataInitialized, {
+    await this.core.effects.emit(`${this.name}:onWalletDataInitialized`, {
       orderUuid: (_g = this.store.currentOrder) == null ? void 0 : _g.uuid,
       customerId: walletBusinessData.customer_id,
       walletBusinessData: {
@@ -347,7 +344,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       totalInfoKeys: params.totalInfo ? Object.keys(params.totalInfo) : []
     });
     try {
-      this.resetStoreState();
+      await this.resetStoreStateAsync();
       const validation = (0, import_utils.validateLocalOrderData)(params.orderData);
       if (!validation.valid) {
         throw (0, import_utils.createCheckoutError)(
@@ -397,20 +394,13 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         }
       });
       this.store.currentOrder = paymentOrder;
-      this.core.effects.emit(import_types.CheckoutHooks.OnOrderCreated, {
+      if (params.autoPayment) {
+      }
+      this.core.effects.emit(`${this.name}: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,
@@ -427,7 +417,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         import_types.CheckoutErrorType.OrderCreationFailed
       );
       this.logError("本地订单创建失败:", error);
-      this.core.effects.emit(import_types.CheckoutHooks.OnOrderCreationFailed, {
+      this.core.effects.emit(`${this.name}:onOrderCreationFailed`, {
         error: this.store.lastError,
         timestamp: Date.now()
       });
@@ -528,7 +518,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         totalAmount: updated.total_amount,
         expectAmount: updated.expect_amount
       });
-      await this.core.effects.emit(import_types.CheckoutHooks.OnOrderCreated, {
+      await this.core.effects.emit(`${this.name}:onOrderCreated`, {
         order: updated,
         timestamp: Date.now()
       });
@@ -594,12 +584,12 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         );
       }
       this.payment.wallet.clearAllCache();
-      await this.core.effects.emit(import_types.CheckoutHooks.OnCheckoutCompleted, {
+      await this.core.effects.emit(`${this.name}:onCheckoutCompleted`, {
         orderId: order.id,
         timestamp: Date.now()
       });
       console.log("[Checkout] 结账流程完成:", order.id);
-      this.resetStoreState();
+      await this.resetStoreStateAsync();
       return {
         success: true,
         orderId: String(order.id)
@@ -705,7 +695,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       );
       if (updatedOrder) {
         this.store.currentOrder = updatedOrder;
-        await this.core.effects.emit(import_types.CheckoutHooks.OnOrderCreated, {
+        await this.core.effects.emit(`${this.name}:onOrderCreated`, {
           order: updatedOrder,
           timestamp: Date.now()
         });
@@ -746,7 +736,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         newAmount: formattedAmount
       });
       this.store.stateAmount = formattedAmount;
-      await this.core.effects.emit(import_types.CheckoutHooks.OnStateAmountChanged, {
+      await this.core.effects.emit(`${this.name}:onStateAmountChanged`, {
         oldAmount,
         newAmount: formattedAmount,
         timestamp: Date.now()
@@ -864,7 +854,6 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         paymentItemWithType
       );
       this.logInfo("支付项添加成功");
-      this.clearCalculationCache();
       await this.updateStateAmountToRemaining();
       const remainingAmount = await this.calculateRemainingAmountAsync();
       if (Number(remainingAmount) > 0) {
@@ -898,7 +887,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
           }
         }
       }
-      this.core.effects.emit(import_types.CheckoutHooks.OnPaymentItemAdded, {
+      this.core.effects.emit(`${this.name}:onPaymentItemAdded`, {
         orderUuid: this.store.currentOrder.uuid,
         paymentMethodCode: paymentItem.code,
         paymentMethodName: paymentItem.name,
@@ -955,7 +944,6 @@ 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(
@@ -975,7 +963,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         this.store.currentOrder = updatedOrder;
       }
       await this.updateStateAmountToRemaining(false);
-      await this.core.effects.emit(import_types.CheckoutHooks.OnPaymentStarted, {
+      await this.core.effects.emit(`${this.name}:onPaymentStarted`, {
         orderUuid: this.store.currentOrder.uuid,
         paymentMethodCode: paymentItem.code,
         amount: `-${paymentItem.amount}`,
@@ -1050,7 +1038,6 @@ 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(
@@ -1070,7 +1057,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         this.store.currentOrder = updatedOrder;
       }
       await this.updateStateAmountToRemaining(false);
-      await this.core.effects.emit(import_types.CheckoutHooks.OnPaymentStarted, {
+      await this.core.effects.emit(`${this.name}:onPaymentStarted`, {
         orderUuid: this.store.currentOrder.uuid,
         paymentMethodCode: "VOUCHER_BATCH",
         amount: voucherPaymentItems.reduce((sum, item) => sum + parseFloat(String(item.amount)), 0).toFixed(2),
@@ -1130,9 +1117,8 @@ 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, {
+      await this.core.effects.emit(`${this.name}:onOrderCreated`, {
         order: this.store.currentOrder,
         timestamp: Date.now()
       });
@@ -1222,9 +1208,8 @@ 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, {
+      await this.core.effects.emit(`${this.name}:onOrderCreated`, {
         order: this.store.currentOrder,
         timestamp: Date.now()
       });
@@ -1252,7 +1237,6 @@ 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,
@@ -1279,9 +1263,7 @@ 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,
@@ -1411,7 +1393,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       this.store.currentCustomer = void 0;
       this.payment.wallet.clearAllCache();
       this.logInfo("订单状态清理完成，currentOrder已释放");
-      await this.core.effects.emit(import_types.CheckoutHooks.OnOrderCancelled, {
+      await this.core.effects.emit(`${this.name}:onOrderCancelled`, {
         orderUuid: currentOrderUuid,
         orderId: currentOrderId,
         cancelReason,
@@ -1528,7 +1510,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
           );
         }
       }
-      await this.core.effects.emit(import_types.CheckoutHooks.OnOrderNoteChanged, {
+      await this.core.effects.emit(`${this.name}:onOrderNoteChanged`, {
         orderUuid: (_b = this.store.currentOrder) == null ? void 0 : _b.uuid,
         oldNote,
         newNote: note,
@@ -1553,7 +1535,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
   async handleError(error, type) {
     const checkoutError = error instanceof Error && "type" in error ? error : (0, import_utils.createCheckoutError)(type, error.message, error);
     this.store.lastError = checkoutError;
-    await this.core.effects.emit(import_types.CheckoutHooks.OnError, {
+    await this.core.effects.emit(`${this.name}:onError`, {
       error: checkoutError,
       context: {},
       timestamp: Date.now()
@@ -1566,7 +1548,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
   async handlePaymentSuccess(data) {
     var _a;
     await this.updateStateAmountToRemaining();
-    await this.core.effects.emit(import_types.CheckoutHooks.OnPaymentSuccess, {
+    await this.core.effects.emit(`${this.name}:onPaymentSuccess`, {
       orderUuid: data.orderUuid,
       paymentMethodCode: "",
       amount: ((_a = this.store.currentOrder) == null ? void 0 : _a.total_amount) || "0",
@@ -1587,7 +1569,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       error instanceof Error ? error : new Error(String(error)),
       import_types.CheckoutErrorType.PaymentFailed
     );
-    await this.core.effects.emit(import_types.CheckoutHooks.OnPaymentFailed, {
+    await this.core.effects.emit(`${this.name}:onPaymentFailed`, {
       orderUuid: data.orderUuid,
       paymentMethodCode: "",
       amount: ((_a = this.store.currentOrder) == null ? void 0 : _a.total_amount) || "0",
@@ -1774,58 +1756,8 @@ 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) {
@@ -1833,18 +1765,30 @@ 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 result = this.calculatePaidAmountFromItems(payments);
-      this.calculationCache.paidAmount = result;
+      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);
+        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);
       this.logInfo("calculatePaidAmountAsync: 计算结果 =", result);
       return result;
     } catch (error) {
@@ -1852,64 +1796,41 @@ 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";
     }
-    const { currentOrder } = await this.fetchOrderDataBatch();
-    if (!currentOrder) {
-      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 paidAmountStr = await this.calculatePaidAmountAsync();
-    const result = this.calculateRemainingAmountFromData(currentOrder, paidAmountStr);
+    const paidAmount = new import_decimal.default(paidAmountStr);
+    const remainingAmount = totalAmount.sub(paidAmount);
+    const result = import_decimal.default.max(0, remainingAmount).toFixed(2);
     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 totalAmount = new import_decimal.default(this.store.currentOrder.total_amount || "0");
     const paidAmountStr = await this.calculatePaidAmountAsync();
-    const result = this.calculateRemainingTotalAmountFromData(currentOrder, paidAmountStr);
+    const paidAmount = new import_decimal.default(paidAmountStr);
+    const remainingAmount = totalAmount.sub(paidAmount);
+    const result = import_decimal.default.max(0, remainingAmount).toFixed(2);
     this.logInfo("calculateRemainingTotalAmountAsync: 计算=", result);
     return result;
   }
@@ -1923,7 +1844,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       const currentBalanceDueAmount = this.store.balanceDueAmount;
       if (remainingAmount !== currentBalanceDueAmount) {
         this.store.balanceDueAmount = remainingAmount;
-        await this.core.effects.emit(import_types.CheckoutHooks.OnBalanceDueAmountChanged, {
+        await this.core.effects.emit(`${this.name}:onBalanceDueAmountChanged`, {
           oldAmount: currentBalanceDueAmount,
           newAmount: remainingAmount,
           timestamp: Date.now(),
@@ -1945,25 +1866,14 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
   }
   /**
    * 更新 stateAmount 为当前剩余未支付金额
-   * 
-   * 优化版本：批量获取数据，避免重复查询数据库
    */
   async updateStateAmountToRemaining(checkOrder = true) {
+    var _a, _b, _c, _d;
     try {
-      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) {
+      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
+        );
         const depositPaidAmount = paymentItems.filter(
           (item) => item.order_payment_type === "deposit" && item.status !== "voided"
         ).reduce((sum, item) => {
@@ -1974,70 +1884,40 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
           const roundingAmount = new import_decimal.default(item.rounding_amount || "0");
           return sum.add(amount.add(roundingAmount.isNegative() ? roundingAmount.abs() : 0));
         }, new import_decimal.default(0));
-        if (depositPaidAmount.gte(currentOrder.deposit_amount || "0")) {
-          needUpdateDepositStatus = true;
-          currentOrder.is_deposit = 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
+          });
         }
       }
-      const remainingAmount = this.calculateRemainingAmountFromData(currentOrder, paidAmount);
-      const remainingTotalAmount = this.calculateRemainingTotalAmountFromData(currentOrder, paidAmount);
+      const remainingAmount = await this.calculateRemainingAmountAsync();
+      const remainingTotalAmount = await this.calculateRemainingTotalAmountAsync();
       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;
-        hasStateChanged = true;
-        setTimeout(() => {
-          this.core.effects.emit(`${this.name}:onStateAmountChanged`, {
-            oldAmount: currentStateAmount,
-            newAmount: remainingAmount,
-            timestamp: Date.now(),
-            totalAmount: remainingTotalAmount
-          });
-        }, 0);
-        this.logInfo("stateAmount 已自动更新为剩余金额:", {
+        this.core.effects.emit(`${this.name}:onStateAmountChanged`, {
           oldAmount: currentStateAmount,
-          newAmount: remainingAmount
+          newAmount: remainingAmount,
+          timestamp: Date.now(),
+          totalAmount: remainingTotalAmount
         });
-      }
-      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,
+        this.logInfo("stateAmount 已自动更新为剩余金额:", {
+          oldAmount: currentStateAmount,
           newAmount: remainingAmount
         });
-      }
-      console.timeEnd("updateStateAmountToRemaining: updateStateAmountToRemaining");
-      if (!hasStateChanged) {
-        this.logInfo("状态无需更新，当前值已是最新:", {
+      } else {
+        this.logInfo("stateAmount 无需更新，当前值已是最新:", {
           stateAmount: currentStateAmount,
           remainingAmount
         });
       }
+      await this.updateBalanceDueAmount();
       if (checkOrder) {
-        await this.checkOrderPaymentCompletionOptimized(paymentItems, remainingAmount);
+        await this.checkOrderPaymentCompletion();
       } else {
         this.logInfo("外部传入无需 checkOrder，不执行订单支付完成检测和同步");
       }
@@ -2045,81 +1925,10 @@ 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 {
@@ -2176,7 +1985,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
             this.logInfo("所有支付项均为代金券类型，跳过订单同步");
           }
         }
-        await this.core.effects.emit(import_types.CheckoutHooks.OnOrderPaymentCompleted, {
+        await this.core.effects.emit(`${this.name}:onOrderPaymentCompleted`, {
           orderUuid: this.store.currentOrder.uuid,
           orderId: this.store.currentOrder.order_id,
           totalAmount,
@@ -2325,7 +2134,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       }
     }
     const startTime = Date.now();
-    await this.core.effects.emit(import_types.CheckoutHooks.OnOrderSubmitStart, {
+    await this.core.effects.emit(`${this.name}:onOrderSubmitStart`, {
       orderUuid: this.store.currentOrder.uuid,
       operation: isUpdateOperation ? "update" : "create",
       isManual,
@@ -2348,7 +2157,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       submitSuccess = false;
       submitError = error instanceof Error ? error.message : String(error);
       this.logError("下单接口调用失败:", submitError);
-      await this.core.effects.emit(import_types.CheckoutHooks.OnOrderSyncFailed, {
+      await this.core.effects.emit(`${this.name}:onOrderSyncFailed`, {
         orderUuid: this.store.currentOrder.uuid,
         operation: isUpdateOperation ? "update" : "create",
         isManual,
@@ -2359,7 +2168,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       });
       throw error;
     } finally {
-      await this.core.effects.emit(import_types.CheckoutHooks.OnOrderSubmitEnd, {
+      await this.core.effects.emit(`${this.name}:onOrderSubmitEnd`, {
         success: submitSuccess,
         orderUuid: this.store.currentOrder.uuid,
         operation: isUpdateOperation ? "update" : "create",
@@ -2374,7 +2183,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
     const isSuccessResponse = responseStatus === true || responseStatus === 200 || responseStatus === "success" || responseStatus === 1 && (checkoutResponse == null ? void 0 : checkoutResponse.code) === 200;
     if (!isSuccessResponse) {
       const errorMessage = (checkoutResponse == null ? void 0 : checkoutResponse.message) || "订单同步失败，后端返回非成功状态";
-      await this.core.effects.emit(import_types.CheckoutHooks.OnOrderSyncFailed, {
+      await this.core.effects.emit(`${this.name}:onOrderSyncFailed`, {
         orderUuid: this.store.currentOrder.uuid,
         operation: isUpdateOperation ? "update" : "create",
         isManual,
@@ -2458,8 +2267,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, {
+    await this.core.effects.emit(`${this.name}:onOrderSynced`, {
       orderUuid: this.store.currentOrder.uuid,
       realOrderId,
       virtualOrderId: this.store.currentOrder.order_id,
@@ -2526,7 +2334,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
           if (this.store.localOrderData) {
             this.store.localOrderData.shop_note = note;
           }
-          await this.core.effects.emit(import_types.CheckoutHooks.OnOrderNoteChanged, {
+          await this.core.effects.emit(`${this.name}:onOrderNoteChanged`, {
             orderUuid: this.store.currentOrder.uuid,
             oldNote: previousNote,
             newNote: note,
@@ -2674,10 +2482,8 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
    * 重置 store 状态
    *
    * 在创建新订单前调用，确保状态完全干净
-   * 
-   * 🚀 性能优化：改为同步方法，事件发射不阻塞主流程
    */
-  resetStoreState() {
+  async resetStoreStateAsync() {
     try {
       const prevOrderInfo = this.store.currentOrder ? {
         uuid: this.store.currentOrder.uuid,
@@ -2694,15 +2500,12 @@ 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) {
-        setTimeout(() => {
-          this.core.effects.emit(import_types.CheckoutHooks.OnOrderCleared, {
-            previousOrder: prevOrderInfo,
-            timestamp: Date.now()
-          });
-        }, 0);
+        await this.core.effects.emit(`${this.name}:onOrderCleared`, {
+          previousOrder: prevOrderInfo,
+          timestamp: Date.now()
+        });
       }
     } catch (error) {
       console.error("[Checkout] 重置 store 状态失败:", error);