@pisell/pisellos 2.1.4 → 2.1.6

package/lib/solution/Checkout/index.js

@@ -0,0 +1,3002 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+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_decimal = __toESM(require("decimal.js"));
+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 插件支持");
+    }
+    const appPlugin = core.getPlugin("app");
+    if (!appPlugin) {
+      throw new Error("Checkout 解决方案需要 app 插件支持");
+    }
+    const app = appPlugin.getApp();
+    this.logger = app.logger;
+    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",
+      balanceDueAmount: "0.00",
+      cartSummary: void 0,
+      isOrderSynced: false,
+      currentCustomer: void 0
+    };
+    await this.initializeSubModules(core, options);
+    await this.preloadPaymentMethods();
+    await this.cleanupExpiredOrdersAsync();
+    this.setStatus(import_types.CheckoutStatus.Ready);
+    console.log("[Checkout] 初始化完成");
+    await this.core.effects.emit(import_types.CheckoutHooks.OnCheckoutInitialized, {
+      timestamp: Date.now()
+    });
+    this.logInfo("CheckoutModule initialized successfully");
+  }
+  /**
+   * 记录信息日志
+   */
+  logInfo(title, metadata) {
+    if (this.logger) {
+      this.logger.addLog({
+        type: "info",
+        title: `[CheckoutModule]  ${this.getCurrentOrderId()} ${title}`,
+        metadata: metadata || {}
+      });
+    }
+  }
+  /**
+   * 记录警告日志
+   */
+  logWarning(title, metadata) {
+    if (this.logger) {
+      this.logger.addLog({
+        type: "warning",
+        title: `[CheckoutModule] ${title}`,
+        metadata: metadata || {}
+      });
+    }
+  }
+  /**
+   * 记录错误日志
+   */
+  logError(title, metadata) {
+    if (this.logger) {
+      this.logger.addLog({
+        type: "error",
+        title: `[CheckoutModule] ${title}`,
+        metadata: metadata || {}
+      });
+    }
+  }
+  /**
+   * 初始化子模块
+   */
+  async initializeSubModules(core, options) {
+    var _a, _b;
+    core.registerModule(this.order, {
+      store: ((_a = options.store) == null ? void 0 : _a.order) || {},
+      otherParams: { ...this.otherParams, fatherModule: this.name }
+    });
+    core.registerModule(this.payment, {
+      store: ((_b = options.store) == null ? void 0 : _b.payment) || {},
+      otherParams: { ...this.otherParams, fatherModule: 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);
+      }
+    });
+    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;
+      }
+    );
+  }
+  /**
+   * 初始化结账流程
+   */
+  async initializeCheckoutAsync(params) {
+    var _a;
+    this.logInfo("initializeCheckoutAsync called", {
+      cartItemsCount: ((_a = params.cartItems) == null ? void 0 : _a.length) || 0,
+      orderType: params.orderType,
+      platform: params.platform
+    });
+    try {
+      this.setStatus(import_types.CheckoutStatus.Initializing);
+      const validation = this.validateCheckoutParams(params);
+      if (!validation.valid) {
+        throw (0, import_utils.createCheckoutError)(
+          import_types.CheckoutErrorType.ValidationFailed,
+          `参数验证失败: ${validation.errors.join(", ")}`
+        );
+      }
+      this.store.cartItems = params.cartItems;
+      this.setStatus(import_types.CheckoutStatus.Ready);
+      this.setStep(import_types.CheckoutStep.OrderConfirmation);
+      console.log("[Checkout] 结账流程初始化完成");
+    } catch (error) {
+      await this.handleError(error, import_types.CheckoutErrorType.UnknownError);
+      throw error;
+    }
+  }
+  getProductListByOrder() {
+    var _a, _b, _c, _d, _e;
+    if (!this.store.currentOrder) {
+      return [];
+    }
+    const getDiscountListAmount = (list) => {
+      return list.reduce((pre, item) => {
+        return pre + (item.amount || 0);
+      }, 0);
+    };
+    const productList = ((_b = (_a = this.store.currentOrder.order_info) == null ? void 0 : _a.original_order_data.bookings) == null ? void 0 : _b.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) - getDiscountListAmount(item.product.discount_list)
+      })
+    )) || [];
+    const relationProducts = ((_e = (_d = (_c = this.store.currentOrder.order_info) == null ? void 0 : _c.original_order_data) == null ? void 0 : _d.relation_products) == null ? void 0 : _e.map((item) => ({
+      product_id: item.product_id,
+      product_variant_id: item.product_variant_id,
+      quantity: item.num,
+      selling_price: item.source_product_price
+    }))) || [];
+    return [...productList, ...relationProducts];
+  }
+  async initWalletData(params) {
+    var _a, _b, _c, _d;
+    const amountInfo = (_b = (_a = this.store.currentOrder) == null ? void 0 : _a.order_info) == null ? void 0 : _b.amount_breakdown;
+    if (!amountInfo) {
+      return;
+    }
+    const walletBusinessData = {
+      customer_id: ((_c = this.store.currentCustomer) == null ? void 0 : _c.customer_id) ? Number(this.store.currentCustomer.customer_id) : void 0,
+      amountInfo: {
+        totalAmount: amountInfo.totalAmount,
+        subTotal: amountInfo.subTotal
+      },
+      products: this.getProductListByOrder(),
+      ...params
+    };
+    await this.payment.wallet.initializeWalletDataFromBusinessAsync(
+      walletBusinessData
+    );
+    await this.core.effects.emit(import_types.CheckoutHooks.OnWalletDataInitialized, {
+      orderUuid: (_d = this.store.currentOrder) == null ? void 0 : _d.uuid,
+      customerId: walletBusinessData.customer_id,
+      walletBusinessData: {
+        customer_id: walletBusinessData.customer_id,
+        amountInfo: walletBusinessData.amountInfo,
+        order_wait_pay_amount: params == null ? void 0 : params.order_wait_pay_amount
+      },
+      timestamp: Date.now()
+    });
+  }
+  /**
+   * 创建本地订单 (前端模拟下单流程)
+   *
+   * 此方法用于在前端模拟整个下单流程，创建一个本地的虚拟订单。
+   * 用户在购物车点击下单时，会把购物车参数传递给此方法，
+   * 方法会记录参数并创建本地虚拟订单，然后用 Payment 模块管理支付流程。
+   */
+  async createLocalOrderAsync(params) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p;
+    this.logInfo("createLocalOrderAsync called", {
+      orderDataType: (_a = params.orderData) == null ? void 0 : _a.type,
+      platform: (_b = params.orderData) == null ? void 0 : _b.platform,
+      bookingsCount: ((_d = (_c = params.orderData) == null ? void 0 : _c.bookings) == null ? void 0 : _d.length) || 0,
+      relationProductsCount: ((_f = (_e = params.orderData) == null ? void 0 : _e.relation_products) == null ? void 0 : _f.length) || 0,
+      customerId: (_g = params.orderData) == null ? void 0 : _g.customer_id,
+      autoPayment: params.autoPayment,
+      cartSummaryCount: ((_h = params.cartSummary) == null ? void 0 : _h.length) || 0,
+      totalInfoKeys: params.totalInfo ? Object.keys(params.totalInfo) : []
+    });
+    try {
+      console.time("createLocalOrderAsync");
+      await this.resetStoreStateAsync();
+      this.setStatus(import_types.CheckoutStatus.CreatingOrder);
+      const validation = (0, import_utils.validateLocalOrderData)(params.orderData);
+      if (!validation.valid) {
+        throw (0, import_utils.createCheckoutError)(
+          import_types.CheckoutErrorType.ValidationFailed,
+          `订单数据验证失败: ${validation.errors.join(", ")}`
+        );
+      }
+      const localOrderId = (0, import_utils.generateLocalOrderId)();
+      const amountInfo = (0, import_utils.extractAmountFromCartSummary)(params.cartSummary);
+      params.orderData.platform = "pos";
+      params.orderData.created_at = (0, import_utils.formatDateTime)(/* @__PURE__ */ new Date());
+      params.orderData.surcharge_fee = (_j = (_i = params.totalInfo) == null ? void 0 : _i.total) == null ? void 0 : _j.otherAmount;
+      params.orderData.surcharges = (_l = (_k = params.totalInfo) == null ? void 0 : _k.total) == null ? void 0 : _l.surcharge;
+      params.orderData.shop_discount = (_n = (_m = params.totalInfo) == null ? void 0 : _m.total) == null ? void 0 : _n.shopDiscount;
+      params.orderData.tax_fee = (_p = (_o = params.totalInfo) == null ? void 0 : _o.total) == null ? void 0 : _p.tax;
+      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
+        }
+      });
+      console.timeEnd("createLocalOrderAsync");
+      this.store.currentOrder = paymentOrder;
+      this.initWalletData();
+      this.setStatus(import_types.CheckoutStatus.OrderCreated);
+      this.setStep(import_types.CheckoutStep.PaymentMethod);
+      if (params.autoPayment) {
+        this.setStep(import_types.CheckoutStep.PaymentProcessing);
+      }
+      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
+      );
+      this.core.effects.emit(import_types.CheckoutHooks.OnOrderCreationFailed, {
+        error: this.store.lastError,
+        timestamp: Date.now()
+      });
+      throw error;
+    }
+  }
+  /**
+   * 手动下单 (根据虚拟订单生成实际订单)
+   *
+   * 使用当前存储的本地订单数据调用 Order 模块创建真实订单
+   */
+  async placeOrderAsync(params = {}) {
+    var _a, _b;
+    this.logInfo("placeOrderAsync called", {
+      url: params.url,
+      autoReplaceOrderId: params.autoReplaceOrderId,
+      hasLocalOrderData: !!this.store.localOrderData,
+      hasCurrentOrder: !!this.store.currentOrder,
+      currentOrderId: (_a = this.store.currentOrder) == null ? void 0 : _a.order_id,
+      isOrderSynced: this.store.isOrderSynced
+    });
+    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] 开始手动下单流程...");
+      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 = ((_b = orderResponse == null ? void 0 : orderResponse.data) == null ? void 0 : _b.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
+          });
+        }
+      }
+      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 {
+      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: (0, import_utils.calculateTotalAmount)(params.cartItems),
+        order_info: orderResponse == null ? void 0 : orderResponse.data
+      });
+      this.store.currentOrder = paymentOrder;
+      this.setStatus(import_types.CheckoutStatus.OrderCreated);
+      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,
+          "未找到当前订单，请先创建订单"
+        );
+      }
+      this.setStatus(import_types.CheckoutStatus.ProcessingPayment);
+      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") {
+        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();
+      this.setStatus(import_types.CheckoutStatus.Completed);
+      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);
+      await this.resetStoreStateAsync();
+      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.balanceDueAmount = "0.00";
+      this.store.isOrderSynced = false;
+      this.store.currentCustomer = void 0;
+      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 = await this.calculatePaidAmountAsync();
+    const remainingAmount = await this.calculateRemainingAmountAsync();
+    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() {
+    return await this.getPaymentMethodsAsync();
+  }
+  /**
+   * 刷新支付方式缓存
+   *
+   * 强制重新从服务器获取支付方式列表，更新本地缓存
+   */
+  async refreshPaymentMethodsAsync() {
+    console.log("[Checkout] 强制刷新支付方式缓存...");
+    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;
+    }
+  }
+  /**
+   * 获取订单原始数据
+   */
+  getOrderOriginalData() {
+    var _a;
+    return (_a = this.store.currentOrder) == null ? void 0 : _a.order_info;
+  }
+  /**
+   * 获取当前订单基础信息
+   *
+   * 返回当前订单的基础信息，包括订单状态、金额、支付状态等
+   */
+  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.logInfo("[Checkout] 设置自定义支付金额:", {
+        oldAmount,
+        newAmount: formattedAmount
+      });
+      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;
+  }
+  /**
+   * 获取系统计算的待付金额（只读）
+   *
+   * 此方法返回系统内部计算的实际待付金额，不允许外部修改
+   *
+   * @returns 当前系统计算的待付金额
+   */
+  getBalanceDueAmount() {
+    return this.store.balanceDueAmount;
+  }
+  /**
+   * 刷新 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 = (0, import_utils.extractAmountFromCartSummary)(
+      this.store.cartSummary
+    );
+    console.log("[Checkout] 获取提取的金额信息:", extractedInfo);
+    return extractedInfo;
+  }
+  /**
+   * 获取支付方式列表
+   *
+   * 优先使用 store 中的缓存数据，避免重复接口调用。
+   * 如果 store 中没有数据，则调用 Payment 模块的方法获取。
+   *
+   * @returns 支付方式列表
+   */
+  async getPaymentMethodsAsync() {
+    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 当前没有活跃订单时抛出错误
+   */
+  async addPaymentItemAsync(paymentItem) {
+    var _a, _b, _c, _d, _e, _f;
+    this.logInfo("addPaymentItemAsync called", {
+      paymentCode: paymentItem.code,
+      paymentType: paymentItem.type,
+      amount: paymentItem.amount,
+      voucherId: paymentItem.voucher_id,
+      serviceCharge: paymentItem.service_charge,
+      roundingAmount: paymentItem.rounding_amount,
+      hasMetadata: !!paymentItem.metadata,
+      hasCurrentOrder: !!this.store.currentOrder,
+      currentOrderId: (_a = this.store.currentOrder) == null ? void 0 : _a.order_id,
+      isDepositOrder: (_b = this.store.currentOrder) == null ? void 0 : _b.is_deposit
+    });
+    try {
+      if (!this.store.currentOrder) {
+        throw (0, import_utils.createCheckoutError)(
+          import_types.CheckoutErrorType.ValidationFailed,
+          "未找到当前订单，无法添加支付项"
+        );
+      }
+      const orderPaymentType = this.store.currentOrder.is_deposit === 1 ? "deposit" : "normal";
+      const processedPaymentItem = await this.processCashPaymentItem(paymentItem);
+      const metadata = {
+        ...processedPaymentItem.metadata,
+        rounding_rule: this.otherParams.order_rounding_setting,
+        shop_wallet_pass_id: this.otherParams.shop_wallet_pass_id
+      };
+      const paymentItemWithType = {
+        ...processedPaymentItem,
+        order_payment_type: orderPaymentType,
+        metadata
+      };
+      console.log("[Checkout] 为当前订单添加支付项:", {
+        orderUuid: this.store.currentOrder.uuid,
+        paymentItem: {
+          code: paymentItemWithType.code,
+          name: paymentItemWithType.name,
+          type: paymentItemWithType.type,
+          amount: paymentItemWithType.amount,
+          service_charge: paymentItemWithType.service_charge,
+          rounding_amount: paymentItemWithType.rounding_amount,
+          voucher_id: paymentItemWithType.voucher_id,
+          order_payment_type: paymentItemWithType.order_payment_type,
+          metadata: paymentItemWithType.metadata
+        },
+        orderDepositStatus: this.store.currentOrder.is_deposit,
+        calculatedOrderPaymentType: orderPaymentType,
+        // 现金支付找零详情
+        isCashPayment: this.isCashPayment(paymentItem.code, paymentItem.type),
+        originalAmount: paymentItem.amount,
+        processedAmount: paymentItemWithType.amount,
+        actualPaidAmount: (_c = paymentItemWithType.metadata) == null ? void 0 : _c.actual_paid_amount,
+        changeGivenAmount: (_d = paymentItemWithType.metadata) == null ? void 0 : _d.change_given_amount
+      });
+      await this.payment.addPaymentItemAsync(
+        this.store.currentOrder.uuid,
+        paymentItemWithType
+      );
+      console.log("[Checkout] 支付项添加成功");
+      const isEftposPayment = ((_e = paymentItem.type) == null ? void 0 : _e.toLowerCase()) === "eftpos" || ((_f = paymentItem.code) == null ? void 0 : _f.toUpperCase().includes("EFTPOS"));
+      console.log("[Checkout] EFTPOS 支付检查:", {
+        paymentCode: paymentItem.code,
+        paymentType: paymentItem.type,
+        isEftposPayment,
+        currentOrderSynced: this.store.isOrderSynced
+      });
+      if (isEftposPayment) {
+        console.log("[Checkout] 检测到 EFTPOS 支付，立即同步订单到后端...");
+        try {
+          const syncResult = await this.syncOrderToBackendWithReturn(true);
+          console.log("[Checkout] EFTPOS 支付后订单同步完成 (已标记为手动同步):", {
+            orderId: syncResult.orderId,
+            isOrderSynced: this.store.isOrderSynced,
+            backendResponse: syncResult.response
+          });
+        } catch (error) {
+          console.error("[Checkout] EFTPOS 支付后订单同步失败:", error);
+          await this.handleError(
+            new Error(`EFTPOS 支付后订单同步失败: ${error instanceof Error ? error.message : String(error)}`),
+            import_types.CheckoutErrorType.OrderCreationFailed
+          );
+        }
+      }
+      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 currentPayments = await this.payment.getPaymentItemsAsync(
+        this.store.currentOrder.uuid,
+        true
+        // 包括已撤销的支付项，因为我们需要验证是否存在
+      );
+      const paymentItem = currentPayments.find((p) => p.uuid === paymentUuid);
+      if (!paymentItem) {
+        throw (0, import_utils.createCheckoutError)(
+          import_types.CheckoutErrorType.ValidationFailed,
+          `支付项不存在: ${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 && !(0, import_utils.isVirtualOrderId)(currentOrderId);
+      const updatedOrder = await this.payment.getPaymentOrderByUuidAsync(
+        this.store.currentOrder.uuid
+      );
+      if (updatedOrder) {
+        if (isCurrentOrderReal && (0, import_utils.isVirtualOrderId)(updatedOrder.order_id)) {
+          console.warn(
+            "[Checkout] deletePaymentItemAsync: 检测到订单ID回退，保护真实订单ID:",
+            {
+              currentRealId: currentOrderId,
+              retrievedVirtualId: 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
+      });
+      const orderPaymentType = this.store.currentOrder.is_deposit === 1 ? "deposit" : "normal";
+      const voucherPaymentItemsWithType = voucherPaymentItems.map((item) => {
+        if (!item.voucher_id) {
+          throw (0, import_utils.createCheckoutError)(
+            import_types.CheckoutErrorType.ValidationFailed,
+            `代金券支付项缺少 voucher_id: ${JSON.stringify(item)}`
+          );
+        }
+        const metadata = {
+          ...item.metadata,
+          rounding_rule: this.otherParams.order_rounding_setting,
+          shop_wallet_pass_id: this.otherParams.shop_wallet_pass_id
+        };
+        return {
+          ...item,
+          order_payment_type: orderPaymentType,
+          metadata
+        };
+      });
+      console.log("[Checkout] 代金券支付项订单支付类型设置:", {
+        orderDepositStatus: this.store.currentOrder.is_deposit,
+        calculatedOrderPaymentType: orderPaymentType,
+        itemsCount: voucherPaymentItemsWithType.length
+      });
+      await this.payment.updateVoucherPaymentItemsAsync(
+        this.store.currentOrder.uuid,
+        voucherPaymentItemsWithType
+      );
+      console.log("[Checkout] Payment模块批量更新完成");
+      const currentOrderId = this.store.currentOrder.order_id;
+      const isCurrentOrderReal = currentOrderId && !(0, import_utils.isVirtualOrderId)(currentOrderId);
+      const updatedOrder = await this.payment.getPaymentOrderByUuidAsync(
+        this.store.currentOrder.uuid
+      );
+      if (updatedOrder) {
+        if (isCurrentOrderReal && (0, import_utils.isVirtualOrderId)(updatedOrder.order_id)) {
+          console.warn(
+            "[Checkout] updateVoucherPaymentItemsAsync: 检测到订单ID回退，保护真实订单ID:",
+            {
+              currentRealId: currentOrderId,
+              retrievedVirtualId: 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但未同步的状态
+   * 从 Payment 模块获取最新的支付项数据
+   */
+  async needsManualSyncAsync() {
+    try {
+      if (!this.store.currentOrder || this.store.isOrderSynced) {
+        return false;
+      }
+      const remainingAmount = await this.calculateRemainingAmountAsync();
+      const remainingValue = new import_decimal.default(remainingAmount);
+      if (remainingValue.gt(0)) {
+        return false;
+      }
+      const currentPayments = await this.payment.getPaymentItemsAsync(
+        this.store.currentOrder.uuid,
+        false
+        // 不包括已撤销的支付项
+      );
+      const allPaymentsHaveVoucherId = currentPayments.length > 0 && currentPayments.every(
+        (item) => item.status !== "voided" && item.voucher_id
+      );
+      console.log("[Checkout] needsManualSyncAsync 检查结果:", {
+        orderUuid: this.store.currentOrder.uuid,
+        isOrderSynced: this.store.isOrderSynced,
+        remainingAmount,
+        hasPayments: currentPayments.length > 0,
+        allPaymentsHaveVoucherId,
+        needsManualSync: allPaymentsHaveVoucherId,
+        paymentItems: currentPayments.map((p) => ({
+          code: p.code,
+          amount: p.amount,
+          status: p.status,
+          hasVoucherId: !!p.voucher_id
+        }))
+      });
+      return allPaymentsHaveVoucherId;
+    } catch (error) {
+      console.error("[Checkout] needsManualSyncAsync 检查失败:", error);
+      return false;
+    }
+  }
+  /**
+   * 手动同步订单到后端
+   *
+   * 用于强制同步订单到后端，特别适用于纯代金券支付完成的订单
+   */
+  async manualSyncOrderAsync() {
+    var _a, _b, _c, _d;
+    this.logInfo("manualSyncOrderAsync called", {
+      hasCurrentOrder: !!this.store.currentOrder,
+      currentOrderId: (_a = this.store.currentOrder) == null ? void 0 : _a.order_id,
+      orderUuid: (_b = this.store.currentOrder) == null ? void 0 : _b.uuid,
+      totalAmount: (_c = this.store.currentOrder) == null ? void 0 : _c.total_amount,
+      isOrderSynced: this.store.isOrderSynced,
+      isVirtualOrderId: this.store.currentOrder ? (0, import_utils.isVirtualOrderId)(this.store.currentOrder.order_id) : false
+    });
+    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: await this.calculateRemainingAmountAsync()
+      });
+      const syncResult = await this.syncOrderToBackendWithReturn(true);
+      console.log("[Checkout] 手动同步订单完成:", {
+        orderUuid,
+        syncResult,
+        oldOrderId,
+        realOrderId: syncResult.orderId,
+        isOrderSynced: this.store.isOrderSynced
+      });
+      const finalOrderId = this.store.currentOrder.order_id;
+      const finalIsVirtual = (0, import_utils.isVirtualOrderId)(finalOrderId);
+      console.log("[Checkout] manualSyncOrderAsync 最终状态验证:", {
+        returnedOrderId: syncResult.orderId,
+        storedOrderId: finalOrderId,
+        storedIdIsVirtual: finalIsVirtual,
+        isConsistent: syncResult.orderId === finalOrderId,
+        syncStatus: this.store.isOrderSynced
+      });
+      if (finalIsVirtual) {
+        console.error("[Checkout] 严重警告：手动同步完成后订单ID仍为虚拟ID！");
+      }
+      if (syncResult.orderId !== finalOrderId) {
+        console.error(
+          "[Checkout] 严重警告：返回的订单ID与存储的订单ID不一致！"
+        );
+      }
+      return syncResult;
+    } catch (error) {
+      console.error("[Checkout] 手动同步订单失败:", error);
+      const errorMessage = error instanceof Error ? error.message : "同步失败";
+      return {
+        success: false,
+        message: `订单同步失败: ${errorMessage}`,
+        orderUuid: (_d = this.store.currentOrder) == null ? void 0 : _d.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;
+  }
+  /**
+   * 获取当前订单是否已同步到后端
+   *
+   * @returns 当前订单是否已同步状态，如果没有订单则返回false
+   */
+  isCurrentOrderSynced() {
+    if (!this.store.currentOrder) {
+      console.log("[Checkout] 没有当前订单，同步状态为false");
+      return false;
+    }
+    const syncStatus = this.store.isOrderSynced;
+    console.log("[Checkout] 当前订单同步状态:", {
+      orderUuid: this.store.currentOrder.uuid,
+      orderId: this.store.currentOrder.order_id,
+      isOrderSynced: syncStatus
+    });
+    return syncStatus;
+  }
+  /**
+   * 取消当前本地订单
+   *
+   * 只能取消未同步到后端的本地订单，如果订单已同步则不能取消
+   *
+   * @param cancelReason 取消原因（可选）
+   * @returns 取消结果
+   */
+  async cancelCurrentOrderAsync(cancelReason) {
+    var _a, _b;
+    try {
+      console.log("[Checkout] 开始取消当前本地订单:", {
+        hasCurrentOrder: !!this.store.currentOrder,
+        orderUuid: (_a = this.store.currentOrder) == null ? void 0 : _a.uuid,
+        orderId: (_b = this.store.currentOrder) == null ? void 0 : _b.order_id,
+        isOrderSynced: this.store.isOrderSynced,
+        cancelReason
+      });
+      if (!this.store.currentOrder) {
+        console.log("[Checkout] 没有当前订单，无需取消");
+        return {
+          success: false,
+          message: "没有当前订单可取消"
+        };
+      }
+      const currentOrderUuid = this.store.currentOrder.uuid;
+      const currentOrderId = this.store.currentOrder.order_id;
+      const isOrderSynced = this.store.isOrderSynced;
+      if (isOrderSynced) {
+        console.log("[Checkout] 订单已同步到后端，不能取消:", {
+          orderId: currentOrderId,
+          orderUuid: currentOrderUuid
+        });
+        return {
+          success: false,
+          message: "订单已同步到后端，无法取消",
+          orderId: currentOrderId
+        };
+      }
+      console.log("[Checkout] 订单尚未同步，可以取消");
+      try {
+        console.log("[Checkout] 删除本地订单数据");
+        await this.payment.deletePaymentOrderAsync(currentOrderUuid);
+        console.log("[Checkout] 本地订单数据删除成功");
+      } catch (error) {
+        console.warn("[Checkout] 删除本地订单数据失败，但继续执行:", error);
+      }
+      console.log("[Checkout] 清理订单相关状态");
+      this.store.currentOrder = void 0;
+      this.store.localOrderData = void 0;
+      this.store.stateAmount = "0.00";
+      this.store.balanceDueAmount = "0.00";
+      this.store.isOrderSynced = false;
+      this.store.currentCustomer = void 0;
+      this.payment.wallet.clearAllCache();
+      console.log("[Checkout] 订单状态清理完成，currentOrder已释放");
+      await this.core.effects.emit(import_types.CheckoutHooks.OnOrderCancelled, {
+        orderUuid: currentOrderUuid,
+        orderId: currentOrderId,
+        cancelReason,
+        wasSynced: false,
+        // 只有未同步订单可以被取消
+        timestamp: Date.now()
+      });
+      console.log("[Checkout] 本地订单取消完成:", {
+        orderUuid: currentOrderUuid,
+        orderId: currentOrderId,
+        cancelReason
+      });
+      return {
+        success: true,
+        message: "本地订单已成功取消",
+        orderId: currentOrderId
+      };
+    } catch (error) {
+      console.error("[Checkout] 取消本地订单失败:", error);
+      const errorMessage = error instanceof Error ? error.message : "未知错误";
+      return {
+        success: false,
+        message: `取消订单失败: ${errorMessage}`
+      };
+    }
+  }
+  /**
+   * 保存订单并稍后支付
+   *
+   * 将当前订单保存到后端，但排除代金券类支付项(voucher_id)，
+   * 适用于用户想要保存订单但稍后完成支付的场景
+   */
+  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 syncResult = await this.syncOrderToBackendWithReturn(
+        false,
+        allPaymentItems
+      );
+      console.log("[Checkout] 保存订单完成:", {
+        orderUuid,
+        oldOrderId: currentOrderId,
+        syncResult,
+        realOrderId: syncResult.orderId,
+        isOrderSynced: this.store.isOrderSynced,
+        filteredPaymentsCount: allPaymentItems.length
+      });
+      const finalOrderId = this.store.currentOrder.order_id;
+      console.log("[Checkout] saveForLaterPaymentAsync 最终状态验证:", {
+        returnedOrderId: syncResult.orderId,
+        storedOrderId: finalOrderId,
+        isConsistent: syncResult.orderId === finalOrderId,
+        syncStatus: this.store.isOrderSynced
+      });
+      return {
+        success: true,
+        message: "订单保存成功，可稍后继续支付",
+        orderId: syncResult.orderId,
+        orderUuid,
+        response: syncResult.response
+      };
+    } 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 = (0, import_utils.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;
+    }
+  }
+  /**
+   * 设置状态
+   */
+  setStatus(status) {
+    const oldStatus = this.store.status;
+    this.store.status = status;
+    this.core.effects.emit(import_types.CheckoutHooks.OnStatusChanged, {
+      oldStatus,
+      newStatus: status,
+      timestamp: Date.now()
+    });
+  }
+  /**
+   * 设置步骤
+   */
+  setStep(step) {
+    const oldStep = this.store.step;
+    this.store.step = step;
+    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;
+    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;
+    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
+    });
+  }
+  /**
+   * 验证结账参数
+   */
+  validateCheckoutParams(params) {
+    return (0, import_utils.validateCheckoutData)(params);
+  }
+  /**
+   * 处理现金支付项的找零逻辑
+   * 
+   * @param paymentItem 原始支付项
+   * @returns 处理后的支付项（包含找零信息）
+   */
+  async processCashPaymentItem(paymentItem) {
+    const isCashPayment = this.isCashPayment(paymentItem.code, paymentItem.type);
+    if (!isCashPayment) {
+      return paymentItem;
+    }
+    try {
+      const remainingAmountStr = await this.calculateRemainingAmountAsync();
+      let remainingAmount = new import_decimal.default(remainingAmountStr);
+      const cashAmount = new import_decimal.default(String(paymentItem.amount));
+      console.log("[Checkout] 现金支付处理:", {
+        cashAmount: cashAmount.toNumber(),
+        remainingAmount: remainingAmount.toNumber(),
+        needsChange: cashAmount.gt(remainingAmount)
+      });
+      if (cashAmount.lte(remainingAmount)) {
+        return paymentItem;
+      }
+      const changeAmount = cashAmount.sub(remainingAmount);
+      if (Number(paymentItem.rounding_amount) > 0) {
+        if (Number(paymentItem.rounding_amount) === changeAmount.toNumber()) {
+          return paymentItem;
+        } else {
+          remainingAmount = remainingAmount.add(new import_decimal.default(paymentItem.rounding_amount || "0"));
+        }
+      }
+      console.log("[Checkout] 现金支付需要找零:", {
+        actualPaidAmount: cashAmount.toFixed(2),
+        chargedAmount: remainingAmount.toFixed(2),
+        changeGivenAmount: changeAmount.toFixed(2)
+      });
+      const processedPaymentItem = {
+        ...paymentItem,
+        amount: remainingAmount.toFixed(2),
+        // 将 amount 设置为剩余待付金额，保留2位小数
+        metadata: {
+          ...paymentItem.metadata,
+          actual_paid_amount: cashAmount.toNumber(),
+          // 实付金额
+          change_given_amount: changeAmount.toNumber()
+          // 找零金额
+        }
+      };
+      this.logInfo("Cash payment with change processed", {
+        originalAmount: cashAmount.toFixed(2),
+        chargedAmount: remainingAmount.toFixed(2),
+        changeAmount: changeAmount.toFixed(2),
+        paymentCode: paymentItem.code,
+        paymentType: paymentItem.type,
+        // 额外的精度验证信息
+        decimalPrecisionCheck: {
+          cashAmountPrecise: cashAmount.toString(),
+          remainingAmountPrecise: remainingAmount.toString(),
+          changeAmountPrecise: changeAmount.toString()
+        }
+      });
+      return processedPaymentItem;
+    } catch (error) {
+      console.error("[Checkout] 处理现金支付项时出错:", error);
+      return paymentItem;
+    }
+  }
+  /**
+   * 判断是否为现金支付
+   * 
+   * @param paymentCode 支付代码
+   * @param paymentType 支付类型
+   * @returns 是否为现金支付
+   */
+  isCashPayment(paymentCode, paymentType) {
+    const codeUpper = (paymentCode == null ? void 0 : paymentCode.toUpperCase()) || "";
+    const typeUpper = (paymentType == null ? void 0 : paymentType.toUpperCase()) || "";
+    const cashIdentifiers = ["CASH", "CASHMANUAL", "MANUAL"];
+    return cashIdentifiers.some(
+      (identifier) => codeUpper.includes(identifier) || typeUpper.includes(identifier)
+    );
+  }
+  /**
+   * 预加载支付方式（在初始化时调用）
+   */
+  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 = [];
+    }
+  }
+  /**
+   * 清理过期的已同步订单数据
+   * 
+   * 删除本地 IndexDB 中超过指定天数且已同步到后端的订单数据
+   */
+  async cleanupExpiredOrdersAsync() {
+    var _a, _b, _c;
+    try {
+      const cleanupConfig = this.otherParams.orderDataCleanup || {};
+      const isCleanupEnabled = cleanupConfig.enabled !== false;
+      const retentionDays = cleanupConfig.retentionDays || 7;
+      const maxOrdersToDelete = cleanupConfig.maxOrdersToDelete || 100;
+      if (!isCleanupEnabled) {
+        console.log("[Checkout] 订单数据清理功能已禁用");
+        return;
+      }
+      console.log(`[Checkout] 开始清理过期订单数据（保留 ${retentionDays} 天内的数据）...`);
+      const allOrders = await this.payment.getOrderListAsync();
+      if (!allOrders || allOrders.length === 0) {
+        console.log("[Checkout] 没有找到需要清理的订单数据");
+        return;
+      }
+      const thresholdDate = /* @__PURE__ */ new Date();
+      thresholdDate.setDate(thresholdDate.getDate() - retentionDays);
+      let deletedCount = 0;
+      const ordersToDelete = [];
+      for (const order of allOrders) {
+        try {
+          const isSynced = order.order_id && !(0, import_utils.isVirtualOrderId)(order.order_id);
+          if (!isSynced) {
+            continue;
+          }
+          let orderCreatedAt = null;
+          if ((_a = order.order_info) == null ? void 0 : _a.created_at) {
+            orderCreatedAt = new Date(order.order_info.created_at);
+          } else if ((_c = (_b = order.order_info) == null ? void 0 : _b.original_order_data) == null ? void 0 : _c.created_at) {
+            orderCreatedAt = new Date(order.order_info.original_order_data.created_at);
+          }
+          if (!orderCreatedAt || isNaN(orderCreatedAt.getTime())) {
+            continue;
+          }
+          if (orderCreatedAt < thresholdDate) {
+            ordersToDelete.push({
+              uuid: order.uuid,
+              orderId: order.order_id,
+              createdAt: orderCreatedAt.toISOString(),
+              daysSinceCreated: Math.floor((Date.now() - orderCreatedAt.getTime()) / (1e3 * 60 * 60 * 24))
+            });
+          }
+        } catch (error) {
+          console.warn(`[Checkout] 处理订单 ${order.uuid} 时出错:`, error);
+          continue;
+        }
+      }
+      ordersToDelete.sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
+      const actualOrdersToDelete = ordersToDelete.slice(0, maxOrdersToDelete);
+      for (const orderInfo of actualOrdersToDelete) {
+        try {
+          await this.payment.deletePaymentOrderAsync(orderInfo.uuid);
+          deletedCount++;
+          console.log(`[Checkout] 已删除过期订单: ${orderInfo.orderId} (${orderInfo.daysSinceCreated} 天前创建)`);
+        } catch (error) {
+          console.error(`[Checkout] 删除订单 ${orderInfo.uuid} 失败:`, error);
+        }
+      }
+      const summary = {
+        totalOrders: allOrders.length,
+        expiredSyncedOrders: ordersToDelete.length,
+        maxOrdersToDelete,
+        actualDeletedOrders: deletedCount,
+        retentionDays,
+        cleanupDate: (/* @__PURE__ */ new Date()).toISOString(),
+        thresholdDate: thresholdDate.toISOString(),
+        skippedOrders: Math.max(0, ordersToDelete.length - maxOrdersToDelete)
+      };
+      this.logInfo("Expired orders cleanup completed", summary);
+      if (ordersToDelete.length > maxOrdersToDelete) {
+        console.log(`[Checkout] 过期订单清理完成: 总计 ${allOrders.length} 个订单，发现 ${ordersToDelete.length} 个过期已同步订单，删除了 ${deletedCount} 个（限制为 ${maxOrdersToDelete} 个）`);
+      } else {
+        console.log(`[Checkout] 过期订单清理完成: 总计 ${allOrders.length} 个订单，删除了 ${deletedCount} 个过期已同步订单`);
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      console.error("[Checkout] 清理过期订单数据失败:", error);
+      this.logError("Expired orders cleanup failed", { error: errorMessage });
+    }
+  }
+  /**
+   * 计算已支付金额（从 Payment 模块获取最新数据）
+   */
+  async calculatePaidAmountAsync() {
+    if (!this.store.currentOrder) {
+      console.log("[Checkout] calculatePaidAmountAsync: 没有当前订单");
+      return "0.00";
+    }
+    try {
+      const payments = await this.payment.getPaymentItemsAsync(
+        this.store.currentOrder.uuid,
+        false
+        // 不包括已撤销的支付项
+      );
+      console.log("[Checkout] calculatePaidAmountAsync: 支付项详情:", {
+        paymentCount: payments.length,
+        payments: payments.map((p) => ({
+          uuid: p.uuid,
+          amount: p.amount,
+          code: p.code,
+          status: p.status,
+          rounding_amount: p.rounding_amount
+        }))
+      });
+      const paidAmount = payments.filter((payment) => payment.status !== "voided").reduce((sum, payment) => {
+        const amount = new import_decimal.default(payment.amount || "0");
+        const roundingAmount = new import_decimal.default(payment.rounding_amount || "0");
+        const effectiveAmount = amount.add(roundingAmount.abs());
+        console.log(`[Checkout] 计算支付项: ${payment.code}`, {
+          originalAmount: amount.toFixed(2),
+          roundingAmount: roundingAmount.toFixed(2),
+          effectiveAmount: effectiveAmount.toFixed(2),
+          description: !roundingAmount.isZero() ? `抹零金额 ${roundingAmount.toFixed(2)} 元，有效支付增加 ${roundingAmount.abs().toFixed(2)} 元` : "无抹零",
+          // Decimal 精度验证
+          preciseCalculationValues: {
+            amount: amount.toString(),
+            roundingAmount: roundingAmount.toString(),
+            effectiveAmount: effectiveAmount.toString()
+          }
+        });
+        return sum.add(effectiveAmount);
+      }, new import_decimal.default(0));
+      const result = paidAmount.toFixed(2);
+      console.log("[Checkout] calculatePaidAmountAsync: 计算结果 =", result);
+      return result;
+    } catch (error) {
+      console.error("[Checkout] calculatePaidAmountAsync 失败:", error);
+      return "0.00";
+    }
+  }
+  /**
+   * 计算剩余未支付金额（从 Payment 模块获取最新数据）
+   */
+  async calculateRemainingAmountAsync() {
+    if (!this.store.currentOrder) {
+      console.log("[Checkout] calculateRemainingAmountAsync: 没有当前订单");
+      return "0.00";
+    }
+    const totalAmount = new import_decimal.default(this.store.currentOrder.total_amount || "0");
+    const paidAmountStr = await this.calculatePaidAmountAsync();
+    const paidAmount = new import_decimal.default(paidAmountStr);
+    const remainingAmount = totalAmount.sub(paidAmount);
+    const result = import_decimal.default.max(0, remainingAmount).toFixed(2);
+    console.log("[Checkout] calculateRemainingAmountAsync: 计算详情:", {
+      orderUuid: this.store.currentOrder.uuid,
+      totalAmount: totalAmount.toFixed(2),
+      paidAmount: paidAmount.toFixed(2),
+      calculatedRemaining: remainingAmount.toFixed(2),
+      finalResult: result,
+      description: "已支付金额包含抹零计算（amount + |rounding_amount|）",
+      // Decimal 精度验证
+      preciseCalculationValues: {
+        totalAmount: totalAmount.toString(),
+        paidAmount: paidAmount.toString(),
+        remainingAmount: remainingAmount.toString(),
+        resultAfterMax: import_decimal.default.max(0, remainingAmount).toString()
+      }
+    });
+    return result;
+  }
+  /**
+   * 更新 balanceDueAmount 为当前剩余未支付金额（系统内部计算）
+   */
+  async updateBalanceDueAmount() {
+    var _a;
+    try {
+      const remainingAmount = await this.calculateRemainingAmountAsync();
+      const currentBalanceDueAmount = this.store.balanceDueAmount;
+      console.log("[Checkout] updateBalanceDueAmount: 状态检查:", {
+        calculatedRemainingAmount: remainingAmount,
+        currentBalanceDueAmount,
+        needsUpdate: remainingAmount !== currentBalanceDueAmount,
+        orderUuid: (_a = this.store.currentOrder) == null ? void 0 : _a.uuid
+      });
+      if (remainingAmount !== currentBalanceDueAmount) {
+        this.store.balanceDueAmount = remainingAmount;
+        await this.core.effects.emit(import_types.CheckoutHooks.OnBalanceDueAmountChanged, {
+          oldAmount: currentBalanceDueAmount,
+          newAmount: remainingAmount,
+          timestamp: Date.now()
+        });
+        console.log("[Checkout] balanceDueAmount 已自动更新:", {
+          oldAmount: currentBalanceDueAmount,
+          newAmount: remainingAmount
+        });
+      } else {
+        console.log("[Checkout] balanceDueAmount 无需更新，当前值已是最新:", {
+          balanceDueAmount: currentBalanceDueAmount,
+          remainingAmount
+        });
+      }
+    } catch (error) {
+      console.error("[Checkout] 更新 balanceDueAmount 失败:", error);
+    }
+  }
+  /**
+   * 更新 stateAmount 为当前剩余未支付金额
+   */
+  async updateStateAmountToRemaining() {
+    var _a;
+    try {
+      const remainingAmount = await this.calculateRemainingAmountAsync();
+      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;
+        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.updateBalanceDueAmount();
+      await this.checkOrderPaymentCompletion();
+    } catch (error) {
+      console.error("[Checkout] 更新 stateAmount 为剩余金额失败:", error);
+    }
+  }
+  /**
+   * 检查订单支付是否完成
+   *
+   * 当剩余待付款金额 <= 0 时，触发订单支付完成事件
+   */
+  async checkOrderPaymentCompletion() {
+    try {
+      if (!this.store.currentOrder) {
+        return;
+      }
+      const remainingAmount = await this.calculateRemainingAmountAsync();
+      const remainingValue = new import_decimal.default(remainingAmount);
+      if (remainingValue.lte(0)) {
+        const totalAmount = this.store.currentOrder.total_amount;
+        const paidAmount = await this.calculatePaidAmountAsync();
+        console.log("[Checkout] 检测到订单支付完成:", {
+          orderUuid: this.store.currentOrder.uuid,
+          orderId: this.store.currentOrder.order_id,
+          totalAmount,
+          paidAmount,
+          remainingAmount,
+          isOrderSynced: this.store.isOrderSynced
+        });
+        const currentPayments = await this.payment.getPaymentItemsAsync(
+          this.store.currentOrder.uuid,
+          false
+          // 不包括已撤销的支付项
+        );
+        const hasPaymentItems = currentPayments.length > 0;
+        const allPaymentsHaveVoucherId = hasPaymentItems && currentPayments.every(
+          (item) => item.status !== "voided" && item.voucher_id
+        );
+        const shouldAutoSync = hasPaymentItems && !allPaymentsHaveVoucherId;
+        console.log("[Checkout] 自动同步订单条件检查:", {
+          paymentCount: currentPayments.length,
+          hasPaymentItems,
+          allHaveVoucherId: allPaymentsHaveVoucherId,
+          isOrderSynced: this.store.isOrderSynced,
+          shouldAutoSync,
+          reason: shouldAutoSync ? "支付完成，需要同步最终支付状态" : "跳过同步",
+          paymentItems: currentPayments.map((p) => ({
+            uuid: p.uuid,
+            code: p.code,
+            amount: p.amount,
+            rounding_amount: p.rounding_amount,
+            effective_amount: (parseFloat(p.amount || "0") + Math.abs(parseFloat(p.rounding_amount || "0"))).toFixed(2),
+            voucher_id: p.voucher_id,
+            status: p.status
+          }))
+        });
+        if (shouldAutoSync) {
+          console.log("[Checkout] 满足自动同步条件，开始同步订单到后端...");
+          await this.syncOrderToBackend();
+        } else {
+          if (!hasPaymentItems) {
+            console.log("[Checkout] 没有支付项，跳过订单同步");
+          } else if (allPaymentsHaveVoucherId) {
+            console.log("[Checkout] 所有支付项均为代金券类型，跳过订单同步");
+          }
+        }
+        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);
+    }
+  }
+  /**
+   * 同步订单到后端
+   *
+   * 调用后端 /order/checkout 接口创建真实订单
+   */
+  /**
+   * 同步订单到后端并返回真实订单ID
+   *
+   * @param isManual 是否为手动同步，默认为 false
+   * @param customPaymentItems 自定义支付项列表，如果提供则使用此列表而不是从数据库获取
+   * @returns 包含订单ID、UUID和完整后端响应的对象
+   */
+  async syncOrderToBackendWithReturn(isManual = false, customPaymentItems) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
+    if (!this.store.localOrderData || !this.store.currentOrder) {
+      throw new Error("缺少必要的订单数据，无法同步到后端");
+    }
+    this.logInfo("syncOrderToBackendWithReturn called", {
+      isManual,
+      hasCustomPaymentItems: !!customPaymentItems,
+      customPaymentItemsCount: (customPaymentItems == null ? void 0 : customPaymentItems.length) || 0,
+      currentOrderId: this.store.currentOrder.order_id,
+      orderUuid: this.store.currentOrder.uuid,
+      isOrderSynced: this.store.isOrderSynced,
+      isVirtualOrderId: (0, import_utils.isVirtualOrderId)(this.store.currentOrder.order_id),
+      localOrderDataType: this.store.localOrderData.type,
+      platform: this.store.localOrderData.platform,
+      customerId: (_a = this.store.currentCustomer) == null ? void 0 : _a.customer_id
+    });
+    const syncType = isManual ? "手动" : "自动";
+    const currentOrderId = this.store.currentOrder.order_id;
+    const hasRealOrderId = currentOrderId && !(0, import_utils.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: (0, import_utils.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,
+          orderPaymentType: p.order_payment_type,
+          metadata: p.metadata
+        };
+      })
+    });
+    const processedPaymentItems = paymentItems.map((item) => {
+      var _a2, _b2;
+      return {
+        ...item,
+        metadata: {
+          ...item.metadata,
+          rounding_rule: ((_a2 = item.metadata) == null ? void 0 : _a2.rounding_rule) || this.otherParams.order_rounding_setting,
+          shop_wallet_pass_id: ((_b2 = item.metadata) == null ? void 0 : _b2.shop_wallet_pass_id) || this.otherParams.shop_wallet_pass_id
+        }
+      };
+    });
+    console.log("[Checkout] 处理后的支付项数据（包含完整metadata）:", {
+      originalCount: paymentItems.length,
+      processedCount: processedPaymentItems.length,
+      sampleMetadata: (_b = processedPaymentItems[0]) == null ? void 0 : _b.metadata,
+      allPaymentItems: processedPaymentItems.map((p) => {
+        var _a2, _b2;
+        return {
+          code: p.code,
+          amount: p.amount,
+          voucherId: p.voucher_id,
+          orderPaymentType: p.order_payment_type,
+          metadata: p.metadata,
+          // 现金支付找零信息
+          actualPaidAmount: (_a2 = p.metadata) == null ? void 0 : _a2.actual_paid_amount,
+          changeGivenAmount: (_b2 = p.metadata) == null ? void 0 : _b2.change_given_amount
+        };
+      })
+    });
+    const orderParams = {
+      ...this.store.localOrderData,
+      type: this.store.localOrderData.type,
+      platform: this.store.localOrderData.platform,
+      payments: processedPaymentItems,
+      // 使用处理过的支付项数据
+      customer_id: (_c = this.store.currentCustomer) == null ? void 0 : _c.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: ((_d = this.store.currentOrder) == null ? void 0 : _d.is_deposit) || 0,
+      deposit_amount: ((_e = this.store.currentOrder) == null ? void 0 : _e.deposit_amount) || "0.00",
+      // surcharge_fee: this.otherParams.surcharge_fee,
+      // surcharges: ,
+      product_tax_fee: this.store.localOrderData.tax_fee,
+      note: this.store.localOrderData.shop_note
+      // deposit_amount:
+    };
+    if (isUpdateOperation) {
+      if ((0, import_utils.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 startTime = Date.now();
+    await this.core.effects.emit(import_types.CheckoutHooks.OnOrderSubmitStart, {
+      orderUuid: this.store.currentOrder.uuid,
+      operation: isUpdateOperation ? "update" : "create",
+      isManual,
+      paymentItemCount: paymentItems.length,
+      timestamp: startTime
+    });
+    let checkoutResponse;
+    let submitSuccess = false;
+    let submitError;
+    try {
+      this.logInfo("Calling backend checkout API", {
+        url: "/order/checkout",
+        operation,
+        isManual,
+        orderType: orderParams.type,
+        platform: orderParams.platform,
+        customerId: orderParams.customer_id,
+        isDeposit: orderParams.is_deposit,
+        depositAmount: orderParams.deposit_amount,
+        bookingsCount: ((_f = orderParams.bookings) == null ? void 0 : _f.length) || 0,
+        relationProductsCount: ((_g = orderParams.relation_products) == null ? void 0 : _g.length) || 0,
+        paymentsCount: ((_h = orderParams.payments) == null ? void 0 : _h.length) || 0,
+        paymentMethods: ((_i = orderParams.payments) == null ? void 0 : _i.map((p) => p.code)) || [],
+        hasOrderId: !!orderParams.order_id,
+        orderIdIncluded: orderParams.order_id,
+        productTaxFee: orderParams.product_tax_fee,
+        note: orderParams.note,
+        scheduleDate: orderParams.schedule_date
+      });
+      checkoutResponse = await this.order.createOrderByCheckout(orderParams);
+      submitSuccess = true;
+      console.log("[Checkout] 下单接口调用成功");
+    } catch (error) {
+      submitSuccess = false;
+      submitError = error instanceof Error ? error.message : String(error);
+      await this.core.effects.emit(import_types.CheckoutHooks.OnOrderSyncFailed, {
+        orderUuid: this.store.currentOrder.uuid,
+        operation: isUpdateOperation ? "update" : "create",
+        isManual,
+        error: submitError,
+        errorType: "network_error",
+        duration: Date.now() - startTime,
+        timestamp: Date.now()
+      });
+      throw error;
+    } finally {
+      await this.core.effects.emit(import_types.CheckoutHooks.OnOrderSubmitEnd, {
+        success: submitSuccess,
+        orderUuid: this.store.currentOrder.uuid,
+        operation: isUpdateOperation ? "update" : "create",
+        isManual,
+        orderId: submitSuccess ? ((_j = checkoutResponse == null ? void 0 : checkoutResponse.data) == null ? void 0 : _j.order_id) || (checkoutResponse == null ? void 0 : checkoutResponse.order_id) : void 0,
+        error: submitError,
+        duration: Date.now() - startTime,
+        timestamp: Date.now()
+      });
+    }
+    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
+    });
+    const responseStatus = checkoutResponse == null ? void 0 : checkoutResponse.status;
+    const isSuccessResponse = responseStatus === true || responseStatus === 200 || responseStatus === "success" || responseStatus === 1 && (checkoutResponse == null ? void 0 : checkoutResponse.code) === 200;
+    if (!isSuccessResponse) {
+      const errorMessage = (checkoutResponse == null ? void 0 : checkoutResponse.message) || "订单同步失败，后端返回非成功状态";
+      console.error("[Checkout] 订单同步失败，响应状态检查未通过:", {
+        expectedSuccess: true,
+        actualStatus: responseStatus,
+        code: checkoutResponse == null ? void 0 : checkoutResponse.code,
+        message: checkoutResponse == null ? void 0 : checkoutResponse.message,
+        errorMessage
+      });
+      await this.core.effects.emit(import_types.CheckoutHooks.OnOrderSyncFailed, {
+        orderUuid: this.store.currentOrder.uuid,
+        operation: isUpdateOperation ? "update" : "create",
+        isManual,
+        error: errorMessage,
+        errorType: "api_error",
+        response: checkoutResponse,
+        duration: Date.now() - startTime,
+        timestamp: Date.now()
+      });
+      throw new Error(errorMessage);
+    }
+    console.log("[Checkout] 响应状态检查通过，开始处理订单数据");
+    let realOrderId;
+    if (isUpdateOperation) {
+      realOrderId = currentOrderId;
+      console.log(`[Checkout] 订单更新成功，订单ID: ${realOrderId}`);
+    } else {
+      let extractedOrderId = (_k = checkoutResponse == null ? void 0 : checkoutResponse.data) == null ? void 0 : _k.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:", {
+            beforeReplacement: beforeManualUpdate,
+            afterReplacement: 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,
+      response: checkoutResponse
+    });
+    const finalOrderId = this.store.currentOrder.order_id;
+    const finalIsVirtual = (0, import_utils.isVirtualOrderId)(finalOrderId || "");
+    console.log(`[Checkout] ${syncType}${operation}订单到后端完成`, {
+      returnedOrderId: realOrderId,
+      currentStoredOrderId: finalOrderId,
+      isStillVirtualId: finalIsVirtual,
+      isSynced: this.store.isOrderSynced
+    });
+    if (finalIsVirtual && !isUpdateOperation) {
+      console.warn(
+        "[Checkout] 警告：订单创建后，当前订单ID仍然是虚拟ID，可能存在问题"
+      );
+    }
+    return {
+      success: true,
+      message: `订单${operation}成功`,
+      orderId: realOrderId,
+      orderUuid: this.store.currentOrder.uuid,
+      response: checkoutResponse
+    };
+  }
+  async syncOrderToBackend() {
+    try {
+      const syncResult = await this.syncOrderToBackendWithReturn(false);
+      console.log("[Checkout] 自动同步订单完成:", syncResult);
+    } 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 };
+    }
+  }
+  /**
+   * 通过订单ID编辑订单备注
+   *
+   * 用于修改已同步到后端的订单备注，通常在支付成功后的弹窗中使用
+   *
+   * @param orderId 后端订单ID
+   * @param note 新的订单备注
+   * @returns 修改结果
+   */
+  async editOrderNoteByOrderIdAsync(orderId, note) {
+    this.logInfo("editOrderNoteByOrderIdAsync called", {
+      orderId,
+      note,
+      noteLength: note.length,
+      isCurrentOrder: this.store.currentOrder && (String(this.store.currentOrder.order_id) === String(orderId) || String(this.store.currentOrder.id) === String(orderId))
+    });
+    try {
+      console.log("[Checkout] 开始编辑订单备注:", {
+        orderId,
+        note,
+        noteLength: note.length
+      });
+      if (!orderId) {
+        return {
+          success: false,
+          message: "订单ID不能为空",
+          orderId
+        };
+      }
+      this.logInfo("Calling order note edit API", {
+        url: `/order/order/${orderId}/note`,
+        method: "PUT",
+        orderId,
+        note,
+        noteLength: note.length
+      });
+      const response = await this.request.put(
+        `/order/order/${orderId}/note`,
+        {
+          note
+        }
+      );
+      console.log("[Checkout] 订单备注编辑响应:", {
+        orderId,
+        status: response.status,
+        message: response.message,
+        response
+      });
+      if (response.status === true || response.status === 200) {
+        console.log(`[Checkout] 订单 ${orderId} 备注修改成功`);
+        if (this.store.currentOrder && (String(this.store.currentOrder.order_id) === String(orderId) || String(this.store.currentOrder.id) === String(orderId))) {
+          console.log("[Checkout] 更新本地订单备注状态");
+          const previousNote = this.getOrderNote();
+          if (this.store.localOrderData) {
+            this.store.localOrderData.shop_note = note;
+          }
+          await this.core.effects.emit(import_types.CheckoutHooks.OnOrderNoteChanged, {
+            orderUuid: this.store.currentOrder.uuid,
+            oldNote: previousNote,
+            newNote: note,
+            timestamp: Date.now()
+          });
+        }
+        return {
+          success: true,
+          message: response.message || "订单备注修改成功",
+          orderId
+        };
+      } else {
+        const errorMessage = response.message || "订单备注修改失败";
+        console.error(`[Checkout] 订单 ${orderId} 备注修改失败:`, errorMessage);
+        return {
+          success: false,
+          message: errorMessage,
+          orderId
+        };
+      }
+    } catch (error) {
+      console.error("[Checkout] 编辑订单备注失败:", error);
+      const errorMessage = error instanceof Error ? error.message : "网络错误或服务器异常";
+      return {
+        success: false,
+        message: `编辑订单备注失败: ${errorMessage}`,
+        orderId
+      };
+    }
+  }
+  /**
+   * 发送客户支付链接邮件
+   *
+   * 向指定邮箱发送订单支付提醒邮件
+   *
+   * @param params 发送参数
+   * @returns 发送结果
+   */
+  async sendCustomerPayLinkAsync(params) {
+    var _a, _b;
+    this.logInfo("sendCustomerPayLinkAsync called", {
+      orderIds: params.order_ids,
+      orderIdsCount: ((_a = params.order_ids) == null ? void 0 : _a.length) || 0,
+      emails: params.emails,
+      emailsCount: ((_b = params.emails) == null ? void 0 : _b.length) || 0,
+      notifyAction: params.notify_action || "order_payment_reminder"
+    });
+    try {
+      console.log("[Checkout] 开始发送客户支付链接邮件:", {
+        orderIds: params.order_ids,
+        emails: params.emails,
+        notifyAction: params.notify_action || "order_payment_reminder"
+      });
+      if (!params.order_ids || params.order_ids.length === 0) {
+        return {
+          success: false,
+          message: "订单ID列表不能为空"
+        };
+      }
+      if (!params.emails || params.emails.length === 0) {
+        return {
+          success: false,
+          message: "邮箱地址列表不能为空"
+        };
+      }
+      const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+      const invalidEmails = params.emails.filter(
+        (email) => !emailRegex.test(email)
+      );
+      if (invalidEmails.length > 0) {
+        return {
+          success: false,
+          message: `邮箱格式无效: ${invalidEmails.join(", ")}`
+        };
+      }
+      const requestBody = {
+        order_ids: params.order_ids,
+        notify_action: params.notify_action || "order_payment_reminder",
+        emails: params.emails
+      };
+      console.log("[Checkout] 发送支付链接邮件请求参数:", requestBody);
+      this.logInfo("Calling batch email API", {
+        url: "/order/batch-email",
+        orderIds: requestBody.order_ids,
+        orderIdsCount: requestBody.order_ids.length,
+        notifyAction: requestBody.notify_action,
+        emails: requestBody.emails,
+        emailsCount: requestBody.emails.length
+      });
+      const response = await this.request.post(
+        "/order/batch-email",
+        requestBody
+      );
+      console.log("[Checkout] 支付链接邮件发送响应:", {
+        status: response.status,
+        message: response.message,
+        data: response.data,
+        response
+      });
+      if (response.status === true || response.status === 200) {
+        console.log("[Checkout] 支付链接邮件发送成功");
+        return {
+          success: true,
+          message: response.message || "支付链接邮件发送成功"
+        };
+      } else {
+        const errorMessage = response.message || "支付链接邮件发送失败";
+        console.error("[Checkout] 支付链接邮件发送失败:", errorMessage);
+        return {
+          success: false,
+          message: errorMessage
+        };
+      }
+    } catch (error) {
+      console.error("[Checkout] 发送客户支付链接邮件失败:", error);
+      const errorMessage = error instanceof Error ? error.message : "网络错误或服务器异常";
+      return {
+        success: false,
+        message: `发送支付链接邮件失败: ${errorMessage}`
+      };
+    }
+  }
+  /**
+   * 金额舍入
+   *
+   * @param amount 原始金额
+   * @returns 舍入结果详情，包含原始金额、舍入后金额和舍入差额
+   */
+  async roundAmountAsync(amount) {
+    var _a, _b;
+    const result = await this.payment.roundAmountAsync(
+      amount,
+      (_a = this.otherParams.order_rounding_setting) == null ? void 0 : _a.interval,
+      (_b = this.otherParams.order_rounding_setting) == null ? void 0 : _b.type
+    );
+    console.log(
+      `[Checkout] 金额舍入完成 - 原始: ${result.originalAmount}, 舍入后: ${result.roundedAmount}, 差额: ${result.roundingDifference}`
+    );
+    return result;
+  }
+  async destroy() {
+    var _a, _b, _c, _d;
+    this.payment.wallet.clearAllCache();
+    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] 已销毁");
+  }
+  /**
+   * 重置 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.balanceDueAmount = "0.00";
+      this.store.isOrderSynced = false;
+      this.store.currentCustomer = void 0;
+      this.store.lastError = void 0;
+      this.store.cartItems = [];
+      this.payment.wallet.clearAllCache();
+      this.setStatus(import_types.CheckoutStatus.Ready);
+      this.setStep(import_types.CheckoutStep.OrderConfirmation);
+      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 = {
+  CheckoutImpl,
+  ...require("./types")
+});