@pisell/pisellos 0.0.235 → 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;
@@ -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 当前没有活跃订单时抛出错误
    */
@@ -881,9 +945,9 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
   }
   /**
    * 删除当前订单的支付项
-   * 
+   *
    * 从当前活跃订单中删除指定的支付项，支付项将被标记为已撤销状态
-   * 
+   *
    * @param paymentUuid 要删除的支付项UUID
    * @throws 当前没有活跃订单时抛出错误
    * @throws 支付项不存在时抛出错误
@@ -925,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, {
@@ -954,10 +1026,10 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
   }
   /**
    * 批量更新当前订单的代金券支付项（覆盖更新）
-   * 
+   *
    * 删除所有现有的代金券支付项，然后添加新的代金券支付项。
    * 这是一个覆盖式更新操作，确保代金券支付项的一致性。
-   * 
+   *
    * @param voucherPaymentItems 新的代金券支付项列表，每个都必须包含 voucher_id
    * @throws 当前没有活跃订单时抛出错误
    * @throws 支付项缺少 voucher_id 时抛出错误
@@ -990,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"
         );
@@ -1030,9 +1110,9 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
   }
   /**
    * 修改当前订单的定金状态
-   * 
+   *
    * 更新当前订单的 is_deposit 字段，用于标识订单是否为定金订单
-   * 
+   *
    * @param isDeposit 定金状态 (1: 定金订单, 0: 全款订单)
    * @throws 当前没有活跃订单时抛出错误
    */
@@ -1069,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
@@ -1087,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 当前没有活跃订单时抛出错误
    */
@@ -1120,16 +1206,22 @@ 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() {
@@ -1137,7 +1229,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
   }
   /**
    * 检查订单是否需要手动同步（异步版本）
-   * 
+   *
    * 返回订单是否为纯代金券支付且待付金额<=0但未同步的状态
    * 从 Payment 模块获取最新的支付项数据
    */
@@ -1181,7 +1273,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
   }
   /**
    * 手动同步订单到后端
-   * 
+   *
    * 用于强制同步订单到后端，特别适用于纯代金券支付完成的订单
    */
   async manualSyncOrderAsync() {
@@ -1224,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,
@@ -1245,7 +1339,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
   }
   /**
    * 获取当前订单备注
-   * 
+   *
    * @returns 当前订单的备注内容，如果没有则返回空字符串
    */
   getOrderNote() {
@@ -1257,7 +1351,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
   }
   /**
    * 获取当前订单ID
-   * 
+   *
    * @returns 当前订单的ID，如果没有订单则返回null
    */
   getCurrentOrderId() {
@@ -1268,7 +1362,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
   }
   /**
    * 获取当前订单是否已同步到后端
-   * 
+   *
    * @returns 当前订单是否已同步状态，如果没有订单则返回false
    */
   isCurrentOrderSynced() {
@@ -1286,9 +1380,9 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
   }
   /**
    * 取消当前本地订单
-   * 
+   *
    * 只能取消未同步到后端的本地订单，如果订单已同步则不能取消
-   * 
+   *
    * @param cancelReason 取消原因（可选）
    * @returns 取消结果
    */
@@ -1368,7 +1462,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
   }
   /**
    * 保存订单并稍后支付
-   * 
+   *
    * 将当前订单保存到后端，但排除代金券类支付项(voucher_id)，
    * 适用于用户想要保存订单但稍后完成支付的场景
    */
@@ -1388,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() === ""
       );
@@ -1411,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,
@@ -1444,7 +1543,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
   }
   /**
    * 获取当前商店折扣金额
-   * 
+   *
    * @returns 当前的商店折扣金额，如果没有则返回0
    */
   getShopDiscount() {
@@ -1453,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;
       }
@@ -1462,9 +1563,9 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
   }
   /**
    * 更新订单商店折扣
-   * 
+   *
    * 同时更新cartSummary和localOrderData中的shop_discount值
-   * 
+   *
    * @param discountAmount 商店折扣金额
    */
   async updateShopDiscountAsync(discountAmount) {
@@ -1477,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 中的商店折扣已更新");
@@ -1498,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;
@@ -1516,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) {
@@ -1543,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, {
@@ -1563,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;
     }
   }
@@ -1629,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: "",
@@ -1647,6 +1766,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
    * 验证本地订单数据
    */
   async validateLocalOrderData(orderData) {
+    var _a;
     const errors = [];
     if (!orderData.type) {
       errors.push("订单类型不能为空");
@@ -1654,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) {
@@ -1685,7 +1805,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
   }
   /**
    * 格式化日期时间为 YYYY-MM-DD hh:mm:ss 格式
-   * 
+   *
    * @param date 要格式化的日期对象
    * @returns 格式化后的日期时间字符串
    */
@@ -1871,7 +1991,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
   }
   /**
    * 检查订单支付是否完成
-   * 
+   *
    * 当剩余待付款金额 <= 0 时，触发订单支付完成事件
    */
   async checkOrderPaymentCompletion() {
@@ -1932,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) {
@@ -1956,12 +2078,12 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
   }
   /**
    * 同步订单到后端
-   * 
+   *
    * 调用后端 /order/checkout 接口创建真实订单
    */
   /**
    * 判断订单ID是否为本地生成的虚拟ID
-   * 
+   *
    * @param orderId 订单ID
    * @returns true 表示是虚拟ID，false 表示是真实的后端ID
    */
@@ -1970,7 +2092,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
   }
   /**
    * 同步订单到后端并返回真实订单ID
-   * 
+   *
    * @param isManual 是否为手动同步，默认为 false
    * @param customPaymentItems 自定义支付项列表，如果提供则使用此列表而不是从数据库获取
    * @returns 后端返回的真实订单ID
@@ -2052,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}`);
@@ -2117,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:", {
@@ -2152,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;
   }
@@ -2162,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
       );
     }
@@ -2204,9 +2340,9 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
   }
   /**
    * 通过订单ID编辑订单备注
-   * 
+   *
    * 用于修改已同步到后端的订单备注，通常在支付成功后的弹窗中使用
-   * 
+   *
    * @param orderId 后端订单ID
    * @param note 新的订单备注
    * @returns 修改结果
@@ -2225,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,
@@ -2275,9 +2414,9 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
   }
   /**
    * 发送客户支付链接邮件
-   * 
+   *
    * 向指定邮箱发送订单支付提醒邮件
-   * 
+   *
    * @param params 发送参数
    * @returns 发送结果
    */
@@ -2301,7 +2440,9 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         };
       }
       const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-      const invalidEmails = params.emails.filter((email) => !emailRegex.test(email));
+      const invalidEmails = params.emails.filter(
+        (email) => !emailRegex.test(email)
+      );
       if (invalidEmails.length > 0) {
         return {
           success: false,
@@ -2314,7 +2455,10 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         emails: params.emails
       };
       console.log("[Checkout] 发送支付链接邮件请求参数:", requestBody);
-      const response = await this.request.post("/order/batch-email", requestBody);
+      const response = await this.request.post(
+        "/order/batch-email",
+        requestBody
+      );
       console.log("[Checkout] 支付链接邮件发送响应:", {
         status: response.status,
         message: response.message,
@@ -2346,7 +2490,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
   }
   /**
    * 金额舍入
-   * 
+   *
    * @param amount 原始金额
    * @returns 舍入结果详情，包含原始金额、舍入后金额和舍入差额
    */
@@ -2357,7 +2501,9 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       (_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}`);
+    console.log(
+      `[Checkout] 金额舍入完成 - 原始: ${result.originalAmount}, 舍入后: ${result.roundedAmount}, 差额: ${result.roundingDifference}`
+    );
     return result;
   }
   async destroy() {
@@ -2369,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 = {