@pisell/pisellos 0.0.234 → 0.0.236

package/lib/solution/Checkout/index.js

@@ -96,6 +96,23 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         await this.handlePaymentError(data);
       }
     });
+    this.core.effects.on(
+      import_types2.PaymentHooks.OnPaymentMethodsLoaded,
+      async (methods) => {
+        console.log("[Checkout] 收到支付方式加载完成事件:", methods.length);
+        this.store.paymentMethods = methods;
+      }
+    );
+    this.core.effects.on(
+      import_types2.PaymentHooks.OnPaymentMethodsChanged,
+      async (data) => {
+        console.log("[Checkout] 收到支付方式变更事件:", {
+          oldCount: data.oldMethods.length,
+          newCount: data.newMethods.length
+        });
+        this.store.paymentMethods = data.newMethods;
+      }
+    );
   }
   /**
    * 初始化结账流程
@@ -160,7 +177,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
   }
   /**
    * 创建本地订单 (前端模拟下单流程)
-   * 
+   *
    * 此方法用于在前端模拟整个下单流程，创建一个本地的虚拟订单。
    * 用户在购物车点击下单时，会把购物车参数传递给此方法，
    * 方法会记录参数并创建本地虚拟订单，然后用 Payment 模块管理支付流程。
@@ -168,6 +185,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
   async createLocalOrderAsync(params) {
     var _a, _b, _c, _d;
     try {
+      await this.resetStoreStateAsync();
       await this.setStatus(import_types.CheckoutStatus.CreatingOrder);
       const validation = await this.validateLocalOrderData(params.orderData);
       if (!validation.valid) {
@@ -233,7 +251,10 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       });
       return paymentOrder;
     } catch (error) {
-      await this.handleError(error, import_types.CheckoutErrorType.OrderCreationFailed);
+      await this.handleError(
+        error,
+        import_types.CheckoutErrorType.OrderCreationFailed
+      );
       await this.core.effects.emit(import_types.CheckoutHooks.OnOrderCreationFailed, {
         error: this.store.lastError,
         timestamp: Date.now()
@@ -243,7 +264,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
   }
   /**
    * 手动下单 (根据虚拟订单生成实际订单)
-   * 
+   *
    * 使用当前存储的本地订单数据调用 Order 模块创建真实订单
    */
   async placeOrderAsync(params = {}) {
@@ -310,7 +331,10 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         errorMessage = error.message;
       }
       console.error("[Checkout] 手动下单失败:", errorMessage);
-      await this.handleError(error, import_types.CheckoutErrorType.OrderCreationFailed);
+      await this.handleError(
+        error,
+        import_types.CheckoutErrorType.OrderCreationFailed
+      );
       return {
         success: false,
         error: errorMessage
@@ -359,7 +383,10 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       console.log("[Checkout] 订单创建成功:", paymentOrder.id);
       return paymentOrder;
     } catch (error) {
-      await this.handleError(error, import_types.CheckoutErrorType.OrderCreationFailed);
+      await this.handleError(
+        error,
+        import_types.CheckoutErrorType.OrderCreationFailed
+      );
       await this.core.effects.emit(import_types.CheckoutHooks.OnOrderCreationFailed, {
         error: this.store.lastError,
         timestamp: Date.now()
@@ -455,6 +482,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         timestamp: Date.now()
       });
       console.log("[Checkout] 结账流程完成:", order.id);
+      await this.resetStoreStateAsync();
       return {
         success: true,
         orderId: String(order.id)
@@ -470,7 +498,9 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
   async cancelCheckoutAsync() {
     try {
       if (this.store.currentOrder) {
-        await this.payment.deletePaymentOrderAsync(this.store.currentOrder.uuid);
+        await this.payment.deletePaymentOrderAsync(
+          this.store.currentOrder.uuid
+        );
         this.store.currentOrder = void 0;
       }
       this.store.localOrderData = void 0;
@@ -508,8 +538,8 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
   async getCheckoutSummaryAsync() {
     var _a, _b;
     const totalAmount = ((_a = this.store.currentOrder) == null ? void 0 : _a.total_amount) || "0.00";
-    const paidAmount = this.calculatePaidAmount();
-    const remainingAmount = this.calculateRemainingAmount();
+    const paidAmount = await this.calculatePaidAmountAsync();
+    const remainingAmount = await this.calculateRemainingAmountAsync();
     return {
       order: this.store.currentOrder,
       totalAmount,
@@ -523,21 +553,26 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
    * 获取可用支付方式
    */
   async getAvailablePaymentMethodsAsync() {
-    if (this.store.paymentMethods.length === 0) {
-      console.log("[Checkout] 支付方式缓存为空，重新加载...");
-      await this.preloadPaymentMethods();
-    }
-    return this.store.paymentMethods;
+    return await this.getPaymentMethodsAsync();
   }
   /**
    * 刷新支付方式缓存
-   * 
+   *
    * 强制重新从服务器获取支付方式列表，更新本地缓存
    */
   async refreshPaymentMethodsAsync() {
     console.log("[Checkout] 强制刷新支付方式缓存...");
-    await this.preloadPaymentMethods();
-    return this.store.paymentMethods;
+    try {
+      const methods = await this.payment.getPayMethodListAsync();
+      this.store.paymentMethods = methods;
+      console.log(
+        `[Checkout] 强制刷新完成，获取到 ${methods.length} 种支付方式`
+      );
+      return methods;
+    } catch (error) {
+      console.error("[Checkout] 强制刷新支付方式失败:", error);
+      return this.store.paymentMethods;
+    }
   }
   /**
    * 获取订单原始数据
@@ -548,7 +583,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
   }
   /**
    * 获取当前订单基础信息
-   * 
+   *
    * 返回当前订单的基础信息，包括订单状态、金额、支付状态等
    */
   getCurrentOrderInfo() {
@@ -593,7 +628,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
   }
   /**
    * 获取当前订单的支付项
-   * 
+   *
    * 返回当前订单的所有支付项，包括活跃和已撤销的支付项
    */
   async getCurrentOrderPaymentItemsAsync() {
@@ -607,7 +642,9 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         orderUuid: currentOrder.uuid,
         orderId: currentOrder.order_id
       });
-      const paymentItems = await this.payment.getPaymentItemsAsync(currentOrder.uuid);
+      const paymentItems = await this.payment.getPaymentItemsAsync(
+        currentOrder.uuid
+      );
       console.log("[Checkout] 成功获取支付项:", {
         orderUuid: currentOrder.uuid,
         paymentItemCount: paymentItems.length,
@@ -662,7 +699,10 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
             }
             break;
           default:
-            console.warn("[Checkout] 无法重试此类型的错误:", this.store.lastError.type);
+            console.warn(
+              "[Checkout] 无法重试此类型的错误:",
+              this.store.lastError.type
+            );
         }
       }
     } catch (error) {
@@ -695,9 +735,9 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
   }
   /**
    * 替换本地订单ID为真实订单ID
-   * 
+   *
    * 当后端订单创建完成后，调用此方法将本地虚拟订单ID替换为真实订单ID
-   * 
+   *
    * @param newOrderId 后端返回的真实订单ID
    * @returns 更新后的订单对象，如果当前没有订单则返回null
    */
@@ -733,9 +773,9 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
   }
   /**
    * 设置自定义支付金额
-   * 
+   *
    * 允许UI自定义本次支付的金额，通常用于部分支付或调整支付金额场景
-   * 
+   *
    * @param amount 自定义支付金额，必须是有效的数字字符串
    */
   async setStateAmountAsync(amount) {
@@ -771,7 +811,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
   }
   /**
    * 获取当前自定义支付金额
-   * 
+   *
    * @returns 当前设置的自定义支付金额
    */
   getStateAmount() {
@@ -779,7 +819,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
   }
   /**
    * 刷新 stateAmount 为当前剩余未支付金额
-   * 
+   *
    * UI 可以调用此方法来主动刷新支付金额状态
    */
   async refreshStateAmountAsync() {
@@ -787,9 +827,9 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
   }
   /**
    * 获取购物车小计数据
-   * 
+   *
    * 返回当前结账流程中的购物车小计项数据，包含各种费用明细
-   * 
+   *
    * @returns 购物车小计数据数组，如果没有则返回 null
    */
   getCartSummary() {
@@ -799,15 +839,19 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
     }
     console.log("[Checkout] 获取购物车小计数据:", {
       itemCount: this.store.cartSummary.length,
-      items: this.store.cartSummary.map((item) => ({ key: item.key, value: item.value, label: item.label }))
+      items: this.store.cartSummary.map((item) => ({
+        key: item.key,
+        value: item.value,
+        label: item.label
+      }))
     });
     return [...this.store.cartSummary];
   }
   /**
    * 获取提取的金额详细信息
-   * 
+   *
    * 从当前的购物车小计数据中提取结构化的金额信息
-   * 
+   *
    * @returns 提取的金额信息对象，如果没有小计数据则返回 null
    */
   getExtractedAmountInfo() {
@@ -815,25 +859,45 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       console.warn("[Checkout] 没有可用的购物车小计数据，无法提取金额信息");
       return null;
     }
-    const extractedInfo = this.extractAmountFromCartSummary(this.store.cartSummary);
+    const extractedInfo = this.extractAmountFromCartSummary(
+      this.store.cartSummary
+    );
     console.log("[Checkout] 获取提取的金额信息:", extractedInfo);
     return extractedInfo;
   }
   /**
    * 获取支付方式列表
-   * 
-   * 直接调用 Payment 模块的 getPayMethodListAsync 方法
-   * 
+   *
+   * 优先使用 store 中的缓存数据，避免重复接口调用。
+   * 如果 store 中没有数据，则调用 Payment 模块的方法获取。
+   *
    * @returns 支付方式列表
    */
   async getPaymentMethodsAsync() {
-    return await this.payment.getPayMethodListAsync();
+    if (this.store.paymentMethods && this.store.paymentMethods.length > 0) {
+      console.log(
+        `[Checkout] 使用缓存的支付方式数据，共 ${this.store.paymentMethods.length} 种`
+      );
+      return this.store.paymentMethods;
+    }
+    console.log("[Checkout] store 中无缓存，从 Payment 模块获取支付方式...");
+    try {
+      const methods = await this.payment.getPayMethodListAsync();
+      this.store.paymentMethods = methods;
+      console.log(
+        `[Checkout] 从 Payment 模块获取到 ${methods.length} 种支付方式，已更新缓存`
+      );
+      return methods;
+    } catch (error) {
+      console.error("[Checkout] 获取支付方式失败:", error);
+      return [];
+    }
   }
   /**
    * 为当前订单添加支付项
-   * 
+   *
    * 向当前活跃订单添加一个支付项，支付项包含支付方式信息和金额
-   * 
+   *
    * @param paymentItem 支付项数据
    * @throws 当前没有活跃订单时抛出错误
    */
@@ -866,45 +930,6 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         当前订单ID: currentOrderId,
         是否为真实ID: isCurrentOrderReal
       });
-      const updatedOrder = await this.payment.getPaymentOrderByUuidAsync(this.store.currentOrder.uuid);
-      if (updatedOrder) {
-        if (isCurrentOrderReal && this.isVirtualOrderId(updatedOrder.order_id)) {
-          console.warn("[Checkout] 检测到订单ID回退，保护真实订单ID:", {
-            当前真实ID: currentOrderId,
-            获取到的虚拟ID: updatedOrder.order_id
-          });
-          updatedOrder.order_id = currentOrderId;
-        }
-        this.store.currentOrder = updatedOrder;
-        console.log("[Checkout] 订单数据已同步:", {
-          支付项数量: updatedOrder.payment.length,
-          最终订单ID: updatedOrder.order_id,
-          是否为虚拟ID: this.isVirtualOrderId(updatedOrder.order_id)
-        });
-      }
-      const needsOrderSync = this.shouldSyncOrderForPayment(paymentItem.code, paymentItem.type);
-      console.log("[Checkout] 支付项同步检查:", {
-        paymentCode: paymentItem.code,
-        paymentType: paymentItem.type,
-        paymentAmount: paymentItem.amount,
-        expectedCashCode: import_types2.PaymentMethodType.Cash,
-        needsOrderSync,
-        isOrderSynced: this.store.isOrderSynced
-      });
-      if (needsOrderSync) {
-        console.log("[Checkout] 检测到非现金/自定义支付，开始同步订单到后端...", {
-          同步前订单ID: this.store.currentOrder.order_id,
-          是否为虚拟ID: this.isVirtualOrderId(this.store.currentOrder.order_id),
-          订单同步状态: this.store.isOrderSynced,
-          订单UUID: this.store.currentOrder.uuid
-        });
-        await this.syncOrderToBackend();
-        console.log("[Checkout] addPaymentItemAsync 中的同步完成:", {
-          同步后订单ID: this.store.currentOrder.order_id,
-          是否为虚拟ID: this.isVirtualOrderId(this.store.currentOrder.order_id),
-          订单同步状态: this.store.isOrderSynced
-        });
-      }
       await this.updateStateAmountToRemaining();
       await this.core.effects.emit(import_types.CheckoutHooks.OnPaymentStarted, {
         orderUuid: this.store.currentOrder.uuid,
@@ -920,9 +945,9 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
   }
   /**
    * 删除当前订单的支付项
-   * 
+   *
    * 从当前活跃订单中删除指定的支付项，支付项将被标记为已撤销状态
-   * 
+   *
    * @param paymentUuid 要删除的支付项UUID
    * @throws 当前没有活跃订单时抛出错误
    * @throws 支付项不存在时抛出错误
@@ -939,7 +964,12 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         orderUuid: this.store.currentOrder.uuid,
         paymentUuid
       });
-      const paymentItem = this.store.currentOrder.payment.find((p) => p.uuid === paymentUuid);
+      const currentPayments = await this.payment.getPaymentItemsAsync(
+        this.store.currentOrder.uuid,
+        true
+        // 包括已撤销的支付项，因为我们需要验证是否存在
+      );
+      const paymentItem = currentPayments.find((p) => p.uuid === paymentUuid);
       if (!paymentItem) {
         throw (0, import_utils.createCheckoutError)(
           import_types.CheckoutErrorType.ValidationFailed,
@@ -959,17 +989,25 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       console.log("[Checkout] Payment模块删除完成");
       const currentOrderId = this.store.currentOrder.order_id;
       const isCurrentOrderReal = currentOrderId && !this.isVirtualOrderId(currentOrderId);
-      const updatedOrder = await this.payment.getPaymentOrderByUuidAsync(this.store.currentOrder.uuid);
+      const updatedOrder = await this.payment.getPaymentOrderByUuidAsync(
+        this.store.currentOrder.uuid
+      );
       if (updatedOrder) {
         if (isCurrentOrderReal && this.isVirtualOrderId(updatedOrder.order_id)) {
-          console.warn("[Checkout] deletePaymentItemAsync: 检测到订单ID回退，保护真实订单ID:", {
-            当前真实ID: currentOrderId,
-            获取到的虚拟ID: updatedOrder.order_id
-          });
+          console.warn(
+            "[Checkout] deletePaymentItemAsync: 检测到订单ID回退，保护真实订单ID:",
+            {
+              当前真实ID: currentOrderId,
+              获取到的虚拟ID: updatedOrder.order_id
+            }
+          );
           updatedOrder.order_id = currentOrderId;
         }
         this.store.currentOrder = updatedOrder;
-        console.log("[Checkout] 订单数据已同步，当前支付项数量:", updatedOrder.payment.length);
+        console.log(
+          "[Checkout] 订单数据已同步，当前支付项数量:",
+          updatedOrder.payment.length
+        );
       }
       await this.updateStateAmountToRemaining();
       await this.core.effects.emit(import_types.CheckoutHooks.OnPaymentStarted, {
@@ -988,10 +1026,10 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
   }
   /**
    * 批量更新当前订单的代金券支付项（覆盖更新）
-   * 
+   *
    * 删除所有现有的代金券支付项，然后添加新的代金券支付项。
    * 这是一个覆盖式更新操作，确保代金券支付项的一致性。
-   * 
+   *
    * @param voucherPaymentItems 新的代金券支付项列表，每个都必须包含 voucher_id
    * @throws 当前没有活跃订单时抛出错误
    * @throws 支付项缺少 voucher_id 时抛出错误
@@ -1024,17 +1062,25 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       console.log("[Checkout] Payment模块批量更新完成");
       const currentOrderId = this.store.currentOrder.order_id;
       const isCurrentOrderReal = currentOrderId && !this.isVirtualOrderId(currentOrderId);
-      const updatedOrder = await this.payment.getPaymentOrderByUuidAsync(this.store.currentOrder.uuid);
+      const updatedOrder = await this.payment.getPaymentOrderByUuidAsync(
+        this.store.currentOrder.uuid
+      );
       if (updatedOrder) {
         if (isCurrentOrderReal && this.isVirtualOrderId(updatedOrder.order_id)) {
-          console.warn("[Checkout] updateVoucherPaymentItemsAsync: 检测到订单ID回退，保护真实订单ID:", {
-            当前真实ID: currentOrderId,
-            获取到的虚拟ID: updatedOrder.order_id
-          });
+          console.warn(
+            "[Checkout] updateVoucherPaymentItemsAsync: 检测到订单ID回退，保护真实订单ID:",
+            {
+              当前真实ID: currentOrderId,
+              获取到的虚拟ID: updatedOrder.order_id
+            }
+          );
           updatedOrder.order_id = currentOrderId;
         }
         this.store.currentOrder = updatedOrder;
-        console.log("[Checkout] 订单数据已同步，当前支付项数量:", updatedOrder.payment.length);
+        console.log(
+          "[Checkout] 订单数据已同步，当前支付项数量:",
+          updatedOrder.payment.length
+        );
         const voucherItems = updatedOrder.payment.filter(
           (payment) => payment.voucher_id && payment.status !== "voided"
         );
@@ -1064,9 +1110,9 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
   }
   /**
    * 修改当前订单的定金状态
-   * 
+   *
    * 更新当前订单的 is_deposit 字段，用于标识订单是否为定金订单
-   * 
+   *
    * @param isDeposit 定金状态 (1: 定金订单, 0: 全款订单)
    * @throws 当前没有活跃订单时抛出错误
    */
@@ -1103,7 +1149,10 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         updateParams.deposit_amount = "0.00";
         console.log("[Checkout] 订单从定金改为全款，清空定金金额");
       }
-      await this.payment.updateOrderAsync(this.store.currentOrder.uuid, updateParams);
+      await this.payment.updateOrderAsync(
+        this.store.currentOrder.uuid,
+        updateParams
+      );
       this.store.currentOrder = {
         ...this.store.currentOrder,
         ...updateParams
@@ -1121,15 +1170,18 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       });
     } catch (error) {
       console.error("[Checkout] 更新订单定金状态失败:", error);
-      await this.handleError(error, import_types.CheckoutErrorType.ValidationFailed);
+      await this.handleError(
+        error,
+        import_types.CheckoutErrorType.ValidationFailed
+      );
       throw error;
     }
   }
   /**
    * 更新当前订单的客户信息
-   * 
+   *
    * 更新当前订单关联的客户信息，用于标识订单的所属客户
-   * 
+   *
    * @param customer 客户信息 (customer_id 和/或 customer_name)
    * @throws 当前没有活跃订单时抛出错误
    */
@@ -1154,57 +1206,74 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         this.store.localOrderData.customer_id = customer.customer_id;
         this.store.localOrderData.customer_name = customer.customer_name;
       }
-      console.log("[Checkout] 订单客户信息更新成功:", this.store.currentCustomer);
+      console.log(
+        "[Checkout] 订单客户信息更新成功:",
+        this.store.currentCustomer
+      );
     } catch (error) {
       console.error("[Checkout] 更新订单客户信息失败:", error);
-      await this.handleError(error, import_types.CheckoutErrorType.ValidationFailed);
+      await this.handleError(
+        error,
+        import_types.CheckoutErrorType.ValidationFailed
+      );
       throw error;
     }
   }
   /**
    * 获取当前订单的客户信息
-   * 
+   *
    * @returns 当前客户信息，如果没有则返回 null
    */
   getCurrentCustomer() {
     return this.store.currentCustomer || null;
   }
   /**
-   * 检查订单是否需要手动同步
-   * 
+   * 检查订单是否需要手动同步（异步版本）
+   *
    * 返回订单是否为纯代金券支付且待付金额<=0但未同步的状态
+   * 从 Payment 模块获取最新的支付项数据
    */
-  needsManualSync() {
-    var _a;
+  async needsManualSyncAsync() {
     try {
       if (!this.store.currentOrder || this.store.isOrderSynced) {
         return false;
       }
-      const remainingAmount = this.calculateRemainingAmount();
+      const remainingAmount = await this.calculateRemainingAmountAsync();
       const remainingValue = parseFloat(remainingAmount);
       if (remainingValue > 0) {
         return false;
       }
-      const allPaymentsHaveVoucherId = this.store.currentOrder.payment && this.store.currentOrder.payment.length > 0 && this.store.currentOrder.payment.every(
+      const currentPayments = await this.payment.getPaymentItemsAsync(
+        this.store.currentOrder.uuid,
+        false
+        // 不包括已撤销的支付项
+      );
+      const allPaymentsHaveVoucherId = currentPayments.length > 0 && currentPayments.every(
         (item) => item.status !== "voided" && item.voucher_id
       );
-      console.log("[Checkout] needsManualSync 检查结果:", {
+      console.log("[Checkout] needsManualSyncAsync 检查结果:", {
         orderUuid: this.store.currentOrder.uuid,
         isOrderSynced: this.store.isOrderSynced,
         remainingAmount,
-        hasPayments: ((_a = this.store.currentOrder.payment) == null ? void 0 : _a.length) > 0,
+        hasPayments: currentPayments.length > 0,
         allPaymentsHaveVoucherId,
-        needsManualSync: allPaymentsHaveVoucherId
+        needsManualSync: allPaymentsHaveVoucherId,
+        paymentItems: currentPayments.map((p) => ({
+          code: p.code,
+          amount: p.amount,
+          status: p.status,
+          hasVoucherId: !!p.voucher_id
+        }))
       });
       return allPaymentsHaveVoucherId;
     } catch (error) {
-      console.error("[Checkout] needsManualSync 检查失败:", error);
+      console.error("[Checkout] needsManualSyncAsync 检查失败:", error);
       return false;
     }
   }
   /**
    * 手动同步订单到后端
-   * 
+   *
    * 用于强制同步订单到后端，特别适用于纯代金券支付完成的订单
    */
   async manualSyncOrderAsync() {
@@ -1225,7 +1294,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         orderUuid,
         orderId: oldOrderId,
         totalAmount: this.store.currentOrder.total_amount,
-        remainingAmount: this.calculateRemainingAmount()
+        remainingAmount: await this.calculateRemainingAmountAsync()
       });
       const realOrderId = await this.syncOrderToBackendWithReturn(true);
       console.log("[Checkout] 手动同步订单完成:", {
@@ -1247,7 +1316,9 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         console.error("[Checkout] 严重警告：手动同步完成后订单ID仍为虚拟ID！");
       }
       if (realOrderId !== finalOrderId) {
-        console.error("[Checkout] 严重警告：返回的订单ID与存储的订单ID不一致！");
+        console.error(
+          "[Checkout] 严重警告：返回的订单ID与存储的订单ID不一致！"
+        );
       }
       return {
         success: true,
@@ -1268,7 +1339,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
   }
   /**
    * 获取当前订单备注
-   * 
+   *
    * @returns 当前订单的备注内容，如果没有则返回空字符串
    */
   getOrderNote() {
@@ -1280,7 +1351,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
   }
   /**
    * 获取当前订单ID
-   * 
+   *
    * @returns 当前订单的ID，如果没有订单则返回null
    */
   getCurrentOrderId() {
@@ -1289,9 +1360,109 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
     }
     return this.store.currentOrder.order_id;
   }
+  /**
+   * 获取当前订单是否已同步到后端
+   *
+   * @returns 当前订单是否已同步状态，如果没有订单则返回false
+   */
+  isCurrentOrderSynced() {
+    if (!this.store.currentOrder) {
+      console.log("[Checkout] 没有当前订单，同步状态为false");
+      return false;
+    }
+    const syncStatus = this.store.isOrderSynced;
+    console.log("[Checkout] 当前订单同步状态:", {
+      orderUuid: this.store.currentOrder.uuid,
+      orderId: this.store.currentOrder.order_id,
+      isOrderSynced: syncStatus
+    });
+    return syncStatus;
+  }
+  /**
+   * 取消当前本地订单
+   *
+   * 只能取消未同步到后端的本地订单，如果订单已同步则不能取消
+   *
+   * @param cancelReason 取消原因（可选）
+   * @returns 取消结果
+   */
+  async cancelCurrentOrderAsync(cancelReason) {
+    var _a, _b;
+    try {
+      console.log("[Checkout] 开始取消当前本地订单:", {
+        hasCurrentOrder: !!this.store.currentOrder,
+        orderUuid: (_a = this.store.currentOrder) == null ? void 0 : _a.uuid,
+        orderId: (_b = this.store.currentOrder) == null ? void 0 : _b.order_id,
+        isOrderSynced: this.store.isOrderSynced,
+        cancelReason
+      });
+      if (!this.store.currentOrder) {
+        console.log("[Checkout] 没有当前订单，无需取消");
+        return {
+          success: false,
+          message: "没有当前订单可取消"
+        };
+      }
+      const currentOrderUuid = this.store.currentOrder.uuid;
+      const currentOrderId = this.store.currentOrder.order_id;
+      const isOrderSynced = this.store.isOrderSynced;
+      if (isOrderSynced) {
+        console.log("[Checkout] 订单已同步到后端，不能取消:", {
+          orderId: currentOrderId,
+          orderUuid: currentOrderUuid
+        });
+        return {
+          success: false,
+          message: "订单已同步到后端，无法取消",
+          orderId: currentOrderId
+        };
+      }
+      console.log("[Checkout] 订单尚未同步，可以取消");
+      try {
+        console.log("[Checkout] 删除本地订单数据");
+        await this.payment.deletePaymentOrderAsync(currentOrderUuid);
+        console.log("[Checkout] 本地订单数据删除成功");
+      } catch (error) {
+        console.warn("[Checkout] 删除本地订单数据失败，但继续执行:", error);
+      }
+      console.log("[Checkout] 清理订单相关状态");
+      this.store.currentOrder = void 0;
+      this.store.localOrderData = void 0;
+      this.store.stateAmount = "0.00";
+      this.store.isOrderSynced = false;
+      this.store.currentCustomer = void 0;
+      this.payment.wallet.clearAllCache();
+      console.log("[Checkout] 订单状态清理完成，currentOrder已释放");
+      await this.core.effects.emit(import_types.CheckoutHooks.OnOrderCancelled, {
+        orderUuid: currentOrderUuid,
+        orderId: currentOrderId,
+        cancelReason,
+        wasSynced: false,
+        // 只有未同步订单可以被取消
+        timestamp: Date.now()
+      });
+      console.log("[Checkout] 本地订单取消完成:", {
+        orderUuid: currentOrderUuid,
+        orderId: currentOrderId,
+        cancelReason
+      });
+      return {
+        success: true,
+        message: "本地订单已成功取消",
+        orderId: currentOrderId
+      };
+    } catch (error) {
+      console.error("[Checkout] 取消本地订单失败:", error);
+      const errorMessage = error instanceof Error ? error.message : "未知错误";
+      return {
+        success: false,
+        message: `取消订单失败: ${errorMessage}`
+      };
+    }
+  }
   /**
    * 保存订单并稍后支付
-   * 
+   *
    * 将当前订单保存到后端，但排除代金券类支付项(voucher_id)，
    * 适用于用户想要保存订单但稍后完成支付的场景
    */
@@ -1311,7 +1482,9 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         orderId: currentOrderId,
         totalAmount: this.store.currentOrder.total_amount
       });
-      const allPaymentItems = await this.payment.getPaymentItemsAsync(this.store.currentOrder.uuid);
+      const allPaymentItems = await this.payment.getPaymentItemsAsync(
+        this.store.currentOrder.uuid
+      );
       const filteredPaymentItems = allPaymentItems.filter(
         (payment) => !payment.voucher_id || payment.voucher_id.trim() === ""
       );
@@ -1334,7 +1507,10 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
           amount: item.amount
         }))
       });
-      const realOrderId = await this.syncOrderToBackendWithReturn(false, filteredPaymentItems);
+      const realOrderId = await this.syncOrderToBackendWithReturn(
+        false,
+        filteredPaymentItems
+      );
       console.log("[Checkout] 保存订单完成:", {
         orderUuid,
         oldOrderId: currentOrderId,
@@ -1367,7 +1543,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
   }
   /**
    * 获取当前商店折扣金额
-   * 
+   *
    * @returns 当前的商店折扣金额，如果没有则返回0
    */
   getShopDiscount() {
@@ -1376,7 +1552,9 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       return this.store.localOrderData.shop_discount;
     }
     if (this.store.cartSummary) {
-      const shopDiscountItem = this.store.cartSummary.find((item) => item.key === "shop_discount");
+      const shopDiscountItem = this.store.cartSummary.find(
+        (item) => item.key === "shop_discount"
+      );
       if (shopDiscountItem) {
         return shopDiscountItem.value;
       }
@@ -1385,9 +1563,9 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
   }
   /**
    * 更新订单商店折扣
-   * 
+   *
    * 同时更新cartSummary和localOrderData中的shop_discount值
-   * 
+   *
    * @param discountAmount 商店折扣金额
    */
   async updateShopDiscountAsync(discountAmount) {
@@ -1400,7 +1578,9 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         newDiscount: discountAmount
       });
       if (this.store.cartSummary) {
-        const shopDiscountItem = this.store.cartSummary.find((item) => item.key === "shop_discount");
+        const shopDiscountItem = this.store.cartSummary.find(
+          (item) => item.key === "shop_discount"
+        );
         if (shopDiscountItem) {
           shopDiscountItem.value = discountAmount;
           console.log("[Checkout] cartSummary 中的商店折扣已更新");
@@ -1421,7 +1601,9 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         console.warn("[Checkout] localOrderData 不存在，无法更新商店折扣");
       }
       if (this.store.currentOrder && this.store.cartSummary) {
-        const updatedAmountInfo = this.extractAmountFromCartSummary(this.store.cartSummary);
+        const updatedAmountInfo = this.extractAmountFromCartSummary(
+          this.store.cartSummary
+        );
         console.log("[Checkout] 重新计算订单金额:", updatedAmountInfo);
         this.store.currentOrder.total_amount = updatedAmountInfo.totalAmount;
         this.store.currentOrder.expect_amount = updatedAmountInfo.totalAmount;
@@ -1439,13 +1621,16 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       });
     } catch (error) {
       console.error("[Checkout] 更新商店折扣失败:", error);
-      await this.handleError(error, import_types.CheckoutErrorType.ValidationFailed);
+      await this.handleError(
+        error,
+        import_types.CheckoutErrorType.ValidationFailed
+      );
       throw error;
     }
   }
   /**
    * 更新订单备注
-   * 
+   *
    * @param note 订单备注内容
    */
   async updateOrderNoteAsync(note) {
@@ -1466,12 +1651,17 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       this.store.localOrderData.shop_note = note;
       if (this.store.currentOrder) {
         try {
-          const orderInPayment = await this.payment.getPaymentOrderByUuidAsync(this.store.currentOrder.uuid);
+          const orderInPayment = await this.payment.getPaymentOrderByUuidAsync(
+            this.store.currentOrder.uuid
+          );
           if (orderInPayment && orderInPayment.note !== void 0) {
             console.log("[Checkout] 同步备注到Payment模块的订单数据中");
           }
         } catch (syncError) {
-          console.warn("[Checkout] 同步备注到Payment模块失败，但本地更新成功:", syncError);
+          console.warn(
+            "[Checkout] 同步备注到Payment模块失败，但本地更新成功:",
+            syncError
+          );
         }
       }
       await this.core.effects.emit(import_types.CheckoutHooks.OnOrderNoteChanged, {
@@ -1486,7 +1676,10 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       });
     } catch (error) {
       console.error("[Checkout] 更新订单备注失败:", error);
-      await this.handleError(error, import_types.CheckoutErrorType.ValidationFailed);
+      await this.handleError(
+        error,
+        import_types.CheckoutErrorType.ValidationFailed
+      );
       throw error;
     }
   }
@@ -1552,7 +1745,10 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       import_types.CheckoutErrorType.PaymentFailed,
       data.error || "支付同步失败"
     );
-    await this.handleError(error instanceof Error ? error : new Error(String(error)), import_types.CheckoutErrorType.PaymentFailed);
+    await this.handleError(
+      error instanceof Error ? error : new Error(String(error)),
+      import_types.CheckoutErrorType.PaymentFailed
+    );
     await this.core.effects.emit(import_types.CheckoutHooks.OnPaymentFailed, {
       orderUuid: data.orderUuid,
       paymentMethodCode: "",
@@ -1570,6 +1766,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
    * 验证本地订单数据
    */
   async validateLocalOrderData(orderData) {
+    var _a;
     const errors = [];
     if (!orderData.type) {
       errors.push("订单类型不能为空");
@@ -1577,7 +1774,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
     if (!orderData.platform) {
       errors.push("平台信息不能为空");
     }
-    if (!orderData.bookings || orderData.bookings.length === 0) {
+    if ((!orderData.bookings || orderData.bookings.length === 0) && !((_a = orderData == null ? void 0 : orderData.relation_products) == null ? void 0 : _a.length)) {
       errors.push("预订信息不能为空");
     }
     if (orderData.bookings) {
@@ -1608,7 +1805,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
   }
   /**
    * 格式化日期时间为 YYYY-MM-DD hh:mm:ss 格式
-   * 
+   *
    * @param date 要格式化的日期对象
    * @returns 格式化后的日期时间字符串
    */
@@ -1700,45 +1897,54 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
     return total.toFixed(2);
   }
   /**
-   * 计算已支付金额
+   * 计算已支付金额（从 Payment 模块获取最新数据）
    */
-  calculatePaidAmount() {
+  async calculatePaidAmountAsync() {
     if (!this.store.currentOrder) {
-      console.log("[Checkout] calculatePaidAmount: 没有当前订单");
+      console.log("[Checkout] calculatePaidAmountAsync: 没有当前订单");
+      return "0.00";
+    }
+    try {
+      const payments = await this.payment.getPaymentItemsAsync(
+        this.store.currentOrder.uuid,
+        false
+        // 不包括已撤销的支付项
+      );
+      console.log("[Checkout] calculatePaidAmountAsync: 支付项详情:", {
+        paymentCount: payments.length,
+        payments: payments.map((p) => ({
+          uuid: p.uuid,
+          amount: p.amount,
+          code: p.code,
+          status: p.status
+        }))
+      });
+      const paidAmount = payments.filter((payment) => payment.status !== "voided").reduce((sum, payment) => {
+        const amount = parseFloat(payment.amount || "0");
+        console.log(`[Checkout] 计算支付项: ${payment.code} = ${amount}`);
+        return sum + amount;
+      }, 0);
+      const result = paidAmount.toFixed(2);
+      console.log("[Checkout] calculatePaidAmountAsync: 计算结果 =", result);
+      return result;
+    } catch (error) {
+      console.error("[Checkout] calculatePaidAmountAsync 失败:", error);
       return "0.00";
     }
-    const payments = this.store.currentOrder.payment || [];
-    console.log("[Checkout] calculatePaidAmount: 支付项详情:", {
-      paymentCount: payments.length,
-      payments: payments.map((p) => ({
-        uuid: p.uuid,
-        amount: p.amount,
-        code: p.code,
-        status: p.status
-      }))
-    });
-    const paidAmount = payments.filter((payment) => payment.status !== "voided").reduce((sum, payment) => {
-      const amount = parseFloat(payment.amount || "0");
-      console.log(`[Checkout] 计算支付项: ${payment.code} = ${amount}`);
-      return sum + amount;
-    }, 0);
-    const result = paidAmount.toFixed(2);
-    console.log("[Checkout] calculatePaidAmount: 计算结果 =", result);
-    return result;
   }
   /**
-   * 计算剩余未支付金额
+   * 计算剩余未支付金额（从 Payment 模块获取最新数据）
    */
-  calculateRemainingAmount() {
+  async calculateRemainingAmountAsync() {
     if (!this.store.currentOrder) {
-      console.log("[Checkout] calculateRemainingAmount: 没有当前订单");
+      console.log("[Checkout] calculateRemainingAmountAsync: 没有当前订单");
       return "0.00";
     }
     const totalAmount = parseFloat(this.store.currentOrder.total_amount || "0");
-    const paidAmount = parseFloat(this.calculatePaidAmount());
+    const paidAmount = parseFloat(await this.calculatePaidAmountAsync());
     const remainingAmount = totalAmount - paidAmount;
     const result = Math.max(0, remainingAmount).toFixed(2);
-    console.log("[Checkout] calculateRemainingAmount: 计算详情:", {
+    console.log("[Checkout] calculateRemainingAmountAsync: 计算详情:", {
       orderUuid: this.store.currentOrder.uuid,
       totalAmount: totalAmount.toFixed(2),
       paidAmount: paidAmount.toFixed(2),
@@ -1753,7 +1959,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
   async updateStateAmountToRemaining() {
     var _a;
     try {
-      const remainingAmount = this.calculateRemainingAmount();
+      const remainingAmount = await this.calculateRemainingAmountAsync();
       const currentStateAmount = this.store.stateAmount;
       console.log("[Checkout] updateStateAmountToRemaining: 状态检查:", {
         calculatedRemainingAmount: remainingAmount,
@@ -1785,20 +1991,19 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
   }
   /**
    * 检查订单支付是否完成
-   * 
+   *
    * 当剩余待付款金额 <= 0 时，触发订单支付完成事件
    */
   async checkOrderPaymentCompletion() {
-    var _a, _b;
     try {
       if (!this.store.currentOrder) {
         return;
       }
-      const remainingAmount = this.calculateRemainingAmount();
+      const remainingAmount = await this.calculateRemainingAmountAsync();
       const remainingValue = parseFloat(remainingAmount);
       if (remainingValue <= 0) {
         const totalAmount = this.store.currentOrder.total_amount;
-        const paidAmount = this.calculatePaidAmount();
+        const paidAmount = await this.calculatePaidAmountAsync();
         console.log("[Checkout] 检测到订单支付完成:", {
           orderUuid: this.store.currentOrder.uuid,
           orderId: this.store.currentOrder.order_id,
@@ -1807,13 +2012,18 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
           remainingAmount,
           isOrderSynced: this.store.isOrderSynced
         });
-        const allPaymentsHaveVoucherId = this.store.currentOrder.payment && this.store.currentOrder.payment.length > 0 && this.store.currentOrder.payment.every(
+        const currentPayments = await this.payment.getPaymentItemsAsync(
+          this.store.currentOrder.uuid,
+          false
+          // 不包括已撤销的支付项
+        );
+        const allPaymentsHaveVoucherId = currentPayments.length > 0 && currentPayments.every(
           (item) => item.status !== "voided" && item.voucher_id
         );
         console.log("[Checkout] 支付项voucher_id检查:", {
-          paymentCount: ((_a = this.store.currentOrder.payment) == null ? void 0 : _a.length) || 0,
+          paymentCount: currentPayments.length,
           allHaveVoucherId: allPaymentsHaveVoucherId,
-          paymentItems: (_b = this.store.currentOrder.payment) == null ? void 0 : _b.map((p) => ({
+          paymentItems: currentPayments.map((p) => ({
             uuid: p.uuid,
             code: p.code,
             amount: p.amount,
@@ -1821,13 +2031,11 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
             status: p.status
           }))
         });
-        if (!this.store.isOrderSynced) {
-          if (allPaymentsHaveVoucherId) {
-            console.log("[Checkout] 所有支付项均为代金券类型，跳过订单同步");
-          } else {
-            console.log("[Checkout] 支付完成但订单未同步，开始同步订单到后端...");
-            await this.syncOrderToBackend();
-          }
+        if (allPaymentsHaveVoucherId) {
+          console.log("[Checkout] 所有支付项均为代金券类型，跳过订单同步");
+        } else {
+          console.log("[Checkout] 支付完成但订单未同步，开始同步订单到后端...");
+          await this.syncOrderToBackend();
         }
         await this.core.effects.emit(import_types.CheckoutHooks.OnOrderPaymentCompleted, {
           orderUuid: this.store.currentOrder.uuid,
@@ -1844,18 +2052,20 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
   }
   /**
    * 判断支付方式是否需要同步订单到后端
-   * 
+   *
    * 现金支付(CASHMANUAL)和自定义支付不需要同步，其他支付方式需要同步
-   * 
+   *
    * @param paymentCode 支付方式代码
-   * @param paymentType 支付方式类型 
+   * @param paymentType 支付方式类型
    * @returns 是否需要同步订单
    */
   shouldSyncOrderForPayment(paymentCode, paymentType) {
     const codeUpper = (paymentCode == null ? void 0 : paymentCode.toUpperCase()) || "";
     const typeUpper = (paymentType == null ? void 0 : paymentType.toUpperCase()) || "";
     const cashIdentifiers = ["CASHMANUAL", "CASH", "MANUAL"];
-    if (cashIdentifiers.some((id) => codeUpper.includes(id) || typeUpper.includes(id))) {
+    if (cashIdentifiers.some(
+      (id) => codeUpper.includes(id) || typeUpper.includes(id)
+    )) {
       return false;
     }
     if (paymentCode === import_types2.PaymentMethodType.Cash || paymentType === import_types2.PaymentMethodType.Cash) {
@@ -1868,12 +2078,12 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
   }
   /**
    * 同步订单到后端
-   * 
+   *
    * 调用后端 /order/checkout 接口创建真实订单
    */
   /**
    * 判断订单ID是否为本地生成的虚拟ID
-   * 
+   *
    * @param orderId 订单ID
    * @returns true 表示是虚拟ID，false 表示是真实的后端ID
    */
@@ -1882,7 +2092,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
   }
   /**
    * 同步订单到后端并返回真实订单ID
-   * 
+   *
    * @param isManual 是否为手动同步，默认为 false
    * @param customPaymentItems 自定义支付项列表，如果提供则使用此列表而不是从数据库获取
    * @returns 后端返回的真实订单ID
@@ -1964,18 +2174,23 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       // surcharge_fee: this.otherParams.surcharge_fee,
       // surcharges: ,
       note: this.store.localOrderData.shop_note
-      // deposit_amount: 
+      // deposit_amount:
     };
     if (isUpdateOperation) {
       if (this.isVirtualOrderId(currentOrderId)) {
-        console.error("[Checkout] 数据不一致警告：更新操作但订单ID仍为虚拟ID!", {
-          currentOrderId,
-          isOrderSynced: this.store.isOrderSynced,
-          reason,
-          orderUuid: this.store.currentOrder.uuid
-        });
+        console.error(
+          "[Checkout] 数据不一致警告：更新操作但订单ID仍为虚拟ID!",
+          {
+            currentOrderId,
+            isOrderSynced: this.store.isOrderSynced,
+            reason,
+            orderUuid: this.store.currentOrder.uuid
+          }
+        );
         console.log("[Checkout] 尝试数据修复：暂时不包含order_id，让后端处理");
-        console.log("[Checkout] 注意：这次调用将作为创建操作处理，但后续会修复数据一致性");
+        console.log(
+          "[Checkout] 注意：这次调用将作为创建操作处理，但后续会修复数据一致性"
+        );
       } else {
         orderParams.order_id = currentOrderId;
         console.log(`[Checkout] 更新订单操作，包含订单ID: ${currentOrderId}`);
@@ -2029,9 +2244,14 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
             totalAmount: updatedOrder.total_amount
           });
           this.store.currentOrder = updatedOrder;
-          console.log("[Checkout] 订单ID替换成功，当前订单ID:", this.store.currentOrder.order_id);
+          console.log(
+            "[Checkout] 订单ID替换成功，当前订单ID:",
+            this.store.currentOrder.order_id
+          );
         } else {
-          console.error("[Checkout] Payment模块返回空订单，订单ID替换失败，开始手动替换");
+          console.error(
+            "[Checkout] Payment模块返回空订单，订单ID替换失败，开始手动替换"
+          );
           const beforeManualUpdate = this.store.currentOrder.order_id;
           this.store.currentOrder.order_id = realOrderId;
           console.log("[Checkout] 手动设置订单ID:", {
@@ -2064,7 +2284,9 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       是否同步: this.store.isOrderSynced
     });
     if (finalIsVirtual && !isUpdateOperation) {
-      console.warn("[Checkout] 警告：订单创建后，当前订单ID仍然是虚拟ID，可能存在问题");
+      console.warn(
+        "[Checkout] 警告：订单创建后，当前订单ID仍然是虚拟ID，可能存在问题"
+      );
     }
     return realOrderId;
   }
@@ -2074,7 +2296,9 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
     } catch (error) {
       console.error("[Checkout] 同步订单到后端失败:", error);
       await this.handleError(
-        new Error(`订单同步失败: ${error instanceof Error ? error.message : String(error)}`),
+        new Error(
+          `订单同步失败: ${error instanceof Error ? error.message : String(error)}`
+        ),
         import_types.CheckoutErrorType.OrderCreationFailed
       );
     }
@@ -2116,9 +2340,9 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
   }
   /**
    * 通过订单ID编辑订单备注
-   * 
+   *
    * 用于修改已同步到后端的订单备注，通常在支付成功后的弹窗中使用
-   * 
+   *
    * @param orderId 后端订单ID
    * @param note 新的订单备注
    * @returns 修改结果
@@ -2137,9 +2361,12 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
           orderId
         };
       }
-      const response = await this.request.put(`/shop/order/order/${orderId}/note`, {
-        note
-      });
+      const response = await this.request.put(
+        `/shop/order/order/${orderId}/note`,
+        {
+          note
+        }
+      );
       console.log("[Checkout] 订单备注编辑响应:", {
         orderId,
         status: response.status,
@@ -2185,6 +2412,100 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       };
     }
   }
+  /**
+   * 发送客户支付链接邮件
+   *
+   * 向指定邮箱发送订单支付提醒邮件
+   *
+   * @param params 发送参数
+   * @returns 发送结果
+   */
+  async sendCustomerPayLinkAsync(params) {
+    try {
+      console.log("[Checkout] 开始发送客户支付链接邮件:", {
+        orderIds: params.order_ids,
+        emails: params.emails,
+        notifyAction: params.notify_action || "order_payment_reminder"
+      });
+      if (!params.order_ids || params.order_ids.length === 0) {
+        return {
+          success: false,
+          message: "订单ID列表不能为空"
+        };
+      }
+      if (!params.emails || params.emails.length === 0) {
+        return {
+          success: false,
+          message: "邮箱地址列表不能为空"
+        };
+      }
+      const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+      const invalidEmails = params.emails.filter(
+        (email) => !emailRegex.test(email)
+      );
+      if (invalidEmails.length > 0) {
+        return {
+          success: false,
+          message: `邮箱格式无效: ${invalidEmails.join(", ")}`
+        };
+      }
+      const requestBody = {
+        order_ids: params.order_ids,
+        notify_action: params.notify_action || "order_payment_reminder",
+        emails: params.emails
+      };
+      console.log("[Checkout] 发送支付链接邮件请求参数:", requestBody);
+      const response = await this.request.post(
+        "/order/batch-email",
+        requestBody
+      );
+      console.log("[Checkout] 支付链接邮件发送响应:", {
+        status: response.status,
+        message: response.message,
+        data: response.data,
+        response
+      });
+      if (response.status === true || response.status === 200) {
+        console.log("[Checkout] 支付链接邮件发送成功");
+        return {
+          success: true,
+          message: response.message || "支付链接邮件发送成功"
+        };
+      } else {
+        const errorMessage = response.message || "支付链接邮件发送失败";
+        console.error("[Checkout] 支付链接邮件发送失败:", errorMessage);
+        return {
+          success: false,
+          message: errorMessage
+        };
+      }
+    } catch (error) {
+      console.error("[Checkout] 发送客户支付链接邮件失败:", error);
+      const errorMessage = error instanceof Error ? error.message : "网络错误或服务器异常";
+      return {
+        success: false,
+        message: `发送支付链接邮件失败: ${errorMessage}`
+      };
+    }
+  }
+  /**
+   * 金额舍入
+   *
+   * @param amount 原始金额
+   * @returns 舍入结果详情，包含原始金额、舍入后金额和舍入差额
+   */
+  async roundAmountAsync(amount) {
+    var _a, _b;
+    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
+    );
+    console.log(
+      `[Checkout] 金额舍入完成 - 原始: ${result.originalAmount}, 舍入后: ${result.roundedAmount}, 差额: ${result.roundingDifference}`
+    );
+    return result;
+  }
   async destroy() {
     var _a, _b, _c, _d;
     this.payment.wallet.clearAllCache();
@@ -2194,6 +2515,67 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
     this.core.unregisterModule(this);
     console.log("[Checkout] 已销毁");
   }
+  /**
+   * 重置 store 状态
+   *
+   * 在创建新订单前调用，确保状态完全干净
+   */
+  async resetStoreStateAsync() {
+    try {
+      const prevOrderInfo = this.store.currentOrder ? {
+        uuid: this.store.currentOrder.uuid,
+        orderId: this.store.currentOrder.order_id
+      } : null;
+      console.log("[Checkout] 重置 store 状态，准备创建新订单", prevOrderInfo);
+      this.store.currentOrder = void 0;
+      this.store.localOrderData = void 0;
+      this.store.cartSummary = void 0;
+      this.store.stateAmount = "0.00";
+      this.store.isOrderSynced = false;
+      this.store.currentCustomer = void 0;
+      this.store.lastError = void 0;
+      this.store.cartItems = [];
+      await this.setStatus(import_types.CheckoutStatus.Ready);
+      await this.setStep(import_types.CheckoutStep.OrderConfirmation);
+      this.payment.wallet.clearAllCache();
+      console.log("[Checkout] Store 状态重置完成");
+      if (prevOrderInfo) {
+        await this.core.effects.emit(import_types.CheckoutHooks.OnOrderCleared, {
+          previousOrder: prevOrderInfo,
+          timestamp: Date.now()
+        });
+      }
+    } catch (error) {
+      console.error("[Checkout] 重置 store 状态失败:", error);
+    }
+  }
+  /**
+   * 手动清理已完成的订单状态（公开方法）
+   *
+   * 供UI层调用的公开方法，用于手动清理订单状态
+   *
+   * @returns 清理结果
+   */
+  async clearCompletedOrderAsync() {
+    try {
+      const prevOrderInfo = this.store.currentOrder ? {
+        uuid: this.store.currentOrder.uuid,
+        orderId: this.store.currentOrder.order_id
+      } : null;
+      await this.resetStoreStateAsync();
+      return {
+        success: true,
+        message: prevOrderInfo ? "订单状态已成功清理" : "没有需要清理的订单状态",
+        clearedOrder: prevOrderInfo
+      };
+    } catch (error) {
+      console.error("[Checkout] 手动清理订单状态失败:", error);
+      return {
+        success: false,
+        message: error instanceof Error ? error.message : "清理失败"
+      };
+    }
+  }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {