@pisell/pisellos 0.0.229 → 0.0.231

package/lib/solution/Checkout/index.js

@@ -0,0 +1,2107 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/solution/Checkout/index.ts
+var Checkout_exports = {};
+__export(Checkout_exports, {
+  CheckoutImpl: () => CheckoutImpl
+});
+module.exports = __toCommonJS(Checkout_exports);
+var import_BaseModule = require("../../modules/BaseModule");
+var import_Order = require("../../modules/Order");
+var import_Payment = require("../../modules/Payment");
+var import_types = require("./types");
+var import_types2 = require("../../modules/Payment/types");
+var import_utils = require("./utils");
+__reExport(Checkout_exports, require("./types"), module.exports);
+var CheckoutImpl = class extends import_BaseModule.BaseModule {
+  constructor(name, version) {
+    super(name || "checkout", version || "1.0.0");
+    this.defaultName = "checkout";
+    this.defaultVersion = "1.0.0";
+    this.isSolution = true;
+    this.otherParams = {};
+  }
+  async initialize(core, options) {
+    this.core = core;
+    this.otherParams = options.otherParams || {};
+    this.request = core.getPlugin("request");
+    if (!this.request) {
+      throw new Error("Checkout 解决方案需要 request 插件支持");
+    }
+    this.order = new import_Order.OrderModule();
+    this.payment = new import_Payment.PaymentModule();
+    this.store = {
+      status: import_types.CheckoutStatus.Initializing,
+      step: import_types.CheckoutStep.OrderConfirmation,
+      cartItems: [],
+      paymentMethods: [],
+      stateAmount: "0.00",
+      cartSummary: void 0,
+      isOrderSynced: false,
+      currentCustomer: void 0
+    };
+    await this.initializeSubModules(core, options);
+    await this.preloadPaymentMethods();
+    await this.setStatus(import_types.CheckoutStatus.Ready);
+    console.log("[Checkout] 初始化完成");
+    await this.core.effects.emit(import_types.CheckoutHooks.OnCheckoutInitialized, {
+      timestamp: Date.now()
+    });
+  }
+  /**
+   * 初始化子模块
+   */
+  async initializeSubModules(core, options) {
+    var _a, _b;
+    core.registerModule(this.order, {
+      store: ((_a = options.store) == null ? void 0 : _a.order) || {},
+      otherParams: { ...this.otherParams, parentModule: this.name }
+    });
+    core.registerModule(this.payment, {
+      store: ((_b = options.store) == null ? void 0 : _b.payment) || {},
+      otherParams: { ...this.otherParams, parentModule: this.name }
+    });
+    this.setupPaymentEventListeners();
+  }
+  /**
+   * 设置支付模块事件监听
+   */
+  setupPaymentEventListeners() {
+    this.core.effects.on("payment:onPaymentSyncSuccess", async (data) => {
+      var _a;
+      if (((_a = this.store.currentOrder) == null ? void 0 : _a.uuid) === data.orderUuid) {
+        await this.handlePaymentSuccess(data);
+      }
+    });
+    this.core.effects.on("payment:onPaymentSyncError", async (data) => {
+      var _a;
+      if (((_a = this.store.currentOrder) == null ? void 0 : _a.uuid) === data.orderUuid) {
+        await this.handlePaymentError(data);
+      }
+    });
+  }
+  /**
+   * 初始化结账流程
+   */
+  async initializeCheckoutAsync(params) {
+    try {
+      await this.setStatus(import_types.CheckoutStatus.Initializing);
+      const validation = await this.validateCheckoutParams(params);
+      if (!validation.valid) {
+        throw (0, import_utils.createCheckoutError)(
+          import_types.CheckoutErrorType.ValidationFailed,
+          `参数验证失败: ${validation.errors.join(", ")}`
+        );
+      }
+      this.store.cartItems = params.cartItems;
+      await this.setStatus(import_types.CheckoutStatus.Ready);
+      await this.setStep(import_types.CheckoutStep.OrderConfirmation);
+      console.log("[Checkout] 结账流程初始化完成");
+    } catch (error) {
+      await this.handleError(error, import_types.CheckoutErrorType.UnknownError);
+      throw error;
+    }
+  }
+  getProductListByOrder() {
+    var _a;
+    if (!this.store.currentOrder) {
+      return [];
+    }
+    const productList = (_a = this.store.currentOrder.order_info) == null ? void 0 : _a.original_order_data.bookings.map((item) => ({
+      product_id: item.product.product_id,
+      product_variant_id: item.product.product_variant_id,
+      quantity: item.product.num,
+      selling_price: item.product.price - (item.product.discount_amount || 0)
+    }));
+    return productList;
+  }
+  /**
+   * 创建本地订单 (前端模拟下单流程)
+   * 
+   * 此方法用于在前端模拟整个下单流程，创建一个本地的虚拟订单。
+   * 用户在购物车点击下单时，会把购物车参数传递给此方法，
+   * 方法会记录参数并创建本地虚拟订单，然后用 Payment 模块管理支付流程。
+   */
+  async createLocalOrderAsync(params) {
+    var _a, _b, _c, _d, _e;
+    try {
+      await this.setStatus(import_types.CheckoutStatus.CreatingOrder);
+      const validation = await this.validateLocalOrderData(params.orderData);
+      if (!validation.valid) {
+        throw (0, import_utils.createCheckoutError)(
+          import_types.CheckoutErrorType.ValidationFailed,
+          `订单数据验证失败: ${validation.errors.join(", ")}`
+        );
+      }
+      const localOrderId = this.generateLocalOrderId();
+      const amountInfo = this.extractAmountFromCartSummary(params.cartSummary);
+      params.orderData.platform = "pos";
+      params.orderData.created_at = this.formatDateTime(/* @__PURE__ */ new Date());
+      params.orderData.surcharge_fee = (_b = (_a = params.totalInfo) == null ? void 0 : _a.total) == null ? void 0 : _b.paySurchargeFee;
+      params.orderData.shop_discount = (_d = (_c = params.totalInfo) == null ? void 0 : _c.total) == null ? void 0 : _d.shopDiscount;
+      this.store.localOrderData = params.orderData;
+      this.store.cartSummary = params.cartSummary;
+      const customerInfo = {
+        customer_id: params.orderData.customer_id,
+        customer_name: params.orderData.customer_name
+      };
+      if (customerInfo.customer_id || customerInfo.customer_name) {
+        this.store.currentCustomer = customerInfo;
+        console.log("[Checkout] 保存客户信息:", customerInfo);
+      } else {
+        this.store.currentCustomer = void 0;
+        console.log("[Checkout] 未提供客户信息");
+      }
+      const paymentOrder = await this.payment.createPaymentOrderAsync({
+        order_id: localOrderId,
+        total_amount: amountInfo.totalAmount,
+        is_deposit: params.orderData.is_deposit || 0,
+        deposit_amount: amountInfo.depositAmount || "0.00",
+        order_info: {
+          original_order_data: params.orderData,
+          cart_summary: params.cartSummary,
+          created_at: (/* @__PURE__ */ new Date()).toISOString(),
+          platform: params.orderData.platform,
+          type: params.orderData.type,
+          schedule_date: params.orderData.schedule_date,
+          shop_note: params.orderData.shop_note,
+          amount_breakdown: amountInfo
+        }
+      });
+      this.store.currentOrder = paymentOrder;
+      const walletBusinessData = {
+        customer_id: ((_e = this.store.currentCustomer) == null ? void 0 : _e.customer_id) ? Number(this.store.currentCustomer.customer_id) : void 0,
+        amountInfo: {
+          totalAmount: amountInfo.totalAmount,
+          subTotal: amountInfo.subTotal
+        },
+        products: this.getProductListByOrder()
+      };
+      const walletData = await this.payment.wallet.initializeWalletDataFromBusinessAsync(walletBusinessData);
+      console.log(walletData.walletRecommendList, "walletRecommendList");
+      console.log(walletData.userIdentificationCodes, "userIdentificationCodes");
+      await this.setStatus(import_types.CheckoutStatus.OrderCreated);
+      await this.setStep(import_types.CheckoutStep.PaymentMethod);
+      if (params.autoPayment) {
+        await this.setStep(import_types.CheckoutStep.PaymentProcessing);
+      }
+      await this.core.effects.emit(import_types.CheckoutHooks.OnOrderCreated, {
+        order: paymentOrder,
+        timestamp: Date.now()
+      });
+      await this.updateStateAmountToRemaining();
+      console.log("[Checkout] 本地订单创建成功:", {
+        localOrderId,
+        uuid: paymentOrder.uuid,
+        totalAmount: amountInfo.totalAmount,
+        subTotal: amountInfo.subTotal,
+        taxAmount: amountInfo.taxAmount,
+        stateAmount: this.store.stateAmount
+      });
+      return paymentOrder;
+    } catch (error) {
+      await this.handleError(error, import_types.CheckoutErrorType.OrderCreationFailed);
+      await this.core.effects.emit(import_types.CheckoutHooks.OnOrderCreationFailed, {
+        error: this.store.lastError,
+        timestamp: Date.now()
+      });
+      throw error;
+    }
+  }
+  /**
+   * 手动下单 (根据虚拟订单生成实际订单)
+   * 
+   * 使用当前存储的本地订单数据调用 Order 模块创建真实订单
+   */
+  async placeOrderAsync(params = {}) {
+    var _a;
+    try {
+      if (!this.store.localOrderData) {
+        throw (0, import_utils.createCheckoutError)(
+          import_types.CheckoutErrorType.ValidationFailed,
+          "没有找到本地订单数据，请先调用 createLocalOrderAsync 创建虚拟订单"
+        );
+      }
+      if (!this.store.currentOrder) {
+        throw (0, import_utils.createCheckoutError)(
+          import_types.CheckoutErrorType.ValidationFailed,
+          "没有找到当前订单，请先创建虚拟订单"
+        );
+      }
+      console.log("[Checkout] 开始手动下单流程...");
+      await this.setStatus(import_types.CheckoutStatus.CreatingOrder);
+      const orderData = {
+        cartItems: this.store.cartItems,
+        type: this.store.localOrderData.type,
+        platform: this.store.localOrderData.platform
+      };
+      const orderResponse = await this.order.submitOrder({
+        url: params.url,
+        // 可选的自定义 URL
+        query: orderData
+      });
+      const realOrderId = ((_a = orderResponse == null ? void 0 : orderResponse.data) == null ? void 0 : _a.order_id) || (orderResponse == null ? void 0 : orderResponse.order_id);
+      if (!realOrderId) {
+        throw (0, import_utils.createCheckoutError)(
+          import_types.CheckoutErrorType.OrderCreationFailed,
+          "订单创建成功但未返回订单ID"
+        );
+      }
+      console.log("[Checkout] 真实订单创建成功:", realOrderId);
+      if (params.autoReplaceOrderId !== false) {
+        console.log("[Checkout] 自动替换虚拟订单ID为真实订单ID...");
+        const updatedOrder = await this.replaceLocalOrderIdAsync(realOrderId);
+        if (updatedOrder) {
+          console.log("[Checkout] 订单ID替换成功:", {
+            oldId: this.store.currentOrder.order_id,
+            newId: realOrderId
+          });
+        }
+      }
+      await this.setStatus(import_types.CheckoutStatus.OrderCreated);
+      await this.core.effects.emit(import_types.CheckoutHooks.OnOrderCreated, {
+        order: this.store.currentOrder,
+        timestamp: Date.now()
+      });
+      this.store.isOrderSynced = true;
+      console.log("[Checkout] 手动下单流程完成");
+      return {
+        success: true,
+        orderId: realOrderId
+      };
+    } catch (error) {
+      let errorMessage = "下单失败";
+      if (error && typeof error === "object" && "message" in error) {
+        errorMessage = error.message;
+      } else if (error instanceof Error) {
+        errorMessage = error.message;
+      }
+      console.error("[Checkout] 手动下单失败:", errorMessage);
+      await this.handleError(error, import_types.CheckoutErrorType.OrderCreationFailed);
+      return {
+        success: false,
+        error: errorMessage
+      };
+    }
+  }
+  /**
+   * 创建订单
+   */
+  async createOrderAsync(params) {
+    var _a;
+    try {
+      await this.setStatus(import_types.CheckoutStatus.CreatingOrder);
+      const checkResult = this.order.checkBeforeSubmitOrder({
+        cartItems: params.cartItems,
+        type: "account"
+        // 默认使用 account 类型
+      });
+      if (!checkResult) {
+        throw (0, import_utils.createCheckoutError)(
+          import_types.CheckoutErrorType.ValidationFailed,
+          "购物车数据验证失败，请检查商品信息"
+        );
+      }
+      const orderResponse = await this.order.submitOrder({
+        query: {
+          cartItems: params.cartItems,
+          type: params.type || "appointment_booking",
+          platform: params.platform || "pc"
+        }
+      });
+      const paymentOrder = await this.payment.createPaymentOrderAsync({
+        order_id: ((_a = orderResponse == null ? void 0 : orderResponse.data) == null ? void 0 : _a.order_id) || `order_${Date.now()}`,
+        total_amount: this.calculateTotalAmount(params.cartItems),
+        order_info: orderResponse == null ? void 0 : orderResponse.data
+      });
+      this.store.currentOrder = paymentOrder;
+      await this.setStatus(import_types.CheckoutStatus.OrderCreated);
+      await this.setStep(import_types.CheckoutStep.PaymentMethod);
+      await this.core.effects.emit(import_types.CheckoutHooks.OnOrderCreated, {
+        order: paymentOrder,
+        timestamp: Date.now()
+      });
+      this.store.isOrderSynced = true;
+      await this.updateStateAmountToRemaining();
+      console.log("[Checkout] 订单创建成功:", paymentOrder.id);
+      return paymentOrder;
+    } catch (error) {
+      await this.handleError(error, import_types.CheckoutErrorType.OrderCreationFailed);
+      await this.core.effects.emit(import_types.CheckoutHooks.OnOrderCreationFailed, {
+        error: this.store.lastError,
+        timestamp: Date.now()
+      });
+      throw error;
+    }
+  }
+  /**
+   * 处理支付
+   */
+  async processPaymentAsync(params) {
+    try {
+      if (!this.store.currentOrder) {
+        throw (0, import_utils.createCheckoutError)(
+          import_types.CheckoutErrorType.ValidationFailed,
+          "未找到当前订单，请先创建订单"
+        );
+      }
+      await this.setStatus(import_types.CheckoutStatus.ProcessingPayment);
+      await this.setStep(import_types.CheckoutStep.PaymentProcessing);
+      const paymentMethod = this.store.paymentMethods.find(
+        (method) => method.code === params.paymentMethodCode
+      );
+      if (!paymentMethod) {
+        throw (0, import_utils.createCheckoutError)(
+          import_types.CheckoutErrorType.ValidationFailed,
+          `未找到支付方式: ${params.paymentMethodCode}`
+        );
+      }
+      const paymentItem = {
+        code: paymentMethod.code,
+        name: paymentMethod.name,
+        type: paymentMethod.type,
+        amount: String(params.amount),
+        id: paymentMethod.id
+      };
+      await this.payment.addPaymentItemAsync(
+        this.store.currentOrder.uuid,
+        paymentItem
+      );
+      const result = await this.payment.submitPayAsync(
+        this.store.currentOrder.uuid
+      );
+      await this.core.effects.emit(import_types.CheckoutHooks.OnPaymentStarted, {
+        orderUuid: this.store.currentOrder.uuid,
+        paymentMethodCode: params.paymentMethodCode,
+        amount: String(params.amount),
+        timestamp: Date.now()
+      });
+      if (result.status === "success") {
+        await this.setStatus(import_types.CheckoutStatus.PaymentCompleted);
+        await this.updateStateAmountToRemaining();
+        await this.handlePaymentSuccess({
+          orderUuid: this.store.currentOrder.uuid,
+          timestamp: Date.now()
+        });
+      } else {
+        throw (0, import_utils.createCheckoutError)(
+          import_types.CheckoutErrorType.PaymentFailed,
+          "支付处理失败，请重试"
+        );
+      }
+    } catch (error) {
+      await this.handleError(error, import_types.CheckoutErrorType.PaymentFailed);
+      throw error;
+    }
+  }
+  /**
+   * 完成结账
+   */
+  async completeCheckoutAsync() {
+    try {
+      if (!this.store.currentOrder) {
+        throw (0, import_utils.createCheckoutError)(
+          import_types.CheckoutErrorType.ValidationFailed,
+          "未找到当前订单"
+        );
+      }
+      const order = await this.payment.getPaymentOrderByUuidAsync(
+        this.store.currentOrder.uuid
+      );
+      if (!order || order.payment_status !== import_types2.PaymentStatus.Finished) {
+        throw (0, import_utils.createCheckoutError)(
+          import_types.CheckoutErrorType.ValidationFailed,
+          "订单支付未完成，无法完成结账"
+        );
+      }
+      this.payment.wallet.clearAllCache();
+      await this.setStatus(import_types.CheckoutStatus.Completed);
+      await this.setStep(import_types.CheckoutStep.Complete);
+      await this.core.effects.emit(import_types.CheckoutHooks.OnCheckoutCompleted, {
+        orderId: order.id,
+        timestamp: Date.now()
+      });
+      console.log("[Checkout] 结账流程完成:", order.id);
+      return {
+        success: true,
+        orderId: String(order.id)
+      };
+    } catch (error) {
+      await this.handleError(error, import_types.CheckoutErrorType.UnknownError);
+      return { success: false };
+    }
+  }
+  /**
+   * 取消结账
+   */
+  async cancelCheckoutAsync() {
+    try {
+      if (this.store.currentOrder) {
+        await this.payment.deletePaymentOrderAsync(this.store.currentOrder.uuid);
+        this.store.currentOrder = void 0;
+      }
+      this.store.localOrderData = void 0;
+      this.store.cartSummary = void 0;
+      this.payment.wallet.clearAllCache();
+      this.store.cartItems = [];
+      this.store.stateAmount = "0.00";
+      this.store.isOrderSynced = false;
+      this.store.currentCustomer = void 0;
+      await this.setStatus(import_types.CheckoutStatus.Cancelled);
+      await this.core.effects.emit(import_types.CheckoutHooks.OnCheckoutCancelled, {
+        timestamp: Date.now()
+      });
+      console.log("[Checkout] 结账流程已取消");
+    } catch (error) {
+      console.error("[Checkout] 取消结账失败:", error);
+      await this.handleError(error, import_types.CheckoutErrorType.UnknownError);
+    }
+  }
+  /**
+   * 获取结账状态
+   */
+  getCheckoutStatus() {
+    return {
+      status: this.store.status,
+      step: this.store.step,
+      progress: (0, import_utils.calculateProgress)(this.store.status, this.store.step),
+      message: this.getStatusMessage(),
+      error: this.store.lastError
+    };
+  }
+  /**
+   * 获取结账摘要
+   */
+  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();
+    return {
+      order: this.store.currentOrder,
+      totalAmount,
+      paidAmount,
+      remainingAmount,
+      paymentStatus: ((_b = this.store.currentOrder) == null ? void 0 : _b.payment_status) || import_types2.PaymentStatus.Processing,
+      availablePaymentMethods: this.store.paymentMethods
+    };
+  }
+  /**
+   * 获取可用支付方式
+   */
+  async getAvailablePaymentMethodsAsync() {
+    if (this.store.paymentMethods.length === 0) {
+      console.log("[Checkout] 支付方式缓存为空，重新加载...");
+      await this.preloadPaymentMethods();
+    }
+    return this.store.paymentMethods;
+  }
+  /**
+   * 刷新支付方式缓存
+   * 
+   * 强制重新从服务器获取支付方式列表，更新本地缓存
+   */
+  async refreshPaymentMethodsAsync() {
+    console.log("[Checkout] 强制刷新支付方式缓存...");
+    await this.preloadPaymentMethods();
+    return this.store.paymentMethods;
+  }
+  /**
+   * 获取当前订单基础信息
+   * 
+   * 返回当前订单的基础信息，包括订单状态、金额、支付状态等
+   */
+  getCurrentOrderInfo() {
+    try {
+      const { currentOrder, status, step, cartItems, localOrderData } = this.store;
+      if (!currentOrder) {
+        console.log("[Checkout] 当前没有活跃订单");
+        return null;
+      }
+      const orderInfo = currentOrder.order_info || {};
+      const createdAt = orderInfo.created_at || (/* @__PURE__ */ new Date()).toISOString();
+      const orderType = (localOrderData == null ? void 0 : localOrderData.type) || orderInfo.type || "virtual";
+      const platform = (localOrderData == null ? void 0 : localOrderData.platform) || orderInfo.platform || "pc";
+      const result = {
+        uuid: currentOrder.uuid,
+        orderId: currentOrder.order_id,
+        status,
+        step,
+        totalAmount: currentOrder.total_amount,
+        remainingAmount: currentOrder.expect_amount,
+        paymentStatus: currentOrder.payment_status,
+        isDeposit: Boolean(currentOrder.is_deposit),
+        depositAmount: currentOrder.deposit_amount,
+        orderType,
+        platform,
+        createdAt,
+        itemCount: cartItems.length,
+        hasLocalOrderData: Boolean(localOrderData)
+      };
+      console.log("[Checkout] 获取当前订单基础信息:", {
+        uuid: result.uuid,
+        orderId: result.orderId,
+        status: result.status,
+        totalAmount: result.totalAmount,
+        remainingAmount: result.remainingAmount
+      });
+      return result;
+    } catch (error) {
+      console.error("[Checkout] 获取当前订单基础信息失败:", error);
+      return null;
+    }
+  }
+  /**
+   * 获取当前订单的支付项
+   * 
+   * 返回当前订单的所有支付项，包括活跃和已撤销的支付项
+   */
+  async getCurrentOrderPaymentItemsAsync() {
+    try {
+      const { currentOrder } = this.store;
+      if (!currentOrder) {
+        console.log("[Checkout] 当前没有活跃订单，无法获取支付项");
+        return [];
+      }
+      console.log("[Checkout] 获取当前订单支付项:", {
+        orderUuid: currentOrder.uuid,
+        orderId: currentOrder.order_id
+      });
+      const paymentItems = await this.payment.getPaymentItemsAsync(currentOrder.uuid);
+      console.log("[Checkout] 成功获取支付项:", {
+        orderUuid: currentOrder.uuid,
+        paymentItemCount: paymentItems.length,
+        activeItems: paymentItems.filter((item) => item.status !== "voided").length,
+        voidedItems: paymentItems.filter((item) => item.status === "voided").length,
+        totalPaidAmount: paymentItems.filter((item) => item.status !== "voided").reduce((sum, item) => sum + parseFloat(item.amount || "0"), 0).toFixed(2),
+        paymentMethods: paymentItems.map((item) => ({
+          uuid: item.uuid,
+          code: item.code,
+          amount: item.amount,
+          status: item.status,
+          voucher_id: item.voucher_id
+        }))
+      });
+      return paymentItems;
+    } catch (error) {
+      console.error("[Checkout] 获取当前订单支付项失败:", error);
+      return [];
+    }
+  }
+  /**
+   * 验证结账前置条件
+   */
+  async validateCheckoutAsync() {
+    const errors = [];
+    if (!this.store.cartItems || this.store.cartItems.length === 0) {
+      errors.push("购物车为空");
+    }
+    if (this.store.paymentMethods.length === 0) {
+      errors.push("无可用支付方式");
+    }
+    if (this.store.status === import_types.CheckoutStatus.Error) {
+      errors.push("结账流程存在错误");
+    }
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  }
+  /**
+   * 重试失败的操作
+   */
+  async retryFailedOperationAsync() {
+    try {
+      if (this.store.status === import_types.CheckoutStatus.Error && this.store.lastError) {
+        switch (this.store.lastError.type) {
+          case import_types.CheckoutErrorType.OrderCreationFailed:
+            if (this.store.cartItems.length > 0) {
+              await this.createOrderAsync({
+                cartItems: this.store.cartItems
+              });
+            }
+            break;
+          default:
+            console.warn("[Checkout] 无法重试此类型的错误:", this.store.lastError.type);
+        }
+      }
+    } catch (error) {
+      await this.handleError(error, import_types.CheckoutErrorType.UnknownError);
+    }
+  }
+  /**
+   * 设置当前步骤
+   */
+  setCurrentStep(step) {
+    const oldStep = this.store.step;
+    this.store.step = step;
+    this.core.effects.emit(import_types.CheckoutHooks.OnStepChanged, {
+      oldStep,
+      newStep: step,
+      timestamp: Date.now()
+    });
+  }
+  /**
+   * 获取订单模块
+   */
+  getOrderModule() {
+    return this.order;
+  }
+  /**
+   * 获取支付模块
+   */
+  getPaymentModule() {
+    return this.payment;
+  }
+  /**
+   * 替换本地订单ID为真实订单ID
+   * 
+   * 当后端订单创建完成后，调用此方法将本地虚拟订单ID替换为真实订单ID
+   * 
+   * @param newOrderId 后端返回的真实订单ID
+   * @returns 更新后的订单对象，如果当前没有订单则返回null
+   */
+  async replaceLocalOrderIdAsync(newOrderId) {
+    try {
+      if (!this.store.currentOrder) {
+        console.warn("[Checkout] 没有当前订单，无法替换订单ID");
+        return null;
+      }
+      const updatedOrder = await this.payment.replaceOrderIdByUuidAsync(
+        this.store.currentOrder.uuid,
+        newOrderId
+      );
+      if (updatedOrder) {
+        this.store.currentOrder = updatedOrder;
+        await this.core.effects.emit(import_types.CheckoutHooks.OnOrderCreated, {
+          order: updatedOrder,
+          timestamp: Date.now()
+        });
+        console.log("[Checkout] 本地订单ID替换成功:", {
+          uuid: updatedOrder.uuid,
+          newOrderId: updatedOrder.id
+        });
+        this.store.isOrderSynced = true;
+        await this.updateStateAmountToRemaining();
+      }
+      return updatedOrder;
+    } catch (error) {
+      console.error("[Checkout] 替换订单ID失败:", error);
+      await this.handleError(error, import_types.CheckoutErrorType.UnknownError);
+      return null;
+    }
+  }
+  /**
+   * 设置自定义支付金额
+   * 
+   * 允许UI自定义本次支付的金额，通常用于部分支付或调整支付金额场景
+   * 
+   * @param amount 自定义支付金额，必须是有效的数字字符串
+   */
+  async setStateAmountAsync(amount) {
+    try {
+      const numAmount = parseFloat(amount);
+      if (isNaN(numAmount) || numAmount < 0) {
+        throw new Error(`无效的支付金额: ${amount}`);
+      }
+      const oldAmount = this.store.stateAmount;
+      const formattedAmount = numAmount.toFixed(2);
+      if (oldAmount === formattedAmount) {
+        return;
+      }
+      this.store.stateAmount = formattedAmount;
+      await this.core.effects.emit(import_types.CheckoutHooks.OnStateAmountChanged, {
+        oldAmount,
+        newAmount: formattedAmount,
+        timestamp: Date.now()
+      });
+      console.log("[Checkout] 自定义支付金额已更新:", {
+        oldAmount,
+        newAmount: formattedAmount
+      });
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "设置支付金额失败";
+      console.error("[Checkout] 设置自定义支付金额失败:", errorMessage);
+      await this.handleError(
+        new Error(errorMessage),
+        import_types.CheckoutErrorType.ValidationFailed
+      );
+      throw error;
+    }
+  }
+  /**
+   * 获取当前自定义支付金额
+   * 
+   * @returns 当前设置的自定义支付金额
+   */
+  getStateAmount() {
+    return this.store.stateAmount;
+  }
+  /**
+   * 刷新 stateAmount 为当前剩余未支付金额
+   * 
+   * UI 可以调用此方法来主动刷新支付金额状态
+   */
+  async refreshStateAmountAsync() {
+    await this.updateStateAmountToRemaining();
+  }
+  /**
+   * 获取购物车小计数据
+   * 
+   * 返回当前结账流程中的购物车小计项数据，包含各种费用明细
+   * 
+   * @returns 购物车小计数据数组，如果没有则返回 null
+   */
+  getCartSummary() {
+    if (!this.store.cartSummary || this.store.cartSummary.length === 0) {
+      console.warn("[Checkout] 没有可用的购物车小计数据");
+      return null;
+    }
+    console.log("[Checkout] 获取购物车小计数据:", {
+      itemCount: this.store.cartSummary.length,
+      items: this.store.cartSummary.map((item) => ({ key: item.key, value: item.value, label: item.label }))
+    });
+    return [...this.store.cartSummary];
+  }
+  /**
+   * 获取提取的金额详细信息
+   * 
+   * 从当前的购物车小计数据中提取结构化的金额信息
+   * 
+   * @returns 提取的金额信息对象，如果没有小计数据则返回 null
+   */
+  getExtractedAmountInfo() {
+    if (!this.store.cartSummary || this.store.cartSummary.length === 0) {
+      console.warn("[Checkout] 没有可用的购物车小计数据，无法提取金额信息");
+      return null;
+    }
+    const extractedInfo = this.extractAmountFromCartSummary(this.store.cartSummary);
+    console.log("[Checkout] 获取提取的金额信息:", extractedInfo);
+    return extractedInfo;
+  }
+  /**
+   * 获取支付方式列表
+   * 
+   * 直接调用 Payment 模块的 getPayMethodListAsync 方法
+   * 
+   * @returns 支付方式列表
+   */
+  async getPaymentMethodsAsync() {
+    return await this.payment.getPayMethodListAsync();
+  }
+  /**
+   * 为当前订单添加支付项
+   * 
+   * 向当前活跃订单添加一个支付项，支付项包含支付方式信息和金额
+   * 
+   * @param paymentItem 支付项数据
+   * @throws 当前没有活跃订单时抛出错误
+   */
+  async addPaymentItemAsync(paymentItem) {
+    try {
+      if (!this.store.currentOrder) {
+        throw (0, import_utils.createCheckoutError)(
+          import_types.CheckoutErrorType.ValidationFailed,
+          "未找到当前订单，无法添加支付项"
+        );
+      }
+      console.log("[Checkout] 为当前订单添加支付项:", {
+        orderUuid: this.store.currentOrder.uuid,
+        paymentItem: {
+          code: paymentItem.code,
+          name: paymentItem.name,
+          type: paymentItem.type,
+          amount: paymentItem.amount,
+          service_charge: paymentItem.service_charge
+        }
+      });
+      await this.payment.addPaymentItemAsync(
+        this.store.currentOrder.uuid,
+        paymentItem
+      );
+      console.log("[Checkout] 支付项添加成功");
+      const currentOrderId = this.store.currentOrder.order_id;
+      const isCurrentOrderReal = currentOrderId && !this.isVirtualOrderId(currentOrderId);
+      console.log("[Checkout] 准备同步订单数据:", {
+        当前订单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,
+        paymentMethodCode: paymentItem.code,
+        amount: String(paymentItem.amount),
+        timestamp: Date.now()
+      });
+    } catch (error) {
+      console.error("[Checkout] 添加支付项失败:", error);
+      await this.handleError(error, import_types.CheckoutErrorType.PaymentFailed);
+      throw error;
+    }
+  }
+  /**
+   * 删除当前订单的支付项
+   * 
+   * 从当前活跃订单中删除指定的支付项，支付项将被标记为已撤销状态
+   * 
+   * @param paymentUuid 要删除的支付项UUID
+   * @throws 当前没有活跃订单时抛出错误
+   * @throws 支付项不存在时抛出错误
+   */
+  async deletePaymentItemAsync(paymentUuid) {
+    try {
+      if (!this.store.currentOrder) {
+        throw (0, import_utils.createCheckoutError)(
+          import_types.CheckoutErrorType.ValidationFailed,
+          "当前没有活跃订单，无法删除支付项"
+        );
+      }
+      console.log("[Checkout] 开始删除支付项:", {
+        orderUuid: this.store.currentOrder.uuid,
+        paymentUuid
+      });
+      const paymentItem = this.store.currentOrder.payment.find((p) => p.uuid === paymentUuid);
+      if (!paymentItem) {
+        throw (0, import_utils.createCheckoutError)(
+          import_types.CheckoutErrorType.ValidationFailed,
+          `支付项不存在: ${paymentUuid}`
+        );
+      }
+      console.log("[Checkout] 找到要删除的支付项:", {
+        uuid: paymentItem.uuid,
+        code: paymentItem.code,
+        amount: paymentItem.amount,
+        status: paymentItem.status
+      });
+      await this.payment.deletePaymentAsync(
+        this.store.currentOrder.uuid,
+        paymentUuid
+      );
+      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);
+      if (updatedOrder) {
+        if (isCurrentOrderReal && this.isVirtualOrderId(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);
+      }
+      await this.updateStateAmountToRemaining();
+      await this.core.effects.emit(import_types.CheckoutHooks.OnPaymentStarted, {
+        orderUuid: this.store.currentOrder.uuid,
+        paymentMethodCode: paymentItem.code,
+        amount: `-${paymentItem.amount}`,
+        // 负数表示删除
+        timestamp: Date.now()
+      });
+      console.log("[Checkout] 支付项删除成功");
+    } catch (error) {
+      console.error("[Checkout] 删除支付项失败:", error);
+      await this.handleError(error, import_types.CheckoutErrorType.PaymentFailed);
+      throw error;
+    }
+  }
+  /**
+   * 批量更新当前订单的代金券支付项（覆盖更新）
+   * 
+   * 删除所有现有的代金券支付项，然后添加新的代金券支付项。
+   * 这是一个覆盖式更新操作，确保代金券支付项的一致性。
+   * 
+   * @param voucherPaymentItems 新的代金券支付项列表，每个都必须包含 voucher_id
+   * @throws 当前没有活跃订单时抛出错误
+   * @throws 支付项缺少 voucher_id 时抛出错误
+   */
+  async updateVoucherPaymentItemsAsync(voucherPaymentItems) {
+    try {
+      if (!this.store.currentOrder) {
+        throw (0, import_utils.createCheckoutError)(
+          import_types.CheckoutErrorType.ValidationFailed,
+          "当前没有活跃订单，无法更新代金券支付项"
+        );
+      }
+      console.log("[Checkout] 开始批量更新代金券支付项:", {
+        orderUuid: this.store.currentOrder.uuid,
+        newVoucherCount: voucherPaymentItems.length,
+        voucherPaymentItems
+      });
+      for (const item of voucherPaymentItems) {
+        if (!item.voucher_id) {
+          throw (0, import_utils.createCheckoutError)(
+            import_types.CheckoutErrorType.ValidationFailed,
+            `代金券支付项缺少 voucher_id: ${JSON.stringify(item)}`
+          );
+        }
+      }
+      await this.payment.updateVoucherPaymentItemsAsync(
+        this.store.currentOrder.uuid,
+        voucherPaymentItems
+      );
+      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);
+      if (updatedOrder) {
+        if (isCurrentOrderReal && this.isVirtualOrderId(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);
+        const voucherItems = updatedOrder.payment.filter(
+          (payment) => payment.voucher_id && payment.status !== "voided"
+        );
+        console.log("[Checkout] 更新后的代金券支付项:", {
+          voucherCount: voucherItems.length,
+          items: voucherItems.map((item) => ({
+            uuid: item.uuid,
+            code: item.code,
+            amount: item.amount,
+            voucher_id: item.voucher_id
+          }))
+        });
+      }
+      await this.updateStateAmountToRemaining();
+      await this.core.effects.emit(import_types.CheckoutHooks.OnPaymentStarted, {
+        orderUuid: this.store.currentOrder.uuid,
+        paymentMethodCode: "VOUCHER_BATCH",
+        amount: voucherPaymentItems.reduce((sum, item) => sum + parseFloat(String(item.amount)), 0).toFixed(2),
+        timestamp: Date.now()
+      });
+      console.log("[Checkout] 代金券支付项批量更新成功");
+    } catch (error) {
+      console.error("[Checkout] 批量更新代金券支付项失败:", error);
+      await this.handleError(error, import_types.CheckoutErrorType.PaymentFailed);
+      throw error;
+    }
+  }
+  /**
+   * 修改当前订单的定金状态
+   * 
+   * 更新当前订单的 is_deposit 字段，用于标识订单是否为定金订单
+   * 
+   * @param isDeposit 定金状态 (1: 定金订单, 0: 全款订单)
+   * @throws 当前没有活跃订单时抛出错误
+   */
+  async updateOrderDepositStatusAsync(isDeposit) {
+    try {
+      if (isDeposit !== 0 && isDeposit !== 1) {
+        throw (0, import_utils.createCheckoutError)(
+          import_types.CheckoutErrorType.ValidationFailed,
+          "isDeposit 参数只能是 0（全款订单）或 1（定金订单）"
+        );
+      }
+      if (!this.store.currentOrder) {
+        throw (0, import_utils.createCheckoutError)(
+          import_types.CheckoutErrorType.ValidationFailed,
+          "未找到当前订单，无法修改定金状态"
+        );
+      }
+      const newDepositValue = isDeposit;
+      const oldDepositValue = this.store.currentOrder.is_deposit;
+      if (oldDepositValue === newDepositValue) {
+        console.log("[Checkout] 定金状态无变化，跳过更新");
+        return;
+      }
+      console.log("[Checkout] 更新订单定金状态:", {
+        orderUuid: this.store.currentOrder.uuid,
+        orderId: this.store.currentOrder.order_id,
+        oldIsDeposit: oldDepositValue,
+        newIsDeposit: newDepositValue
+      });
+      const updateParams = {
+        is_deposit: newDepositValue
+      };
+      if (isDeposit === 0 && this.store.currentOrder.deposit_amount !== "0.00") {
+        updateParams.deposit_amount = "0.00";
+        console.log("[Checkout] 订单从定金改为全款，清空定金金额");
+      }
+      await this.payment.updateOrderAsync(this.store.currentOrder.uuid, updateParams);
+      this.store.currentOrder = {
+        ...this.store.currentOrder,
+        ...updateParams
+      };
+      if (this.store.localOrderData) {
+        this.store.localOrderData.is_deposit = newDepositValue;
+      }
+      await this.core.effects.emit(import_types.CheckoutHooks.OnOrderCreated, {
+        order: this.store.currentOrder,
+        timestamp: Date.now()
+      });
+      console.log("[Checkout] 订单定金状态更新成功:", {
+        isDeposit: newDepositValue,
+        depositAmount: this.store.currentOrder.deposit_amount
+      });
+    } catch (error) {
+      console.error("[Checkout] 更新订单定金状态失败:", error);
+      await this.handleError(error, import_types.CheckoutErrorType.ValidationFailed);
+      throw error;
+    }
+  }
+  /**
+   * 更新当前订单的客户信息
+   * 
+   * 更新当前订单关联的客户信息，用于标识订单的所属客户
+   * 
+   * @param customer 客户信息 (customer_id 和/或 customer_name)
+   * @throws 当前没有活跃订单时抛出错误
+   */
+  async updateOrderCustomerAsync(customer) {
+    try {
+      if (!this.store.currentOrder) {
+        throw (0, import_utils.createCheckoutError)(
+          import_types.CheckoutErrorType.ValidationFailed,
+          "未找到当前订单，无法更新客户信息"
+        );
+      }
+      console.log("[Checkout] 更新订单客户信息:", {
+        orderUuid: this.store.currentOrder.uuid,
+        oldCustomer: this.store.currentCustomer,
+        newCustomer: customer
+      });
+      this.store.currentCustomer = {
+        customer_id: customer.customer_id,
+        customer_name: customer.customer_name
+      };
+      if (this.store.localOrderData) {
+        this.store.localOrderData.customer_id = customer.customer_id;
+        this.store.localOrderData.customer_name = customer.customer_name;
+      }
+      console.log("[Checkout] 订单客户信息更新成功:", this.store.currentCustomer);
+    } catch (error) {
+      console.error("[Checkout] 更新订单客户信息失败:", error);
+      await this.handleError(error, import_types.CheckoutErrorType.ValidationFailed);
+      throw error;
+    }
+  }
+  /**
+   * 获取当前订单的客户信息
+   * 
+   * @returns 当前客户信息，如果没有则返回 null
+   */
+  getCurrentCustomer() {
+    return this.store.currentCustomer || null;
+  }
+  /**
+   * 检查订单是否需要手动同步
+   * 
+   * 返回订单是否为纯代金券支付且待付金额<=0但未同步的状态
+   */
+  needsManualSync() {
+    var _a;
+    try {
+      if (!this.store.currentOrder || this.store.isOrderSynced) {
+        return false;
+      }
+      const remainingAmount = this.calculateRemainingAmount();
+      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(
+        (item) => item.status !== "voided" && item.voucher_id
+      );
+      console.log("[Checkout] needsManualSync 检查结果:", {
+        orderUuid: this.store.currentOrder.uuid,
+        isOrderSynced: this.store.isOrderSynced,
+        remainingAmount,
+        hasPayments: ((_a = this.store.currentOrder.payment) == null ? void 0 : _a.length) > 0,
+        allPaymentsHaveVoucherId,
+        needsManualSync: allPaymentsHaveVoucherId
+      });
+      return allPaymentsHaveVoucherId;
+    } catch (error) {
+      console.error("[Checkout] needsManualSync 检查失败:", error);
+      return false;
+    }
+  }
+  /**
+   * 手动同步订单到后端
+   * 
+   * 用于强制同步订单到后端，特别适用于纯代金券支付完成的订单
+   */
+  async manualSyncOrderAsync() {
+    var _a;
+    try {
+      if (!this.store.currentOrder) {
+        return {
+          success: false,
+          message: "当前没有活跃订单，无法同步"
+        };
+      }
+      const orderUuid = this.store.currentOrder.uuid;
+      const oldOrderId = this.store.currentOrder.order_id;
+      if (this.store.isOrderSynced) {
+        console.log("[Checkout] 订单已同步过，将执行更新操作");
+      }
+      console.log("[Checkout] 开始手动同步订单到后端:", {
+        orderUuid,
+        orderId: oldOrderId,
+        totalAmount: this.store.currentOrder.total_amount,
+        remainingAmount: this.calculateRemainingAmount()
+      });
+      const realOrderId = await this.syncOrderToBackendWithReturn(true);
+      console.log("[Checkout] 手动同步订单完成:", {
+        orderUuid,
+        oldOrderId,
+        realOrderId,
+        isOrderSynced: this.store.isOrderSynced
+      });
+      const finalOrderId = this.store.currentOrder.order_id;
+      const finalIsVirtual = this.isVirtualOrderId(finalOrderId);
+      console.log("[Checkout] manualSyncOrderAsync 最终状态验证:", {
+        返回的订单ID: realOrderId,
+        存储的订单ID: finalOrderId,
+        存储的ID是否虚拟: finalIsVirtual,
+        是否一致: realOrderId === finalOrderId,
+        同步状态: this.store.isOrderSynced
+      });
+      if (finalIsVirtual) {
+        console.error("[Checkout] 严重警告：手动同步完成后订单ID仍为虚拟ID！");
+      }
+      if (realOrderId !== finalOrderId) {
+        console.error("[Checkout] 严重警告：返回的订单ID与存储的订单ID不一致！");
+      }
+      return {
+        success: true,
+        message: "订单同步成功",
+        orderId: realOrderId,
+        // 直接返回从后端获取的真实订单ID
+        orderUuid
+      };
+    } catch (error) {
+      console.error("[Checkout] 手动同步订单失败:", error);
+      const errorMessage = error instanceof Error ? error.message : "同步失败";
+      return {
+        success: false,
+        message: `订单同步失败: ${errorMessage}`,
+        orderUuid: (_a = this.store.currentOrder) == null ? void 0 : _a.uuid
+      };
+    }
+  }
+  /**
+   * 获取当前订单备注
+   * 
+   * @returns 当前订单的备注内容，如果没有则返回空字符串
+   */
+  getOrderNote() {
+    if (!this.store.localOrderData) {
+      console.log("[Checkout] 没有本地订单数据，无法获取备注");
+      return "";
+    }
+    return this.store.localOrderData.shop_note || "";
+  }
+  /**
+   * 获取当前订单ID
+   * 
+   * @returns 当前订单的ID，如果没有订单则返回null
+   */
+  getCurrentOrderId() {
+    if (!this.store.currentOrder) {
+      return null;
+    }
+    return this.store.currentOrder.order_id;
+  }
+  /**
+   * 保存订单并稍后支付
+   * 
+   * 将当前订单保存到后端，但排除代金券类支付项(voucher_id)，
+   * 适用于用户想要保存订单但稍后完成支付的场景
+   */
+  async saveForLaterPaymentAsync() {
+    var _a;
+    try {
+      if (!this.store.currentOrder) {
+        return {
+          success: false,
+          message: "当前没有活跃订单，无法保存"
+        };
+      }
+      const orderUuid = this.store.currentOrder.uuid;
+      const currentOrderId = this.store.currentOrder.order_id;
+      console.log("[Checkout] 开始保存订单并稍后支付:", {
+        orderUuid,
+        orderId: currentOrderId,
+        totalAmount: this.store.currentOrder.total_amount
+      });
+      const allPaymentItems = await this.payment.getPaymentItemsAsync(this.store.currentOrder.uuid);
+      const filteredPaymentItems = allPaymentItems.filter(
+        (payment) => !payment.voucher_id || payment.voucher_id.trim() === ""
+      );
+      const voucherItems = allPaymentItems.filter(
+        (payment) => payment.voucher_id && payment.voucher_id.trim() !== ""
+      );
+      console.log("[Checkout] 支付项过滤结果:", {
+        总支付项: allPaymentItems.length,
+        过滤后支付项: filteredPaymentItems.length,
+        被过滤的代金券项: voucherItems.length,
+        代金券详情: voucherItems.map((item) => ({
+          uuid: item.uuid,
+          code: item.code,
+          amount: item.amount,
+          voucherId: item.voucher_id
+        })),
+        保留的支付项: filteredPaymentItems.map((item) => ({
+          uuid: item.uuid,
+          code: item.code,
+          amount: item.amount
+        }))
+      });
+      const realOrderId = await this.syncOrderToBackendWithReturn(false, filteredPaymentItems);
+      console.log("[Checkout] 保存订单完成:", {
+        orderUuid,
+        oldOrderId: currentOrderId,
+        realOrderId,
+        isOrderSynced: this.store.isOrderSynced,
+        filteredPaymentsCount: filteredPaymentItems.length
+      });
+      const finalOrderId = this.store.currentOrder.order_id;
+      console.log("[Checkout] saveForLaterPaymentAsync 最终状态验证:", {
+        返回的订单ID: realOrderId,
+        存储的订单ID: finalOrderId,
+        是否一致: realOrderId === finalOrderId,
+        同步状态: this.store.isOrderSynced
+      });
+      return {
+        success: true,
+        message: "订单保存成功，可稍后继续支付",
+        orderId: realOrderId,
+        orderUuid
+      };
+    } catch (error) {
+      console.error("[Checkout] 保存订单失败:", error);
+      const errorMessage = error instanceof Error ? error.message : "保存失败";
+      return {
+        success: false,
+        message: `订单保存失败: ${errorMessage}`,
+        orderUuid: (_a = this.store.currentOrder) == null ? void 0 : _a.uuid
+      };
+    }
+  }
+  /**
+   * 获取当前商店折扣金额
+   * 
+   * @returns 当前的商店折扣金额，如果没有则返回0
+   */
+  getShopDiscount() {
+    var _a;
+    if (((_a = this.store.localOrderData) == null ? void 0 : _a.shop_discount) !== void 0) {
+      return this.store.localOrderData.shop_discount;
+    }
+    if (this.store.cartSummary) {
+      const shopDiscountItem = this.store.cartSummary.find((item) => item.key === "shop_discount");
+      if (shopDiscountItem) {
+        return shopDiscountItem.value;
+      }
+    }
+    return 0;
+  }
+  /**
+   * 更新订单商店折扣
+   * 
+   * 同时更新cartSummary和localOrderData中的shop_discount值
+   * 
+   * @param discountAmount 商店折扣金额
+   */
+  async updateShopDiscountAsync(discountAmount) {
+    var _a, _b;
+    try {
+      const oldDiscount = this.getShopDiscount();
+      console.log("[Checkout] 更新商店折扣:", {
+        orderUuid: (_a = this.store.currentOrder) == null ? void 0 : _a.uuid,
+        oldDiscount,
+        newDiscount: discountAmount
+      });
+      if (this.store.cartSummary) {
+        const shopDiscountItem = this.store.cartSummary.find((item) => item.key === "shop_discount");
+        if (shopDiscountItem) {
+          shopDiscountItem.value = discountAmount;
+          console.log("[Checkout] cartSummary 中的商店折扣已更新");
+        } else {
+          this.store.cartSummary.push({
+            key: "shop_discount",
+            value: discountAmount,
+            hidden: true,
+            label: "Shop Discount"
+          });
+          console.log("[Checkout] cartSummary 中已添加新的商店折扣项");
+        }
+      }
+      if (this.store.localOrderData) {
+        this.store.localOrderData.shop_discount = discountAmount;
+        console.log("[Checkout] localOrderData 中的商店折扣已更新");
+      } else {
+        console.warn("[Checkout] localOrderData 不存在，无法更新商店折扣");
+      }
+      if (this.store.currentOrder && 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;
+      }
+      await this.updateStateAmountToRemaining();
+      await this.core.effects.emit(import_types.CheckoutHooks.OnShopDiscountChanged, {
+        orderUuid: (_b = this.store.currentOrder) == null ? void 0 : _b.uuid,
+        oldDiscount,
+        newDiscount: discountAmount,
+        timestamp: Date.now()
+      });
+      console.log("[Checkout] 商店折扣更新成功:", {
+        oldDiscount,
+        newDiscount: discountAmount
+      });
+    } catch (error) {
+      console.error("[Checkout] 更新商店折扣失败:", error);
+      await this.handleError(error, import_types.CheckoutErrorType.ValidationFailed);
+      throw error;
+    }
+  }
+  /**
+   * 更新订单备注
+   * 
+   * @param note 订单备注内容
+   */
+  async updateOrderNoteAsync(note) {
+    var _a, _b;
+    try {
+      if (!this.store.localOrderData) {
+        throw (0, import_utils.createCheckoutError)(
+          import_types.CheckoutErrorType.ValidationFailed,
+          "没有本地订单数据，无法更新备注"
+        );
+      }
+      console.log("[Checkout] 更新订单备注:", {
+        orderUuid: (_a = this.store.currentOrder) == null ? void 0 : _a.uuid,
+        oldNote: this.store.localOrderData.shop_note,
+        newNote: note
+      });
+      const oldNote = this.store.localOrderData.shop_note;
+      this.store.localOrderData.shop_note = note;
+      if (this.store.currentOrder) {
+        try {
+          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);
+        }
+      }
+      await this.core.effects.emit(import_types.CheckoutHooks.OnOrderNoteChanged, {
+        orderUuid: (_b = this.store.currentOrder) == null ? void 0 : _b.uuid,
+        oldNote,
+        newNote: note,
+        timestamp: Date.now()
+      });
+      console.log("[Checkout] 订单备注更新成功:", {
+        oldNote,
+        newNote: note
+      });
+    } catch (error) {
+      console.error("[Checkout] 更新订单备注失败:", error);
+      await this.handleError(error, import_types.CheckoutErrorType.ValidationFailed);
+      throw error;
+    }
+  }
+  /**
+   * 设置状态
+   */
+  async setStatus(status) {
+    const oldStatus = this.store.status;
+    this.store.status = status;
+    await this.core.effects.emit(import_types.CheckoutHooks.OnStatusChanged, {
+      oldStatus,
+      newStatus: status,
+      timestamp: Date.now()
+    });
+  }
+  /**
+   * 设置步骤
+   */
+  async setStep(step) {
+    const oldStep = this.store.step;
+    this.store.step = step;
+    await this.core.effects.emit(import_types.CheckoutHooks.OnStepChanged, {
+      oldStep,
+      newStep: step,
+      timestamp: Date.now()
+    });
+  }
+  /**
+   * 处理错误
+   */
+  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.setStatus(import_types.CheckoutStatus.Error);
+    await this.core.effects.emit(import_types.CheckoutHooks.OnError, {
+      error: checkoutError,
+      context: { status: this.store.status, step: this.store.step },
+      timestamp: Date.now()
+    });
+    console.error("[Checkout] 错误:", checkoutError);
+  }
+  /**
+   * 处理支付成功
+   */
+  async handlePaymentSuccess(data) {
+    var _a;
+    await this.setStatus(import_types.CheckoutStatus.PaymentCompleted);
+    await this.updateStateAmountToRemaining();
+    await this.core.effects.emit(import_types.CheckoutHooks.OnPaymentSuccess, {
+      orderUuid: data.orderUuid,
+      paymentMethodCode: "",
+      amount: ((_a = this.store.currentOrder) == null ? void 0 : _a.total_amount) || "0",
+      timestamp: data.timestamp
+    });
+    await this.completeCheckoutAsync();
+  }
+  /**
+   * 处理支付错误
+   */
+  async handlePaymentError(data) {
+    var _a;
+    const error = (0, import_utils.createCheckoutError)(
+      import_types.CheckoutErrorType.PaymentFailed,
+      data.error || "支付同步失败"
+    );
+    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: "",
+      amount: ((_a = this.store.currentOrder) == null ? void 0 : _a.total_amount) || "0",
+      timestamp: data.timestamp
+    });
+  }
+  /**
+   * 验证结账参数
+   */
+  async validateCheckoutParams(params) {
+    return (0, import_utils.validateCheckoutData)(params);
+  }
+  /**
+   * 验证本地订单数据
+   */
+  async validateLocalOrderData(orderData) {
+    const errors = [];
+    if (!orderData.type) {
+      errors.push("订单类型不能为空");
+    }
+    if (!orderData.platform) {
+      errors.push("平台信息不能为空");
+    }
+    if (!orderData.bookings || orderData.bookings.length === 0) {
+      errors.push("预订信息不能为空");
+    }
+    if (orderData.bookings) {
+      orderData.bookings.forEach((booking, index) => {
+        if (!booking.product || !booking.product.product_id) {
+          errors.push(`预订项 ${index + 1} 缺少商品信息`);
+        }
+        if (!booking.start_date) {
+          errors.push(`预订项 ${index + 1} 缺少开始日期`);
+        }
+        if (!booking.start_time) {
+          errors.push(`预订项 ${index + 1} 缺少开始时间`);
+        }
+      });
+    }
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  }
+  /**
+   * 生成本地订单ID
+   */
+  generateLocalOrderId() {
+    const timestamp = Date.now();
+    const random = Math.floor(Math.random() * 1e4).toString().padStart(4, "0");
+    return `local_order_${timestamp}_${random}`;
+  }
+  /**
+   * 格式化日期时间为 YYYY-MM-DD hh:mm:ss 格式
+   * 
+   * @param date 要格式化的日期对象
+   * @returns 格式化后的日期时间字符串
+   */
+  formatDateTime(date) {
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, "0");
+    const day = String(date.getDate()).padStart(2, "0");
+    const hours = String(date.getHours()).padStart(2, "0");
+    const minutes = String(date.getMinutes()).padStart(2, "0");
+    const seconds = String(date.getSeconds()).padStart(2, "0");
+    return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
+  }
+  /**
+   * 从购物车小计数据中提取金额信息
+   */
+  extractAmountFromCartSummary(cartSummary) {
+    const result = {
+      totalAmount: "0.00",
+      subTotal: "0.00",
+      taxAmount: "0.00",
+      discountAmount: "0.00",
+      shopDiscountAmount: "0.00",
+      roundingAmount: "0.00"
+    };
+    cartSummary.forEach((item) => {
+      const value = Number(item.value).toFixed(2);
+      switch (item.key) {
+        case "expect_amount":
+          result.totalAmount = value;
+          break;
+        case "sub_total":
+          result.subTotal = value;
+          break;
+        case "tax":
+          result.taxAmount = value;
+          if (item.tax) {
+            result.taxDetails = item.tax;
+          }
+          break;
+        case "discount":
+          result.discountAmount = value;
+          break;
+        case "shop_discount":
+          result.shopDiscountAmount = value;
+          break;
+        case "custom_roundingAmount":
+          result.roundingAmount = value;
+          break;
+        default:
+          if (item.key.includes("deposit")) {
+            result.depositAmount = value;
+          }
+          break;
+      }
+    });
+    console.log("[Checkout] 从购物车小计提取金额信息:", {
+      totalAmount: result.totalAmount,
+      subTotal: result.subTotal,
+      taxAmount: result.taxAmount,
+      discountAmount: result.discountAmount,
+      shopDiscountAmount: result.shopDiscountAmount,
+      roundingAmount: result.roundingAmount
+    });
+    return result;
+  }
+  /**
+   * 预加载支付方式（在初始化时调用）
+   */
+  async preloadPaymentMethods() {
+    try {
+      console.log("[Checkout] 预加载支付方式...");
+      const methods = await this.payment.getPayMethodListAsync();
+      this.store.paymentMethods = methods;
+      console.log(`[Checkout] 预加载完成，共 ${methods.length} 种支付方式`);
+    } catch (error) {
+      console.error("[Checkout] 预加载支付方式失败:", error);
+      this.store.paymentMethods = [];
+    }
+  }
+  /**
+   * 计算总金额
+   */
+  calculateTotalAmount(cartItems) {
+    const total = cartItems.reduce((sum, item) => {
+      const price = parseFloat(String(item.price) || "0");
+      const quantity = item.quantity || 1;
+      return sum + price * quantity;
+    }, 0);
+    return total.toFixed(2);
+  }
+  /**
+   * 计算已支付金额
+   */
+  calculatePaidAmount() {
+    if (!this.store.currentOrder) {
+      console.log("[Checkout] calculatePaidAmount: 没有当前订单");
+      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;
+  }
+  /**
+   * 计算剩余未支付金额
+   */
+  calculateRemainingAmount() {
+    if (!this.store.currentOrder) {
+      console.log("[Checkout] calculateRemainingAmount: 没有当前订单");
+      return "0.00";
+    }
+    const totalAmount = parseFloat(this.store.currentOrder.total_amount || "0");
+    const paidAmount = parseFloat(this.calculatePaidAmount());
+    const remainingAmount = totalAmount - paidAmount;
+    const result = Math.max(0, remainingAmount).toFixed(2);
+    console.log("[Checkout] calculateRemainingAmount: 计算详情:", {
+      orderUuid: this.store.currentOrder.uuid,
+      totalAmount: totalAmount.toFixed(2),
+      paidAmount: paidAmount.toFixed(2),
+      calculatedRemaining: remainingAmount.toFixed(2),
+      finalResult: result
+    });
+    return result;
+  }
+  /**
+   * 更新 stateAmount 为当前剩余未支付金额
+   */
+  async updateStateAmountToRemaining() {
+    var _a;
+    try {
+      const remainingAmount = this.calculateRemainingAmount();
+      const currentStateAmount = this.store.stateAmount;
+      console.log("[Checkout] updateStateAmountToRemaining: 状态检查:", {
+        calculatedRemainingAmount: remainingAmount,
+        currentStateAmount,
+        needsUpdate: remainingAmount !== currentStateAmount,
+        orderUuid: (_a = this.store.currentOrder) == null ? void 0 : _a.uuid
+      });
+      if (remainingAmount !== currentStateAmount) {
+        this.store.stateAmount = remainingAmount;
+        await this.core.effects.emit(import_types.CheckoutHooks.OnStateAmountChanged, {
+          oldAmount: currentStateAmount,
+          newAmount: remainingAmount,
+          timestamp: Date.now()
+        });
+        console.log("[Checkout] stateAmount 已自动更新为剩余金额:", {
+          oldAmount: currentStateAmount,
+          newAmount: remainingAmount
+        });
+      } else {
+        console.log("[Checkout] stateAmount 无需更新，当前值已是最新:", {
+          stateAmount: currentStateAmount,
+          remainingAmount
+        });
+      }
+      await this.checkOrderPaymentCompletion();
+    } catch (error) {
+      console.error("[Checkout] 更新 stateAmount 为剩余金额失败:", error);
+    }
+  }
+  /**
+   * 检查订单支付是否完成
+   * 
+   * 当剩余待付款金额 <= 0 时，触发订单支付完成事件
+   */
+  async checkOrderPaymentCompletion() {
+    var _a, _b;
+    try {
+      if (!this.store.currentOrder) {
+        return;
+      }
+      const remainingAmount = this.calculateRemainingAmount();
+      const remainingValue = parseFloat(remainingAmount);
+      if (remainingValue <= 0) {
+        const totalAmount = this.store.currentOrder.total_amount;
+        const paidAmount = this.calculatePaidAmount();
+        console.log("[Checkout] 检测到订单支付完成:", {
+          orderUuid: this.store.currentOrder.uuid,
+          orderId: this.store.currentOrder.order_id,
+          totalAmount,
+          paidAmount,
+          remainingAmount,
+          isOrderSynced: this.store.isOrderSynced
+        });
+        const allPaymentsHaveVoucherId = this.store.currentOrder.payment && this.store.currentOrder.payment.length > 0 && this.store.currentOrder.payment.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,
+          allHaveVoucherId: allPaymentsHaveVoucherId,
+          paymentItems: (_b = this.store.currentOrder.payment) == null ? void 0 : _b.map((p) => ({
+            uuid: p.uuid,
+            code: p.code,
+            amount: p.amount,
+            voucher_id: p.voucher_id,
+            status: p.status
+          }))
+        });
+        if (!this.store.isOrderSynced) {
+          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,
+          orderId: this.store.currentOrder.order_id,
+          totalAmount,
+          paidAmount,
+          remainingAmount,
+          timestamp: Date.now()
+        });
+      }
+    } catch (error) {
+      console.error("[Checkout] 检查订单支付完成状态失败:", error);
+    }
+  }
+  /**
+   * 判断支付方式是否需要同步订单到后端
+   * 
+   * 现金支付(CASHMANUAL)和自定义支付不需要同步，其他支付方式需要同步
+   * 
+   * @param paymentCode 支付方式代码
+   * @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))) {
+      return false;
+    }
+    if (paymentCode === import_types2.PaymentMethodType.Cash || paymentType === import_types2.PaymentMethodType.Cash) {
+      return false;
+    }
+    if (codeUpper.includes("CUSTOM") || typeUpper.includes("CUSTOM")) {
+      return false;
+    }
+    return true;
+  }
+  /**
+   * 同步订单到后端
+   * 
+   * 调用后端 /order/checkout 接口创建真实订单
+   */
+  /**
+   * 判断订单ID是否为本地生成的虚拟ID
+   * 
+   * @param orderId 订单ID
+   * @returns true 表示是虚拟ID，false 表示是真实的后端ID
+   */
+  isVirtualOrderId(orderId) {
+    return orderId.startsWith("local_order_");
+  }
+  /**
+   * 同步订单到后端并返回真实订单ID
+   * 
+   * @param isManual 是否为手动同步，默认为 false
+   * @param customPaymentItems 自定义支付项列表，如果提供则使用此列表而不是从数据库获取
+   * @returns 后端返回的真实订单ID
+   */
+  async syncOrderToBackendWithReturn(isManual = false, customPaymentItems) {
+    var _a, _b, _c, _d;
+    if (!this.store.localOrderData || !this.store.currentOrder) {
+      throw new Error("缺少必要的订单数据，无法同步到后端");
+    }
+    const syncType = isManual ? "手动" : "自动";
+    const currentOrderId = this.store.currentOrder.order_id;
+    const hasRealOrderId = currentOrderId && !this.isVirtualOrderId(currentOrderId);
+    let isUpdateOperation = false;
+    let reason = "";
+    if (this.store.isOrderSynced) {
+      isUpdateOperation = true;
+      reason = "订单已同步过";
+    } else if (hasRealOrderId) {
+      isUpdateOperation = true;
+      reason = "有真实订单ID";
+    } else {
+      isUpdateOperation = false;
+      reason = "既未同步也无真实ID";
+    }
+    const operation = isUpdateOperation ? "更新" : "创建";
+    console.log("[Checkout] 操作类型判断详情:", {
+      currentOrderId,
+      hasRealOrderId,
+      isOrderSynced: this.store.isOrderSynced,
+      isManual,
+      reason,
+      finalDecision: operation
+    });
+    console.log(`[Checkout] 开始${syncType}${operation}订单到后端...`, {
+      currentOrderId,
+      isVirtualId: this.isVirtualOrderId(currentOrderId || ""),
+      operation,
+      orderUuid: this.store.currentOrder.uuid,
+      isOrderSynced: this.store.isOrderSynced
+    });
+    const paymentItems = customPaymentItems || await this.payment.getPaymentItemsAsync(this.store.currentOrder.uuid);
+    console.log("[Checkout] 获取到支付项:", {
+      count: paymentItems.length,
+      isCustomFiltered: !!customPaymentItems,
+      methods: paymentItems.map((p) => p.code),
+      totalAmount: paymentItems.reduce((sum, p) => sum + parseFloat(p.amount), 0).toFixed(2),
+      paymentDetails: paymentItems.map((p) => {
+        var _a2;
+        return {
+          uuid: p.uuid,
+          code: p.code,
+          amount: p.amount,
+          uniquePaymentNumber: (_a2 = p.metadata) == null ? void 0 : _a2.unique_payment_number,
+          voucherId: p.voucher_id
+        };
+      })
+    });
+    const orderParams = {
+      ...this.store.localOrderData,
+      type: this.store.localOrderData.type,
+      platform: this.store.localOrderData.platform,
+      payments: paymentItems,
+      // 添加支付项
+      customer_id: (_a = this.store.currentCustomer) == null ? void 0 : _a.customer_id,
+      // 添加客户ID
+      is_price_include_tax: this.otherParams.is_price_include_tax,
+      // core 有
+      tax_title: this.otherParams.tax_title,
+      // core 没有
+      tax_rate: this.otherParams.tax_rate,
+      // core 有
+      tax_country_code: this.otherParams.tax_country_code,
+      // core 没有
+      currency_code: this.otherParams.currency_code,
+      currency_symbol: this.otherParams.currency_symbol,
+      currency_format: this.otherParams.currency_format,
+      is_deposit: ((_b = this.store.currentOrder) == null ? void 0 : _b.is_deposit) || 0,
+      deposit_amount: ((_c = this.store.currentOrder) == null ? void 0 : _c.deposit_amount) || "0.00",
+      // surcharge_fee: this.otherParams.surcharge_fee,
+      // surcharges: ,
+      note: this.store.localOrderData.shop_note
+      // 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.log("[Checkout] 尝试数据修复：暂时不包含order_id，让后端处理");
+        console.log("[Checkout] 注意：这次调用将作为创建操作处理，但后续会修复数据一致性");
+      } else {
+        orderParams.order_id = currentOrderId;
+        console.log(`[Checkout] 更新订单操作，包含订单ID: ${currentOrderId}`);
+      }
+    } else {
+      console.log("[Checkout] 创建新订单操作");
+    }
+    const checkoutResponse = await this.order.createOrderByCheckout(orderParams);
+    console.log("[Checkout] 后端返回的响应数据:", {
+      status: checkoutResponse == null ? void 0 : checkoutResponse.status,
+      code: checkoutResponse == null ? void 0 : checkoutResponse.code,
+      message: checkoutResponse == null ? void 0 : checkoutResponse.message,
+      data: checkoutResponse == null ? void 0 : checkoutResponse.data
+    });
+    let realOrderId;
+    if (isUpdateOperation) {
+      realOrderId = currentOrderId;
+      console.log(`[Checkout] 订单更新成功，订单ID: ${realOrderId}`);
+    } else {
+      let extractedOrderId = (_d = checkoutResponse == null ? void 0 : checkoutResponse.data) == null ? void 0 : _d.order_id;
+      if (!extractedOrderId) {
+        extractedOrderId = checkoutResponse == null ? void 0 : checkoutResponse.order_id;
+      }
+      if (extractedOrderId !== void 0 && extractedOrderId !== null) {
+        extractedOrderId = String(extractedOrderId);
+      }
+      if (!extractedOrderId) {
+        throw new Error("后端返回的订单信息中未包含订单ID");
+      }
+      realOrderId = extractedOrderId;
+      console.log("[Checkout] 订单创建成功，真实订单ID:", realOrderId);
+      console.log("[Checkout] 准备替换订单ID:", {
+        orderUuid: this.store.currentOrder.uuid,
+        oldOrderId: this.store.currentOrder.order_id,
+        newOrderId: realOrderId
+      });
+      try {
+        const updatedOrder = await this.payment.replaceOrderIdByUuidAsync(
+          this.store.currentOrder.uuid,
+          realOrderId
+        );
+        console.log("[Checkout] Payment模块替换订单ID结果:", {
+          wasSuccessful: !!updatedOrder,
+          returnedOrderId: updatedOrder == null ? void 0 : updatedOrder.order_id,
+          expectedOrderId: realOrderId
+        });
+        if (updatedOrder) {
+          console.log("[Checkout] Payment模块返回的更新后订单:", {
+            uuid: updatedOrder.uuid,
+            orderId: updatedOrder.order_id,
+            totalAmount: updatedOrder.total_amount
+          });
+          this.store.currentOrder = updatedOrder;
+          console.log("[Checkout] 订单ID替换成功，当前订单ID:", this.store.currentOrder.order_id);
+        } else {
+          console.error("[Checkout] Payment模块返回空订单，订单ID替换失败，开始手动替换");
+          const beforeManualUpdate = this.store.currentOrder.order_id;
+          this.store.currentOrder.order_id = realOrderId;
+          console.log("[Checkout] 手动设置订单ID:", {
+            替换前: beforeManualUpdate,
+            替换后: this.store.currentOrder.order_id,
+            目标ID: realOrderId
+          });
+        }
+      } catch (error) {
+        console.error("[Checkout] 调用Payment模块替换订单ID时发生错误:", error);
+        this.store.currentOrder.order_id = realOrderId;
+        console.log("[Checkout] 错误恢复：手动设置订单ID:", realOrderId);
+      }
+    }
+    this.store.isOrderSynced = true;
+    await this.core.effects.emit(import_types.CheckoutHooks.OnOrderSynced, {
+      orderUuid: this.store.currentOrder.uuid,
+      realOrderId,
+      virtualOrderId: this.store.currentOrder.order_id,
+      timestamp: Date.now(),
+      isManual
+    });
+    const finalOrderId = this.store.currentOrder.order_id;
+    const finalIsVirtual = this.isVirtualOrderId(finalOrderId || "");
+    console.log(`[Checkout] ${syncType}${operation}订单到后端完成`, {
+      返回的订单ID: realOrderId,
+      当前存储的订单ID: finalOrderId,
+      是否还是虚拟ID: finalIsVirtual,
+      是否同步: this.store.isOrderSynced
+    });
+    if (finalIsVirtual && !isUpdateOperation) {
+      console.warn("[Checkout] 警告：订单创建后，当前订单ID仍然是虚拟ID，可能存在问题");
+    }
+    return realOrderId;
+  }
+  async syncOrderToBackend() {
+    try {
+      await this.syncOrderToBackendWithReturn(false);
+    } catch (error) {
+      console.error("[Checkout] 同步订单到后端失败:", error);
+      await this.handleError(
+        new Error(`订单同步失败: ${error instanceof Error ? error.message : String(error)}`),
+        import_types.CheckoutErrorType.OrderCreationFailed
+      );
+    }
+  }
+  /**
+   * 获取状态消息
+   */
+  getStatusMessage() {
+    var _a;
+    switch (this.store.status) {
+      case import_types.CheckoutStatus.Initializing:
+        return "正在初始化结账流程...";
+      case import_types.CheckoutStatus.Ready:
+        return "准备就绪，可以开始结账";
+      case import_types.CheckoutStatus.CreatingOrder:
+        return "正在创建订单...";
+      case import_types.CheckoutStatus.OrderCreated:
+        return "订单创建成功，请选择支付方式";
+      case import_types.CheckoutStatus.ProcessingPayment:
+        return "正在处理支付...";
+      case import_types.CheckoutStatus.PaymentCompleted:
+        return "支付完成";
+      case import_types.CheckoutStatus.Completed:
+        return "结账完成";
+      case import_types.CheckoutStatus.Cancelled:
+        return "结账已取消";
+      case import_types.CheckoutStatus.Error:
+        return ((_a = this.store.lastError) == null ? void 0 : _a.message) || "发生未知错误";
+      default:
+        return "";
+    }
+  }
+  async setOtherParams(params, { cover = false } = {}) {
+    if (cover) {
+      this.otherParams = params;
+    } else {
+      this.otherParams = { ...this.otherParams, ...params };
+    }
+  }
+  async destroy() {
+    var _a, _b, _c, _d;
+    this.payment.wallet.clearAllCache();
+    this.core.effects.offByModuleDestroy(this.name);
+    await ((_b = (_a = this.order) == null ? void 0 : _a.destroy) == null ? void 0 : _b.call(_a));
+    await ((_d = (_c = this.payment) == null ? void 0 : _c.destroy) == null ? void 0 : _d.call(_c));
+    this.core.unregisterModule(this);
+    console.log("[Checkout] 已销毁");
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CheckoutImpl,
+  ...require("./types")
+});