@pisell/pisellos 3.0.76 → 3.0.77

package/lib/solution/Checkout/index.js

@@ -1,2776 +0,0 @@
-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");
-var import_utils2 = require("../../modules/Cart/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 = {};
-    // LoggerManager 实例
-    // 计算缓存（用于性能优化）
-    this.calculationCache = {};
-  }
-  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 = {
-      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();
-    console.log("[Checkout] 初始化完成");
-    await this.core.effects.emit(`${this.name}: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 {
-      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;
-      console.log("[Checkout] 结账流程初始化完成");
-    } catch (error) {
-      await this.handleError(error, import_types.CheckoutErrorType.UnknownError);
-      throw error;
-    }
-  }
-  getHolderIdFromBooking(obj) {
-    var _a;
-    if (!obj)
-      return void 0;
-    let ret = obj.holder_id || ((_a = obj.holder) == null ? void 0 : _a.form_record);
-    if (Array.isArray(ret)) {
-      return ret.length > 0 ? Number(ret[0]) : void 0;
-    }
-    return Number(ret) || void 0;
-  }
-  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 formatProduct = (items) => {
-      return items.map(
-        (item) => ({
-          product_id: item.product_id,
-          product_variant_id: item.product_variant_id,
-          quantity: item.num,
-          // 商品是否含税：1；0
-          is_charge_tax: item.is_charge_tax ?? 0,
-          // 若商品不含税，计算得到的税费，单位（元）
-          tax_fee: item.tax_fee,
-          // 整个商品折扣后的总金额
-          selling_price: item.calculated_selling_price,
-          // 使用者id
-          holder_id: item.holder_id,
-          // 整个商品折扣前的总金额
-          original_price: item.calculated_original_price,
-          // 主商品折扣前金额，不包含套餐子商品
-          main_product_original_price: item.price,
-          // 主商品折扣后金额，不包含套餐子商品
-          main_product_selling_price: item.main_product_selling_price,
-          metadata: {
-            // 主商品+非原价(加减价)子商品税费
-            "main_product_attached_bundle_tax_fee": item.metadata.main_product_attached_bundle_tax_fee,
-            // 主商品+非原价(加减价)子商品附加费
-            "main_product_attached_bundle_surcharge_fee": item.metadata.main_product_attached_bundle_surcharge_fee,
-            // 可选，附加费均摊舍入金额
-            "surcharge_rounding_remainder": item.metadata.surcharge_rounding_remainder
-          },
-          product_bundle: item.product_bundle.map((bundle) => {
-            return {
-              bundle_id: bundle.bundle_id,
-              bundle_product_id: bundle.bundle_product_id,
-              bundle_variant_id: bundle.bundle_variant_id,
-              price_type: bundle.price_type,
-              price_type_ext: bundle.price_type_ext,
-              // 套餐子商品总价，不包含折扣金额
-              bundle_sum_price: bundle.bundle_sum_price,
-              // 套餐子商品折扣后金额
-              bundle_selling_price: bundle.bundle_selling_price,
-              num: bundle.num,
-              is_charge_tax: bundle.is_charge_tax,
-              tax_fee: bundle.tax_fee,
-              metadata: {
-                // 子商品单数量附加费
-                "surcharge_fee": bundle.metadata.surcharge_fee,
-                // 可选，附加费均摊舍入金额
-                "surcharge_rounding_remainder": bundle.metadata.surcharge_rounding_remainder
-              }
-            };
-          })
-        })
-      ) || [];
-    };
-    const productList = formatProduct(
-      ((_c = (_b = (_a = this.store.currentOrder.order_info) == null ? void 0 : _a.original_order_data) == null ? void 0 : _b.bookings) == null ? void 0 : _c.map(
-        (item) => {
-          return {
-            ...item.product,
-            holder_id: this.getHolderIdFromBooking(item)
-          };
-        }
-      )) || []
-    );
-    const relationProducts = formatProduct(((_e = (_d = this.store.currentOrder.order_info) == null ? void 0 : _d.original_order_data) == null ? void 0 : _e.relation_products) || []);
-    return [...productList, ...relationProducts];
-  }
-  async initWalletData(params) {
-    var _a, _b, _c, _d, _e, _f, _g;
-    this.logInfo("initWalletData called", {
-      params
-    });
-    const amountInfo = (_b = (_a = this.store.currentOrder) == null ? void 0 : _a.order_info) == null ? void 0 : _b.amount_breakdown;
-    if (!amountInfo) {
-      this.logInfo("initWalletData amountInfo not found", {
-        params
-      });
-      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,
-        depositAmount: (_d = this.store.currentOrder) == null ? void 0 : _d.deposit_amount,
-        isDeposit: (_e = this.store.currentOrder) == null ? void 0 : _e.is_deposit
-      },
-      products: this.getProductListByOrder(),
-      is_price_include_tax: this.otherParams.is_price_include_tax,
-      // core 有
-      ...params
-    };
-    if (this.store.isOrderSynced) {
-      walletBusinessData.payment_order_id = (_f = this.store.currentOrder) == null ? void 0 : _f.order_id;
-    }
-    this.logInfo("开始拉取:initializeWalletDataFromBusinessAsync", {
-      walletBusinessData
-    });
-    await this.payment.wallet.initializeWalletDataFromBusinessAsync(
-      walletBusinessData
-    );
-    this.logInfo("调用结束:initializeWalletDataFromBusinessAsync", {
-      walletBusinessData
-    });
-    if (!this.store.currentOrder) {
-      return;
-    }
-    this.logInfo("initWalletData currentOrder found", {
-      currentOrder: this.store.currentOrder
-    });
-    await this.core.effects.emit(`${this.name}:onWalletDataInitialized`, {
-      orderUuid: (_g = this.store.currentOrder) == null ? void 0 : _g.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()
-    });
-  }
-  checkIsNeedDepositAsync(bookings, relationProducts) {
-    const summaryDeposit = {
-      total: 0,
-      protocols: [],
-      hasDeposit: false
-    };
-    bookings == null ? void 0 : bookings.forEach((item) => {
-      const total = item.product.calculated_selling_price;
-      const deposit = (0, import_utils2.getProductDeposit)({
-        cartItem: {
-          total
-        },
-        product: item.product,
-        bundle: item.bundle,
-        options: item.options,
-        num: item.num
-      });
-      item.deposit = deposit;
-      if ((deposit == null ? void 0 : deposit.total) && Number(deposit.total) > 0) {
-        summaryDeposit.protocols = summaryDeposit.protocols.concat(
-          deposit.protocols
-        );
-        summaryDeposit.total = new import_decimal.default(summaryDeposit.total).plus(deposit.total).toNumber();
-        summaryDeposit.hasDeposit = true;
-      }
-    });
-    relationProducts == null ? void 0 : relationProducts.forEach((item) => {
-      const deposit = (0, import_utils2.getProductDeposit)({
-        cartItem: {
-          total: item.price * item.num
-        },
-        product: item,
-        bundle: item.product_bundle,
-        options: item.product_option_item,
-        num: item.num
-      });
-      item.deposit = deposit;
-      if ((deposit == null ? void 0 : deposit.total) && Number(deposit.total) > 0) {
-        summaryDeposit.total = new import_decimal.default(summaryDeposit.total).plus(deposit.total).toNumber();
-        item.discount_list.forEach((discount) => {
-          summaryDeposit.total = new import_decimal.default(summaryDeposit.total).minus(discount.amount || 0).toNumber();
-        });
-        summaryDeposit.protocols = summaryDeposit.protocols.concat(
-          deposit.protocols
-        );
-        summaryDeposit.hasDeposit = true;
-      }
-    });
-    summaryDeposit.total = new import_decimal.default(summaryDeposit.total).toDecimalPlaces(2, import_decimal.default.ROUND_HALF_UP).toNumber();
-    return summaryDeposit;
-  }
-  /**
-   * 创建本地订单 (前端模拟下单流程)
-   *
-   * 此方法用于在前端模拟整个下单流程，创建一个本地的虚拟订单。
-   * 用户在购物车点击下单时，会把购物车参数传递给此方法，
-   * 方法会记录参数并创建本地虚拟订单，然后用 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 {
-      this.resetStoreState();
-      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 isNeedDeposit = this.checkIsNeedDepositAsync(
-        params.orderData.bookings,
-        params.orderData.relation_products
-      );
-      const paymentOrder = await this.payment.createPaymentOrderAsync({
-        order_id: localOrderId,
-        total_amount: amountInfo.totalAmount,
-        is_deposit: isNeedDeposit.hasDeposit ? 1 : 0,
-        deposit_amount: isNeedDeposit.total ? isNeedDeposit.total.toString() : "0.00",
-        order_info: {
-          original_order_data: params.orderData,
-          cart_summary: params.cartSummary,
-          created_at: (/* @__PURE__ */ new Date()).toISOString(),
-          platform: params.orderData.platform,
-          type: params.orderData.type,
-          schedule_date: params.orderData.schedule_date,
-          shop_note: params.orderData.shop_note,
-          amount_breakdown: amountInfo
-        }
-      });
-      this.store.currentOrder = paymentOrder;
-      this.core.effects.emit(`${this.name}:onOrderCreated`, {
-        order: paymentOrder,
-        timestamp: Date.now()
-      });
-      const updateAmountStartTime = Date.now();
-      await this.updateStateAmountToRemaining(false);
-      const updateAmountDuration = Date.now() - updateAmountStartTime;
-      this.logInfo("updateStateAmountToRemaining operation completed", {
-        operation: "updateStateAmountToRemaining",
-        orderUuid: paymentOrder.uuid,
-        orderId: paymentOrder.order_id,
-        duration: `${updateAmountDuration}ms`,
-        performance: updateAmountDuration > 200 ? "slow" : updateAmountDuration > 100 ? "medium" : "fast"
-      });
-      this.logInfo("本地订单创建成功:", {
-        localOrderId,
-        uuid: paymentOrder.uuid,
-        totalAmount: amountInfo.totalAmount,
-        subTotal: amountInfo.subTotal,
-        taxAmount: amountInfo.taxAmount,
-        stateAmount: this.store.stateAmount
-      });
-      this.initWalletData();
-      return paymentOrder;
-    } catch (error) {
-      await this.handleError(
-        error,
-        import_types.CheckoutErrorType.OrderCreationFailed
-      );
-      this.logError("本地订单创建失败:", error);
-      this.core.effects.emit(`${this.name}:onOrderCreationFailed`, {
-        error: this.store.lastError,
-        timestamp: Date.now()
-      });
-      throw error;
-    }
-  }
-  /**
-   * 更新本地订单（已同步后端的订单）并设置为当前订单
-   *
-   * 通过传入真实的 orderId，对已缓存的订单数据进行更新，
-   * 会覆盖 order_info 与金额等字段，并重新计算待付金额，最后设置为 currentOrder。
-   */
-  async updateLocalOrderAsync(params) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
-    this.logInfo("updateLocalOrderAsync called", {
-      orderId: params.orderId,
-      orderDataType: (_a = params.orderData) == null ? void 0 : _a.type,
-      bookingsCount: ((_c = (_b = params.orderData) == null ? void 0 : _b.bookings) == null ? void 0 : _c.length) || 0,
-      cartSummaryCount: ((_d = params.cartSummary) == null ? void 0 : _d.length) || 0,
-      totalInfoKeys: params.totalInfo ? Object.keys(params.totalInfo) : []
-    });
-    const validation = (0, import_utils.validateLocalOrderData)(params.orderData);
-    if (!validation.valid) {
-      throw (0, import_utils.createCheckoutError)(
-        import_types.CheckoutErrorType.ValidationFailed,
-        `订单数据验证失败: ${validation.errors.join(", ")}`
-      );
-    }
-    const amountInfo = (0, import_utils.extractAmountFromCartSummary)(params.cartSummary);
-    params.orderData.created_at = (0, import_utils.formatDateTime)(/* @__PURE__ */ new Date());
-    params.orderData.platform = "pos";
-    params.orderData.surcharge_fee = (_f = (_e = params.totalInfo) == null ? void 0 : _e.total) == null ? void 0 : _f.otherAmount;
-    params.orderData.surcharges = (_h = (_g = params.totalInfo) == null ? void 0 : _g.total) == null ? void 0 : _h.surcharge;
-    params.orderData.shop_discount = (_j = (_i = params.totalInfo) == null ? void 0 : _i.total) == null ? void 0 : _j.shopDiscount;
-    params.orderData.tax_fee = (_l = (_k = params.totalInfo) == null ? void 0 : _k.total) == null ? void 0 : _l.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;
-    } else {
-      this.store.currentCustomer = void 0;
-    }
-    const allOrders = await this.payment.getOrderListAsync();
-    const existingOrder = allOrders.find(
-      (o) => String(o.id) === String(params.orderId) || String(o.order_id) === String(params.orderId)
-    );
-    if (existingOrder) {
-      const totalAmount = new import_decimal.default(amountInfo.totalAmount || "0");
-      const activePayments = (existingOrder.payment || []).filter(
-        (p) => p.status !== "voided"
-      );
-      const paidAmount = activePayments.reduce((sum, p) => {
-        const amt = new import_decimal.default(p.amount || "0");
-        const rounding = new import_decimal.default(Number(p.rounding_amount) > 0 ? 0 : p.rounding_amount || "0").abs();
-        return sum.plus(amt).plus(rounding);
-      }, new import_decimal.default(0));
-      const remaining = import_decimal.default.max(0, totalAmount.minus(paidAmount)).toFixed(
-        2
-      );
-      const isNeedDeposit2 = this.checkIsNeedDepositAsync(
-        params.orderData.bookings,
-        params.orderData.relation_products
-      );
-      await this.payment.updateOrderAsync(existingOrder.uuid, {
-        total_amount: amountInfo.totalAmount,
-        is_deposit: isNeedDeposit2.hasDeposit ? 1 : 0,
-        deposit_amount: isNeedDeposit2.total ? isNeedDeposit2.total.toString() : "0.00",
-        expect_amount: remaining,
-        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
-        }
-      });
-      const updated = await this.payment.getPaymentOrderByUuidAsync(
-        existingOrder.uuid
-      );
-      if (!updated)
-        throw (0, import_utils.createCheckoutError)(
-          import_types.CheckoutErrorType.UnknownError,
-          "订单更新失败"
-        );
-      this.store.currentOrder = updated;
-      await this.updateStateAmountToRemaining(false);
-      this.logInfo("本地订单更新成功(保留支付项):", {
-        orderId: params.orderId,
-        uuid: updated.uuid,
-        payments: ((_m = updated.payment) == null ? void 0 : _m.length) || 0,
-        totalAmount: updated.total_amount,
-        expectAmount: updated.expect_amount
-      });
-      await this.core.effects.emit(`${this.name}:onOrderCreated`, {
-        order: updated,
-        timestamp: Date.now()
-      });
-      const syncedAmount = activePayments.reduce((sum, p) => {
-        const amt = new import_decimal.default(p.amount || "0");
-        const rounding = new import_decimal.default(Number(p.rounding_amount) > 0 ? 0 : p.rounding_amount || "0").abs();
-        return sum.plus(amt).plus(rounding);
-      }, new import_decimal.default(0));
-      const remainingExpectAmount = import_decimal.default.max(0, totalAmount.minus(syncedAmount)).toFixed(
-        2
-      );
-      let depositDiffAmount = new import_decimal.default(0).toFixed(2);
-      if (updated.is_deposit === 1) {
-        depositDiffAmount = new import_decimal.default(updated.deposit_amount).minus(syncedAmount).toFixed(2);
-      }
-      this.initWalletData({
-        order_wait_pay_amount: Number(depositDiffAmount) > 0 ? Number(depositDiffAmount) : Number(remainingExpectAmount)
-      });
-      return updated;
-    }
-    const isNeedDeposit = this.checkIsNeedDepositAsync(
-      params.orderData.bookings,
-      params.orderData.relation_products
-    );
-    const created = await this.payment.createPaymentOrderAsync({
-      order_id: String(params.orderId),
-      total_amount: amountInfo.totalAmount,
-      is_deposit: isNeedDeposit.hasDeposit ? 1 : 0,
-      deposit_amount: isNeedDeposit.total ? isNeedDeposit.total.toString() : "0.00",
-      order_info: {
-        original_order_data: params.orderData,
-        cart_summary: params.cartSummary,
-        created_at: (/* @__PURE__ */ new Date()).toISOString(),
-        platform: params.orderData.platform,
-        type: params.orderData.type,
-        schedule_date: params.orderData.schedule_date,
-        shop_note: params.orderData.shop_note,
-        amount_breakdown: amountInfo
-      }
-    });
-    this.store.currentOrder = created;
-    this.initWalletData();
-    return created;
-  }
-  /**
-   * 完成结账
-   */
-  async completeCheckoutAsync() {
-    try {
-      if (!this.store.currentOrder) {
-        throw (0, import_utils.createCheckoutError)(
-          import_types.CheckoutErrorType.ValidationFailed,
-          "未找到当前订单"
-        );
-      }
-      const order = await this.payment.getPaymentOrderByUuidAsync(
-        this.store.currentOrder.uuid
-      );
-      if (!order || order.payment_status !== import_types2.PaymentStatus.Finished) {
-        throw (0, import_utils.createCheckoutError)(
-          import_types.CheckoutErrorType.ValidationFailed,
-          "订单支付未完成，无法完成结账"
-        );
-      }
-      this.payment.wallet.clearAllCache();
-      await this.core.effects.emit(`${this.name}:onCheckoutCompleted`, {
-        orderId: order.id,
-        timestamp: Date.now()
-      });
-      console.log("[Checkout] 结账流程完成:", order.id);
-      this.resetStoreState();
-      return {
-        success: true,
-        orderId: String(order.id)
-      };
-    } catch (error) {
-      await this.handleError(error, import_types.CheckoutErrorType.UnknownError);
-      return { success: false };
-    }
-  }
-  /**
-   * 获取订单原始数据
-   */
-  getOrderOriginalData() {
-    var _a;
-    return (_a = this.store.currentOrder) == null ? void 0 : _a.order_info;
-  }
-  /**
-   * 获取当前订单基础信息
-   *
-   * 返回当前订单的基础信息，包括订单状态、金额、支付状态等
-   */
-  getCurrentOrderInfo() {
-    try {
-      const { currentOrder, 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,
-        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)
-      };
-      return result;
-    } catch (error) {
-      console.error("[Checkout] 获取当前订单基础信息失败:", error);
-      return null;
-    }
-  }
-  /**
-   * 获取当前订单的支付项
-   *
-   * 返回当前订单的所有支付项，包括活跃和已撤销的支付项
-   */
-  async getCurrentOrderPaymentItemsAsync() {
-    try {
-      const { currentOrder } = this.store;
-      if (!currentOrder) {
-        console.log("[Checkout] 当前没有活跃订单，无法获取支付项");
-        return [];
-      }
-      const paymentItems = await this.payment.getPaymentItemsAsync(
-        currentOrder.uuid
-      );
-      return paymentItems;
-    } catch (error) {
-      console.error("[Checkout] 获取当前订单支付项失败:", error);
-      return [];
-    }
-  }
-  /**
-   * 获取订单模块
-   */
-  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(`${this.name}:onOrderCreated`, {
-          order: updatedOrder,
-          timestamp: Date.now()
-        });
-        console.log("[Checkout] 本地订单ID替换成功:", {
-          uuid: updatedOrder.uuid,
-          newOrderId: updatedOrder.id
-        });
-        this.store.isOrderSynced = true;
-        await this.updateStateAmountToRemaining(false);
-      }
-      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(`${this.name}:onStateAmountChanged`, {
-        oldAmount,
-        newAmount: formattedAmount,
-        timestamp: Date.now()
-      });
-    } 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;
-  }
-  /**
-   * 获取购物车小计数据
-   *
-   * 返回当前结账流程中的购物车小计项数据，包含各种费用明细
-   *
-   * @returns 购物车小计数据数组，如果没有则返回 null
-   */
-  getCartSummary() {
-    if (!this.store.cartSummary || this.store.cartSummary.length === 0) {
-      console.warn("[Checkout] 没有可用的购物车小计数据");
-      return null;
-    }
-    this.logInfo("获取购物车小计数据:", {
-      itemCount: this.store.cartSummary.length,
-      items: this.store.cartSummary.map((item) => ({
-        key: item.key,
-        value: item.value,
-        label: item.label
-      }))
-    });
-    return [...this.store.cartSummary];
-  }
-  /**
-   * 获取支付方式列表
-   *
-   * 优先使用 store 中的缓存数据，避免重复接口调用。
-   * 如果 store 中没有数据，则调用 Payment 模块的方法获取。
-   *
-   * @returns 支付方式列表
-   */
-  async getPaymentMethodsAsync() {
-    if (this.store.paymentMethods && this.store.paymentMethods.length > 0) {
-      this.logInfo(
-        `使用缓存的支付方式数据，共 ${this.store.paymentMethods.length} 种`
-      );
-      return this.store.paymentMethods;
-    }
-    this.logInfo("store 中无缓存，从 Payment 模块获取支付方式...");
-    try {
-      const methods = await this.payment.getPayMethodListAsync();
-      this.store.paymentMethods = methods;
-      this.logInfo(
-        `从 Payment 模块获取到 ${methods.length} 种支付方式，已更新缓存`
-      );
-      return methods;
-    } catch (error) {
-      this.logError("获取支付方式失败:", error);
-      return [];
-    }
-  }
-  /**
-   * 为当前订单添加支付项
-   *
-   * 向当前活跃订单添加一个支付项，支付项包含支付方式信息和金额
-   *
-   * @param paymentItem 支付项数据
-   * @throws 当前没有活跃订单时抛出错误
-   */
-  async addPaymentItemAsync(paymentItem) {
-    var _a, _b;
-    this.logInfo("addPaymentItemAsync called", paymentItem);
-    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
-      };
-      await this.payment.addPaymentItemAsync(
-        this.store.currentOrder.uuid,
-        paymentItemWithType
-      );
-      this.logInfo("支付项添加成功");
-      this.clearCalculationCache();
-      await this.updateStateAmountToRemaining();
-      const remainingAmount = await this.calculateRemainingAmountAsync();
-      if (Number(remainingAmount) > 0) {
-        this.logInfo("订单金额还有待付的，同步 EFTPOS 支付");
-        const isEftposPayment = ((_a = paymentItem.type) == null ? void 0 : _a.toLowerCase()) === "eftpos" || ((_b = paymentItem.code) == null ? void 0 : _b.toUpperCase().includes("EFTPOS"));
-        const isCashPayment2 = paymentItem.code === "CASHMANUAL";
-        const isCustomePayment = paymentItem.type === "custom";
-        this.logInfo("EFTPOS 支付检查:", {
-          paymentCode: paymentItem.code,
-          paymentType: paymentItem.type,
-          isEftposPayment,
-          currentOrderSynced: this.store.isOrderSynced
-        });
-        if (isEftposPayment || isCashPayment2 || isCustomePayment) {
-          this.logInfo("检测到 EFTPOS 支付，立即同步订单到后端...");
-          try {
-            const syncResult = await this.syncOrderToBackendWithReturn(true);
-            this.logInfo("EFTPOS 支付后订单同步完成 (已标记为手动同步):", {
-              orderId: syncResult.orderId,
-              isOrderSynced: this.store.isOrderSynced,
-              backendResponse: syncResult.response
-            });
-          } catch (error) {
-            this.logError("EFTPOS 支付后订单同步失败:", error);
-            await this.handleError(
-              new Error(
-                `EFTPOS 支付后订单同步失败: ${error instanceof Error ? error.message : String(error)}`
-              ),
-              import_types.CheckoutErrorType.OrderCreationFailed
-            );
-          }
-        }
-      }
-      this.core.effects.emit(`${this.name}:onPaymentItemAdded`, {
-        orderUuid: this.store.currentOrder.uuid,
-        paymentMethodCode: paymentItem.code,
-        paymentMethodName: paymentItem.name,
-        amount: String(paymentItem.amount),
-        timestamp: Date.now()
-      });
-    } catch (error) {
-      this.logError("添加支付项失败:", 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,
-          "当前没有活跃订单，无法删除支付项"
-        );
-      }
-      this.logWarning("开始删除支付项:", {
-        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}`
-        );
-      }
-      this.logInfo("找到要删除的支付项:", {
-        uuid: paymentItem.uuid,
-        code: paymentItem.code,
-        amount: paymentItem.amount,
-        status: paymentItem.status
-      });
-      await this.payment.deletePaymentAsync(
-        this.store.currentOrder.uuid,
-        paymentUuid
-      );
-      this.logInfo("Payment支付项删除完成", paymentItem);
-      this.clearCalculationCache();
-      const currentOrderId = this.store.currentOrder.order_id;
-      const isCurrentOrderReal = currentOrderId && !(0, import_utils.isVirtualOrderId)(currentOrderId);
-      const updatedOrder = await this.payment.getPaymentOrderByUuidAsync(
-        this.store.currentOrder.uuid
-      );
-      if (updatedOrder) {
-        if (isCurrentOrderReal && (0, import_utils.isVirtualOrderId)(updatedOrder.order_id)) {
-          this.logWarning(
-            "[Checkout] deletePaymentItemAsync: 检测到订单ID回退，保护真实订单ID:",
-            {
-              currentRealId: currentOrderId,
-              retrievedVirtualId: updatedOrder.order_id
-            }
-          );
-          updatedOrder.order_id = currentOrderId;
-        }
-        this.store.currentOrder = updatedOrder;
-      }
-      await this.updateStateAmountToRemaining(false);
-      await this.core.effects.emit(`${this.name}:onPaymentStarted`, {
-        orderUuid: this.store.currentOrder.uuid,
-        paymentMethodCode: paymentItem.code,
-        amount: `-${paymentItem.amount}`,
-        // 负数表示删除
-        timestamp: Date.now()
-      });
-    } catch (error) {
-      this.logError("删除支付项失败:", 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,
-          "当前没有活跃订单，无法更新代金券支付项"
-        );
-      }
-      const paymentItems = await this.payment.getPaymentItemsAsync(
-        this.store.currentOrder.uuid
-      );
-      const allPaymentItemsSynced = paymentItems.every((item) => item.isSynced);
-      const remainingAmount = await this.calculateRemainingAmountAsync();
-      const remainingValue = new import_decimal.default(remainingAmount);
-      const isOrderSynced = this.store.isOrderSynced;
-      if (remainingValue.lte(0) && isOrderSynced && voucherPaymentItems.length === 0 && allPaymentItemsSynced) {
-        this.logInfo("订单已同步且支付完成，跳过清空代金券操作避免重复同步:", {
-          orderUuid: this.store.currentOrder.uuid,
-          orderId: this.store.currentOrder.order_id,
-          remainingAmount,
-          isOrderSynced,
-          voucherPaymentItemsCount: voucherPaymentItems.length,
-          reason: "Order synced and payment completed, skip clear vouchers to avoid duplicate sync"
-        });
-        return;
-      }
-      this.logInfo("开始批量更新代金券支付项:", {
-        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
-        };
-      });
-      await this.payment.updateVoucherPaymentItemsAsync(
-        this.store.currentOrder.uuid,
-        voucherPaymentItemsWithType
-      );
-      this.clearCalculationCache();
-      const currentOrderId = this.store.currentOrder.order_id;
-      const isCurrentOrderReal = currentOrderId && !(0, import_utils.isVirtualOrderId)(currentOrderId);
-      const updatedOrder = await this.payment.getPaymentOrderByUuidAsync(
-        this.store.currentOrder.uuid
-      );
-      if (updatedOrder) {
-        if (isCurrentOrderReal && (0, import_utils.isVirtualOrderId)(updatedOrder.order_id)) {
-          this.logWarning(
-            "updateVoucherPaymentItemsAsync: 检测到订单ID回退，保护真实订单ID:",
-            {
-              currentRealId: currentOrderId,
-              retrievedVirtualId: updatedOrder.order_id
-            }
-          );
-          updatedOrder.order_id = currentOrderId;
-        }
-        this.store.currentOrder = updatedOrder;
-      }
-      await this.updateStateAmountToRemaining(false);
-      await this.core.effects.emit(`${this.name}:onPaymentStarted`, {
-        orderUuid: this.store.currentOrder.uuid,
-        paymentMethodCode: "VOUCHER_BATCH",
-        amount: voucherPaymentItems.reduce((sum, item) => sum + parseFloat(String(item.amount)), 0).toFixed(2),
-        timestamp: Date.now()
-      });
-      this.logInfo("代金券支付项批量更新成功");
-    } catch (error) {
-      this.logError("[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;
-      }
-      let deposit_amount = this.store.currentOrder.deposit_amount || "0.00";
-      if (!deposit_amount || Number(deposit_amount) === 0) {
-        deposit_amount = this.store.currentOrder.expect_amount;
-      }
-      const updateParams = {
-        is_deposit: newDepositValue,
-        deposit_amount
-      };
-      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;
-      }
-      this.clearCalculationCache();
-      this.updateStateAmountToRemaining(false);
-      await this.core.effects.emit(`${this.name}:onOrderCreated`, {
-        order: this.store.currentOrder,
-        timestamp: Date.now()
-      });
-      this.logInfo("订单定金状态更新成功:", {
-        isDeposit: newDepositValue,
-        depositAmount: this.store.currentOrder.deposit_amount
-      });
-    } catch (error) {
-      this.logError("更新订单定金状态失败:", error);
-      await this.handleError(
-        error,
-        import_types.CheckoutErrorType.ValidationFailed
-      );
-      throw error;
-    }
-  }
-  /**
-   * 手动设置当前订单的定金金额
-   *
-   * 允许手动设置订单的定金金额，通常用于用户自定义定金支付场景
-   *
-   * @param depositAmount 定金金额，必须是有效的数字字符串，且不能超过订单总额
-   * @throws 当前没有活跃订单时抛出错误
-   * @throws 定金金额格式无效或超过订单总额时抛出错误
-   */
-  async setDepositAmountAsync(depositAmount) {
-    var _a, _b;
-    this.logInfo("setDepositAmountAsync called", {
-      depositAmount,
-      hasCurrentOrder: !!this.store.currentOrder,
-      currentOrderId: (_a = this.store.currentOrder) == null ? void 0 : _a.order_id,
-      currentTotalAmount: (_b = this.store.currentOrder) == null ? void 0 : _b.total_amount
-    });
-    try {
-      const depositValue = new import_decimal.default(depositAmount);
-      if (depositValue.isNaN() || depositValue.lt(0)) {
-        throw (0, import_utils.createCheckoutError)(
-          import_types.CheckoutErrorType.ValidationFailed,
-          `无效的定金金额格式: ${depositAmount}`
-        );
-      }
-      if (!this.store.currentOrder) {
-        throw (0, import_utils.createCheckoutError)(
-          import_types.CheckoutErrorType.ValidationFailed,
-          "未找到当前订单，无法设置定金金额"
-        );
-      }
-      const formattedDepositAmount = depositValue.toFixed(2);
-      const oldDepositAmount = this.store.currentOrder.deposit_amount || "0.00";
-      if (formattedDepositAmount === oldDepositAmount) {
-        this.logInfo("定金金额无变化，跳过更新:", {
-          currentAmount: oldDepositAmount,
-          newAmount: formattedDepositAmount
-        });
-        return;
-      }
-      this.logInfo("开始设置订单定金金额:", {
-        orderUuid: this.store.currentOrder.uuid,
-        orderId: this.store.currentOrder.order_id,
-        oldDepositAmount,
-        newDepositAmount: formattedDepositAmount,
-        totalAmount: this.store.currentOrder.total_amount
-      });
-      const updateParams = {
-        deposit_amount: formattedDepositAmount
-      };
-      if (depositValue.gt(0) && this.store.currentOrder.is_deposit !== 1) {
-        updateParams.is_deposit = 1;
-        this.logInfo("定金金额大于0，自动设置为定金订单");
-      } else if (depositValue.eq(0) && this.store.currentOrder.is_deposit === 1) {
-        updateParams.is_deposit = 0;
-        this.logInfo("定金金额为0，自动设置为全款订单");
-      }
-      await this.payment.updateOrderAsync(
-        this.store.currentOrder.uuid,
-        updateParams
-      );
-      this.store.currentOrder = {
-        ...this.store.currentOrder,
-        ...updateParams
-      };
-      if (this.store.localOrderData) {
-        if ("deposit_amount" in this.store.localOrderData) {
-          this.store.localOrderData.deposit_amount = formattedDepositAmount;
-        }
-        if (updateParams.is_deposit !== void 0) {
-          this.store.localOrderData.is_deposit = updateParams.is_deposit;
-        }
-      }
-      this.clearCalculationCache();
-      this.updateStateAmountToRemaining(false);
-      await this.core.effects.emit(`${this.name}:onOrderCreated`, {
-        order: this.store.currentOrder,
-        timestamp: Date.now()
-      });
-      this.logInfo("订单定金金额设置成功:", {
-        orderUuid: this.store.currentOrder.uuid,
-        orderId: this.store.currentOrder.order_id,
-        oldDepositAmount,
-        newDepositAmount: formattedDepositAmount,
-        isDeposit: this.store.currentOrder.is_deposit,
-        totalAmount: this.store.currentOrder.total_amount
-      });
-    } catch (error) {
-      this.logError("设置订单定金金额失败:", error);
-      await this.handleError(
-        error,
-        import_types.CheckoutErrorType.ValidationFailed
-      );
-      throw error;
-    }
-  }
-  /**
-   * 手动同步订单到后端
-   *
-   * 用于强制同步订单到后端，特别适用于纯代金券支付完成的订单
-   */
-  async manualSyncOrderAsync() {
-    var _a, _b, _c, _d, _e;
-    console.log("manualSyncOrderAsync called");
-    this.logInfo("manualSyncOrderAsync called", {
-      hasCurrentOrder: !!this.store.currentOrder,
-      currentOrderId: (_a = this.store.currentOrder) == null ? void 0 : _a.order_id,
-      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) {
-        this.logInfo("订单已同步过，将执行更新操作");
-      }
-      this.logInfo("开始手动同步订单到后端:", {
-        orderUuid,
-        orderId: oldOrderId,
-        totalAmount: this.store.currentOrder.total_amount,
-        remainingAmount: await this.calculateRemainingAmountAsync()
-      });
-      console.time("manualSyncOrderAsync");
-      const syncResult = await this.syncOrderToBackendWithReturn(true);
-      console.timeEnd("manualSyncOrderAsync");
-      this.logInfo("手动同步订单完成:", {
-        orderUuid,
-        syncResult,
-        oldOrderId,
-        realOrderId: syncResult.orderId,
-        isOrderSynced: this.store.isOrderSynced
-      });
-      const finalOrderId = this.store.currentOrder.order_id;
-      const finalIsVirtual = (0, import_utils.isVirtualOrderId)(finalOrderId);
-      if (finalIsVirtual) {
-        this.logError("严重警告：手动同步完成后订单ID仍为虚拟ID！");
-      }
-      if (syncResult.orderId !== finalOrderId) {
-        this.logError(
-          "[Checkout] 严重警告：返回的订单ID与存储的订单ID不一致！"
-        );
-      }
-      let newRes = {
-        ...syncResult,
-        is_deposit: ((_d = this.store.currentOrder) == null ? void 0 : _d.is_deposit) || 0
-      };
-      await this.updateStateAmountToRemaining(false);
-      return newRes;
-    } catch (error) {
-      this.logError("手动同步订单失败:", error);
-      const errorMessage = error instanceof Error ? error.message : "同步失败";
-      return {
-        success: false,
-        message: `订单同步失败: ${errorMessage}`,
-        orderUuid: (_e = this.store.currentOrder) == null ? void 0 : _e.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 {
-      this.logInfo("开始取消当前本地订单:", {
-        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) {
-        this.logInfo("没有当前订单，无需取消");
-        return {
-          success: false,
-          message: "没有当前订单可取消"
-        };
-      }
-      const currentOrderUuid = this.store.currentOrder.uuid;
-      const currentOrderId = this.store.currentOrder.order_id;
-      const isOrderSynced = this.store.isOrderSynced;
-      if (isOrderSynced) {
-        this.logInfo("订单已同步到后端，不能取消:", {
-          orderId: currentOrderId,
-          orderUuid: currentOrderUuid
-        });
-        return {
-          success: false,
-          message: "订单已同步到后端，无法取消",
-          orderId: currentOrderId
-        };
-      }
-      try {
-        this.logInfo("删除本地订单数据");
-        await this.payment.deletePaymentOrderAsync(currentOrderUuid);
-        this.logInfo("本地订单数据删除成功");
-      } catch (error) {
-        this.logWarning("删除本地订单数据失败，但继续执行:", error);
-      }
-      this.logInfo("清理订单相关状态");
-      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();
-      this.logInfo("订单状态清理完成，currentOrder已释放");
-      await this.core.effects.emit(`${this.name}:onOrderCancelled`, {
-        orderUuid: currentOrderUuid,
-        orderId: currentOrderId,
-        cancelReason,
-        wasSynced: false,
-        // 只有未同步订单可以被取消
-        timestamp: Date.now()
-      });
-      this.logInfo("本地订单取消完成:", {
-        orderUuid: currentOrderUuid,
-        orderId: currentOrderId,
-        cancelReason
-      });
-      return {
-        success: true,
-        message: "本地订单已成功取消",
-        orderId: currentOrderId
-      };
-    } catch (error) {
-      this.logError("取消本地订单失败:", 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;
-      this.logInfo("开始保存订单并稍后支付:", {
-        orderUuid,
-        orderId: currentOrderId,
-        totalAmount: this.store.currentOrder.total_amount
-      });
-      const allPaymentItems = await this.payment.getPaymentItemsAsync(
-        this.store.currentOrder.uuid
-      );
-      const syncResult = await this.syncOrderToBackendWithReturn(
-        true,
-        allPaymentItems
-      );
-      this.logInfo("保存订单完成:", {
-        orderUuid,
-        oldOrderId: currentOrderId,
-        syncResult,
-        realOrderId: syncResult.orderId,
-        isOrderSynced: this.store.isOrderSynced,
-        filteredPaymentsCount: allPaymentItems.length
-      });
-      return {
-        success: true,
-        message: "订单保存成功，可稍后继续支付",
-        orderId: syncResult.orderId,
-        orderUuid,
-        response: syncResult.response
-      };
-    } catch (error) {
-      this.logError("保存订单失败:", error);
-      const errorMessage = error instanceof Error ? error.message : "保存失败";
-      return {
-        success: false,
-        message: `订单保存失败: ${errorMessage}`,
-        orderUuid: (_a = this.store.currentOrder) == null ? void 0 : _a.uuid
-      };
-    }
-  }
-  /**
-   * 更新订单备注
-   *
-   * @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(`${this.name}:onOrderNoteChanged`, {
-        orderUuid: (_b = this.store.currentOrder) == null ? void 0 : _b.uuid,
-        oldNote,
-        newNote: note,
-        timestamp: Date.now()
-      });
-      console.log("[Checkout] 订单备注更新成功:", {
-        oldNote,
-        newNote: note
-      });
-    } catch (error) {
-      console.error("[Checkout] 更新订单备注失败:", error);
-      await this.handleError(
-        error,
-        import_types.CheckoutErrorType.ValidationFailed
-      );
-      throw error;
-    }
-  }
-  /**
-   * 处理错误
-   */
-  async handleError(error, type) {
-    const checkoutError = error instanceof Error && "type" in error ? error : (0, import_utils.createCheckoutError)(type, error.message, error);
-    this.store.lastError = checkoutError;
-    await this.core.effects.emit(`${this.name}:onError`, {
-      error: checkoutError,
-      context: {},
-      timestamp: Date.now()
-    });
-    console.error("[Checkout] 错误:", checkoutError);
-  }
-  /**
-   * 处理支付成功
-   */
-  async handlePaymentSuccess(data) {
-    var _a;
-    await this.updateStateAmountToRemaining();
-    await this.core.effects.emit(`${this.name}: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(`${this.name}: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 cashPayment = (0, import_utils.isCashPayment)(paymentItem.code, paymentItem.type);
-    if (!cashPayment) {
-      return paymentItem;
-    }
-    try {
-      const remainingAmountStr = await this.calculateRemainingAmountAsync();
-      let remainingAmount = new import_decimal.default(remainingAmountStr);
-      const cashAmount = new import_decimal.default(String(paymentItem.amount));
-      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")
-          );
-        }
-      }
-      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) {
-      this.logError("处理现金支付项时出错:", error);
-      return paymentItem;
-    }
-  }
-  /**
-   * 预加载支付方式（在初始化时调用）
-   */
-  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 });
-    }
-  }
-  /**
-   * 清除计算缓存
-   */
-  clearCalculationCache() {
-    this.calculationCache = {};
-  }
-  /**
-   * 批量获取订单数据（用于性能优化）
-   * 一次性获取所有需要的数据，避免重复查询
-   */
-  async fetchOrderDataBatch() {
-    if (!this.store.currentOrder) {
-      return { paymentItems: [], currentOrder: null };
-    }
-    const orderUuid = this.store.currentOrder.uuid;
-    const now = Date.now();
-    const cacheValid = this.calculationCache.orderUuid === orderUuid && this.calculationCache.timestamp && now - this.calculationCache.timestamp < 5e3;
-    if (cacheValid && this.calculationCache.paymentItems && this.calculationCache.currentOrder) {
-      return {
-        paymentItems: this.calculationCache.paymentItems,
-        currentOrder: this.calculationCache.currentOrder
-      };
-    }
-    const [paymentItems, currentOrder] = await Promise.all([
-      this.payment.getPaymentItemsAsync(orderUuid, false),
-      this.payment.getPaymentOrderByUuidAsync(orderUuid)
-    ]);
-    this.calculationCache = {
-      paymentItems,
-      currentOrder,
-      orderUuid,
-      timestamp: now
-    };
-    return { paymentItems, currentOrder };
-  }
-  /**
-   * 从支付项数组计算已支付金额（纯计算，不查询数据库）
-   */
-  calculatePaidAmountFromItems(payments) {
-    const paidAmount = payments.filter((payment) => payment.status !== "voided").reduce((sum, payment) => {
-      const amount = new import_decimal.default(payment.amount || "0");
-      const roundingAmount = new import_decimal.default(payment.rounding_amount || "0");
-      const effectiveAmount = amount.add(roundingAmount.isNegative() ? roundingAmount.abs() : 0);
-      return sum.add(effectiveAmount);
-    }, new import_decimal.default(0));
-    return paidAmount.toFixed(2);
-  }
-  /**
-   * 计算已支付金额（从 Payment 模块获取最新数据）
-   *
-   * 注意：此方法保持独立性，可以单独调用。
-   * 在 updateStateAmountToRemaining 等批量操作中会使用缓存优化。
-   */
-  async calculatePaidAmountAsync() {
-    if (!this.store.currentOrder) {
-      this.logWarning("[Checkout] calculatePaidAmountAsync: 没有当前订单");
-      return "0.00";
-    }
-    try {
-      const now = Date.now();
-      const cacheValid = this.calculationCache.orderUuid === this.store.currentOrder.uuid && this.calculationCache.timestamp && now - this.calculationCache.timestamp < 5e3 && this.calculationCache.paidAmount;
-      if (cacheValid && this.calculationCache.paidAmount) {
-        return this.calculationCache.paidAmount;
-      }
-      const payments = await this.payment.getPaymentItemsAsync(
-        this.store.currentOrder.uuid,
-        false
-        // 不包括已撤销的支付项
-      );
-      const result = this.calculatePaidAmountFromItems(payments);
-      this.calculationCache.paidAmount = result;
-      this.logInfo("calculatePaidAmountAsync: 计算结果 =", result);
-      return result;
-    } catch (error) {
-      this.logError("calculatePaidAmountAsync 失败:", error);
-      return "0.00";
-    }
-  }
-  /**
-   * 从订单和支付项计算剩余金额（纯计算，不查询数据库）
-   */
-  calculateRemainingAmountFromData(currentOrder, paidAmount) {
-    let totalAmount = new import_decimal.default(currentOrder.total_amount || "0");
-    if (currentOrder.is_deposit && currentOrder.deposit_amount && Number(currentOrder.deposit_amount) > 0) {
-      totalAmount = new import_decimal.default(currentOrder.deposit_amount);
-    }
-    const paid = new import_decimal.default(paidAmount);
-    const remainingAmount = totalAmount.sub(paid);
-    return import_decimal.default.max(0, remainingAmount).toFixed(2);
-  }
-  /**
-   * 从订单和支付项计算剩余总金额（纯计算，排除定金）
-   */
-  calculateRemainingTotalAmountFromData(currentOrder, paidAmount) {
-    const totalAmount = new import_decimal.default(currentOrder.total_amount || "0");
-    const paid = new import_decimal.default(paidAmount);
-    const remainingAmount = totalAmount.sub(paid);
-    return import_decimal.default.max(0, remainingAmount).toFixed(2);
-  }
-  /**
-   * 计算剩余未支付金额（从 Payment 模块获取最新数据）
-   *
-   * 注意：此方法保持独立性，可以单独调用。
-   * 在 updateStateAmountToRemaining 等批量操作中会使用缓存优化。
-   */
-  async calculateRemainingAmountAsync() {
-    if (!this.store.currentOrder) {
-      this.logWarning("calculateRemainingAmountAsync: 没有当前订单");
-      return "0.00";
-    }
-    const { currentOrder } = await this.fetchOrderDataBatch();
-    if (!currentOrder) {
-      return "0.00";
-    }
-    const paidAmountStr = await this.calculatePaidAmountAsync();
-    const result = this.calculateRemainingAmountFromData(currentOrder, paidAmountStr);
-    this.logInfo("calculateRemainingAmountAsync: 计算=", result);
-    return result;
-  }
-  /**
-   * 计算剩余未支付金额（排除定金计算，始终使用订单总金额）
-   *
-   * 注意：此方法保持独立性，可以单独调用。
-   * 在 updateStateAmountToRemaining 等批量操作中会使用缓存优化。
-   */
-  async calculateRemainingTotalAmountAsync() {
-    if (!this.store.currentOrder) {
-      this.logWarning("calculateRemainingTotalAmountAsync: 没有当前订单");
-      return "0.00";
-    }
-    const { currentOrder } = await this.fetchOrderDataBatch();
-    if (!currentOrder) {
-      return "0.00";
-    }
-    const paidAmountStr = await this.calculatePaidAmountAsync();
-    const result = this.calculateRemainingTotalAmountFromData(currentOrder, paidAmountStr);
-    this.logInfo("calculateRemainingTotalAmountAsync: 计算=", result);
-    return result;
-  }
-  /**
-   * 更新 balanceDueAmount 为当前剩余未支付金额（系统内部计算）
-   */
-  async updateBalanceDueAmount() {
-    try {
-      const remainingAmount = await this.calculateRemainingAmountAsync();
-      const remainingTotalAmount = await this.calculateRemainingTotalAmountAsync();
-      const currentBalanceDueAmount = this.store.balanceDueAmount;
-      if (remainingAmount !== currentBalanceDueAmount) {
-        this.store.balanceDueAmount = remainingAmount;
-        await this.core.effects.emit(`${this.name}:onBalanceDueAmountChanged`, {
-          oldAmount: currentBalanceDueAmount,
-          newAmount: remainingAmount,
-          timestamp: Date.now(),
-          totalAmount: remainingTotalAmount
-        });
-        this.logInfo("balanceDueAmount 已自动更新:", {
-          oldAmount: currentBalanceDueAmount,
-          newAmount: remainingAmount
-        });
-      } else {
-        this.logInfo("balanceDueAmount 无需更新，当前值已是最新:", {
-          balanceDueAmount: currentBalanceDueAmount,
-          remainingAmount
-        });
-      }
-    } catch (error) {
-      this.logError("更新 balanceDueAmount 失败:", error);
-    }
-  }
-  /**
-   * 更新 stateAmount 为当前剩余未支付金额
-   *
-   * 优化版本：批量获取数据，避免重复查询数据库
-   */
-  async updateStateAmountToRemaining(checkOrder = true) {
-    try {
-      if (!this.store.currentOrder) {
-        return;
-      }
-      console.time("updateStateAmountToRemaining");
-      const { paymentItems, currentOrder } = await this.fetchOrderDataBatch();
-      console.timeEnd("updateStateAmountToRemaining");
-      if (!currentOrder) {
-        this.logWarning("updateStateAmountToRemaining: 未找到当前订单");
-        return;
-      }
-      const paidAmount = this.calculatePaidAmountFromItems(paymentItems);
-      this.calculationCache.paidAmount = paidAmount;
-      let needUpdateDepositStatus = false;
-      if (currentOrder.is_deposit === 1) {
-        const depositPaidAmount = paymentItems.filter(
-          (item) => item.order_payment_type === "deposit" && item.status !== "voided"
-        ).reduce((sum, item) => {
-          if (item.voucher_id && !item.isSynced && paymentItems.filter((item2) => !item2.voucher_id).length === 0) {
-            return sum;
-          }
-          const amount = new import_decimal.default(item.amount || "0");
-          const roundingAmount = new import_decimal.default(item.rounding_amount || "0");
-          return sum.add(amount.add(roundingAmount.isNegative() ? roundingAmount.abs() : 0));
-        }, new import_decimal.default(0));
-        if (depositPaidAmount.gte(currentOrder.deposit_amount || "0")) {
-          needUpdateDepositStatus = true;
-          currentOrder.is_deposit = 0;
-        }
-      }
-      const remainingAmount = this.calculateRemainingAmountFromData(currentOrder, paidAmount);
-      const remainingTotalAmount = this.calculateRemainingTotalAmountFromData(currentOrder, paidAmount);
-      const currentStateAmount = this.store.stateAmount;
-      const currentBalanceDueAmount = this.store.balanceDueAmount;
-      let hasStateChanged = false;
-      if (needUpdateDepositStatus) {
-        this.store.currentOrder = {
-          ...this.store.currentOrder,
-          is_deposit: 0
-        };
-        await this.payment.updateOrderAsync(this.store.currentOrder.uuid, {
-          is_deposit: 0
-        });
-        hasStateChanged = true;
-      }
-      console.time("updateStateAmountToRemaining: remainingAmount");
-      if (remainingAmount !== currentStateAmount) {
-        this.store.stateAmount = remainingAmount;
-        hasStateChanged = true;
-        setTimeout(() => {
-          this.core.effects.emit(`${this.name}:onStateAmountChanged`, {
-            oldAmount: currentStateAmount,
-            newAmount: remainingAmount,
-            timestamp: Date.now(),
-            totalAmount: remainingTotalAmount
-          });
-        }, 0);
-        this.logInfo("stateAmount 已自动更新为剩余金额:", {
-          oldAmount: currentStateAmount,
-          newAmount: remainingAmount
-        });
-      }
-      console.timeEnd("updateStateAmountToRemaining: remainingAmount");
-      console.time("updateStateAmountToRemaining: updateStateAmountToRemaining");
-      if (remainingAmount !== currentBalanceDueAmount) {
-        this.store.balanceDueAmount = remainingAmount;
-        hasStateChanged = true;
-        setTimeout(() => {
-          this.core.effects.emit(`${this.name}:onBalanceDueAmountChanged`, {
-            oldAmount: currentBalanceDueAmount,
-            newAmount: remainingAmount,
-            timestamp: Date.now(),
-            totalAmount: remainingTotalAmount
-          });
-        }, 0);
-        this.logInfo("balanceDueAmount 已自动更新:", {
-          oldAmount: currentBalanceDueAmount,
-          newAmount: remainingAmount
-        });
-      }
-      console.timeEnd("updateStateAmountToRemaining: updateStateAmountToRemaining");
-      if (!hasStateChanged) {
-        this.logInfo("状态无需更新，当前值已是最新:", {
-          stateAmount: currentStateAmount,
-          remainingAmount
-        });
-      }
-      if (checkOrder) {
-        await this.checkOrderPaymentCompletionOptimized(paymentItems, remainingAmount);
-      } else {
-        this.logInfo("外部传入无需 checkOrder，不执行订单支付完成检测和同步");
-      }
-    } catch (error) {
-      this.logError("更新 stateAmount 为剩余金额失败:", error);
-    }
-  }
-  /**
-   * 检查订单支付是否完成（优化版，复用已获取的数据）
-   *
-   * @param paymentItems 已获取的支付项数据
-   * @param remainingAmount 已计算的剩余金额
-   */
-  async checkOrderPaymentCompletionOptimized(paymentItems, remainingAmount) {
-    try {
-      if (!this.store.currentOrder) {
-        return;
-      }
-      const remainingValue = new import_decimal.default(remainingAmount);
-      if (remainingValue.lte(0)) {
-        const totalAmount = this.store.currentOrder.total_amount;
-        const paidAmount = this.calculationCache.paidAmount || "0.00";
-        this.logInfo("检测到订单支付完成:", {
-          orderUuid: this.store.currentOrder.uuid,
-          orderId: this.store.currentOrder.order_id,
-          totalAmount,
-          paidAmount,
-          remainingAmount,
-          isOrderSynced: this.store.isOrderSynced
-        });
-        const hasPaymentItems = paymentItems.length > 0;
-        const allPaymentsHaveVoucherId = hasPaymentItems && paymentItems.every(
-          (item) => item.status !== "voided" && item.voucher_id
-        );
-        const shouldAutoSync = hasPaymentItems && !allPaymentsHaveVoucherId;
-        this.logInfo("自动同步订单条件检查:", {
-          paymentCount: paymentItems.length,
-          hasPaymentItems,
-          allHaveVoucherId: allPaymentsHaveVoucherId,
-          isOrderSynced: this.store.isOrderSynced,
-          shouldAutoSync,
-          reason: shouldAutoSync ? "支付完成，需要同步最终支付状态" : "跳过同步",
-          paymentItems: paymentItems.map((p) => ({
-            uuid: p.uuid,
-            code: p.code,
-            amount: p.amount,
-            rounding_amount: p.rounding_amount,
-            effective_amount: (parseFloat(p.amount || "0") + Math.abs(parseFloat(Number(p.rounding_amount) > 0 ? "0" : p.rounding_amount || "0"))).toFixed(2),
-            voucher_id: p.voucher_id,
-            status: p.status
-          }))
-        });
-        if (shouldAutoSync) {
-          this.logInfo("满足自动同步条件，开始同步订单到后端...");
-          await this.syncOrderToBackendWithReturn(false);
-        } else {
-          if (!hasPaymentItems) {
-            this.logInfo("没有支付项，跳过订单同步");
-          } else if (allPaymentsHaveVoucherId) {
-            this.logInfo("所有支付项均为代金券类型，跳过订单同步");
-          }
-        }
-        await this.core.effects.emit(`${this.name}:onOrderPaymentCompleted`, {
-          orderUuid: this.store.currentOrder.uuid,
-          orderId: this.store.currentOrder.order_id,
-          totalAmount,
-          paidAmount,
-          remainingAmount,
-          timestamp: Date.now()
-        });
-      }
-    } catch (error) {
-      this.logError("检查订单支付完成状态失败:", error);
-    }
-  }
-  /**
-   * 检查订单支付是否完成
-   *
-   * 当剩余待付款金额 <= 0 时，触发订单支付完成事件
-   *
-   * 注意：此方法保持独立性，可以单独调用。
-   * 在 updateStateAmountToRemaining 中会使用优化版本。
-   */
-  async checkOrderPaymentCompletion() {
-    try {
-      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();
-        this.logInfo("检测到订单支付完成:", {
-          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;
-        this.logInfo("自动同步订单条件检查:", {
-          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(Number(p.rounding_amount) > 0 ? "0" : p.rounding_amount || "0"))).toFixed(2),
-            voucher_id: p.voucher_id,
-            status: p.status
-          }))
-        });
-        if (shouldAutoSync) {
-          this.logInfo("满足自动同步条件，开始同步订单到后端...");
-          await this.syncOrderToBackendWithReturn(false);
-        } else {
-          if (!hasPaymentItems) {
-            this.logInfo("没有支付项，跳过订单同步");
-          } else if (allPaymentsHaveVoucherId) {
-            this.logInfo("所有支付项均为代金券类型，跳过订单同步");
-          }
-        }
-        await this.core.effects.emit(`${this.name}:onOrderPaymentCompleted`, {
-          orderUuid: this.store.currentOrder.uuid,
-          orderId: this.store.currentOrder.order_id,
-          totalAmount,
-          paidAmount,
-          remainingAmount,
-          timestamp: Date.now()
-        });
-      }
-    } catch (error) {
-      this.logError("检查订单支付完成状态失败:", error);
-    }
-  }
-  /**
-   * 同步订单到后端并返回真实订单ID
-   *
-   * @param isManual 是否为手动同步，默认为 false
-   * @param customPaymentItems 自定义支付项列表，如果提供则使用此列表而不是从数据库获取
-   * @returns 包含订单ID、UUID和完整后端响应的对象
-   */
-  async syncOrderToBackendWithReturn(isManual = false, customPaymentItems) {
-    var _a, _b, _c, _d, _e, _f, _g, _h;
-    if (!this.store.localOrderData || !this.store.currentOrder) {
-      throw new Error("缺少必要的订单数据，无法同步到后端");
-    }
-    this.logInfo("syncOrderToBackendWithReturn called", { isManual });
-    const currentOrderId = this.store.currentOrder.order_id;
-    const isUpdateOperation = this.store.isOrderSynced || !(0, import_utils.isVirtualOrderId)(currentOrderId);
-    this.logInfo(`开始同步订单到后端...`, {
-      currentOrderId,
-      isVirtualId: (0, import_utils.isVirtualOrderId)(currentOrderId || ""),
-      orderUuid: this.store.currentOrder.uuid,
-      isOrderSynced: this.store.isOrderSynced,
-      isManual
-    });
-    const paymentItems = customPaymentItems || await this.payment.getPaymentItemsAsync(this.store.currentOrder.uuid);
-    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
-        }
-      };
-    });
-    let finalDepositAmount;
-    const manualDepositAmount = ((_a = this.store.currentOrder) == null ? void 0 : _a.deposit_amount) || "0.00";
-    const manualDepositValue = new import_decimal.default(manualDepositAmount);
-    if (manualDepositValue.gt(0)) {
-      finalDepositAmount = manualDepositAmount;
-      this.logInfo("使用手动设置的定金金额", {
-        manualDepositAmount,
-        reason: "用户通过setDepositAmountAsync手动设置了定金金额"
-      });
-    } else {
-      finalDepositAmount = "0.00";
-      this.logInfo("定金金额为0", {
-        manualDepositAmount,
-        reason: "手动设置和计算值均为0"
-      });
-    }
-    if (this.store.currentOrder.is_deposit === 0 && processedPaymentItems.every((item) => item.order_payment_type !== "deposit")) {
-      finalDepositAmount = "0.00";
-      this.store.currentOrder.is_deposit = 0;
-    }
-    if (this.store.currentOrder.is_deposit === 0 && processedPaymentItems.some((item) => item.order_payment_type === "deposit")) {
-      finalDepositAmount = processedPaymentItems.filter((item) => item.status !== "voided" && item.order_payment_type === "deposit").reduce((sum, item) => {
-        const amt = new import_decimal.default(item.amount || "0");
-        const rounding = new import_decimal.default(item.rounding_amount || "0");
-        return sum.plus(amt).sub(rounding);
-      }, new import_decimal.default(0)).toFixed(2);
-    }
-    if (this.store.currentOrder.is_deposit === 1 && new import_decimal.default(finalDepositAmount).gte(new import_decimal.default(this.store.currentOrder.total_amount))) {
-      finalDepositAmount = processedPaymentItems.filter((item) => item.status !== "voided" && item.order_payment_type === "deposit").reduce((sum, item) => {
-        const amt = new import_decimal.default(item.amount || "0");
-        const rounding = new import_decimal.default(item.rounding_amount || "0");
-        return sum.plus(amt).sub(rounding);
-      }, new import_decimal.default(0)).toFixed(2);
-    }
-    this.logInfo("定金金额确定结果", {
-      depositPaymentItemsCount: processedPaymentItems.length,
-      depositPaymentItems: processedPaymentItems.map((item) => ({
-        uuid: item.uuid,
-        code: item.code,
-        amount: item.amount,
-        rounding_amount: item.rounding_amount,
-        order_payment_type: item.order_payment_type,
-        status: item.status
-      })),
-      manualDepositAmount,
-      finalDepositAmount,
-      isDeposit: ((_b = this.store.currentOrder) == null ? void 0 : _b.is_deposit) || 0
-    });
-    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) || Number(finalDepositAmount) > 0 ? 1 : 0) || 0,
-      deposit_amount: finalDepositAmount,
-      // 使用最终确定的定金金额（手动设置优先）
-      product_tax_fee: this.store.localOrderData.tax_fee,
-      note: this.store.localOrderData.shop_note,
-      bookings: (_e = this.store.localOrderData.bookings) == null ? void 0 : _e.map((item) => {
-        return {
-          ...item,
-          product: {
-            ...item.product,
-            custom_deposit_data: void 0
-          },
-          deposit: void 0
-        };
-      }),
-      relation_products: (_f = this.store.localOrderData.relation_products) == null ? void 0 : _f.map(
-        (item) => {
-          return {
-            ...item,
-            custom_deposit_data: void 0,
-            deposit: void 0
-          };
-        }
-      )
-    };
-    if (isUpdateOperation) {
-      if ((0, import_utils.isVirtualOrderId)(currentOrderId)) {
-        this.logWarning(
-          "尝试数据修复：暂时不包含order_id，注意：这次调用将作为创建操作处理，但后续会修复数据一致性"
-        );
-      } else {
-        orderParams.order_id = currentOrderId;
-      }
-    }
-    const startTime = Date.now();
-    await this.core.effects.emit(`${this.name}: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",
-        isManual,
-        ...orderParams
-      });
-      checkoutResponse = await this.order.createOrderByCheckout(orderParams);
-      submitSuccess = true;
-      this.logInfo("下单接口调用成功", checkoutResponse);
-    } catch (error) {
-      submitSuccess = false;
-      submitError = error instanceof Error ? error.message : String(error);
-      this.logError("下单接口调用失败:", submitError);
-      await this.core.effects.emit(`${this.name}: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(`${this.name}:onOrderSubmitEnd`, {
-        success: submitSuccess,
-        orderUuid: this.store.currentOrder.uuid,
-        operation: isUpdateOperation ? "update" : "create",
-        isManual,
-        orderId: submitSuccess ? ((_g = checkoutResponse == null ? void 0 : checkoutResponse.data) == null ? void 0 : _g.order_id) || (checkoutResponse == null ? void 0 : checkoutResponse.order_id) : void 0,
-        error: submitError,
-        duration: Date.now() - startTime,
-        timestamp: Date.now()
-      });
-    }
-    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) || "订单同步失败，后端返回非成功状态";
-      await this.core.effects.emit(`${this.name}: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);
-    }
-    let realOrderId;
-    if (isUpdateOperation) {
-      realOrderId = currentOrderId;
-    } else {
-      let extractedOrderId = (_h = checkoutResponse == null ? void 0 : checkoutResponse.data) == null ? void 0 : _h.order_id;
-      if (!extractedOrderId) {
-        extractedOrderId = checkoutResponse == null ? void 0 : checkoutResponse.order_id;
-      }
-      if (extractedOrderId !== void 0 && extractedOrderId !== null) {
-        extractedOrderId = String(extractedOrderId);
-      }
-      if (!extractedOrderId) {
-        this.logError("后端返回的订单信息中未包含订单ID");
-      }
-      realOrderId = extractedOrderId;
-      this.logInfo("准备替换订单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
-        );
-        this.logInfo("Payment模块替换订单ID结果:", {
-          wasSuccessful: !!updatedOrder,
-          returnedOrderId: updatedOrder == null ? void 0 : updatedOrder.order_id,
-          expectedOrderId: realOrderId
-        });
-        if (updatedOrder) {
-          this.logInfo("Payment模块返回的更新后订单:", {
-            uuid: updatedOrder.uuid,
-            orderId: updatedOrder.order_id,
-            totalAmount: updatedOrder.total_amount
-          });
-          this.store.currentOrder = updatedOrder;
-          this.logInfo(
-            "[Checkout] 订单ID替换成功，当前订单ID:",
-            this.store.currentOrder.order_id
-          );
-        } else {
-          this.logError(
-            "[Checkout] Payment模块返回空订单，订单ID替换失败，开始手动替换"
-          );
-          const beforeManualUpdate = this.store.currentOrder.order_id;
-          this.store.currentOrder.order_id = realOrderId;
-          this.logInfo("手动设置订单ID:", {
-            beforeReplacement: beforeManualUpdate,
-            afterReplacement: this.store.currentOrder.order_id,
-            目标ID: realOrderId
-          });
-        }
-      } catch (error) {
-        this.logError("调用Payment模块替换订单ID时发生错误:", error);
-        this.store.currentOrder.order_id = realOrderId;
-        this.logInfo("错误恢复：手动设置订单ID:", realOrderId);
-      }
-    }
-    try {
-      const syncedPaymentUuids = processedPaymentItems.filter((item) => item.status !== "voided").map((item) => item.uuid).filter(Boolean);
-      for (const paymentUuid of syncedPaymentUuids) {
-        await this.payment.updatePaymentAsync(
-          this.store.currentOrder.uuid,
-          paymentUuid,
-          { isSynced: true, syncError: void 0 }
-        );
-      }
-    } catch (e) {
-      this.logWarning("标记支付项已同步失败（不阻塞主流程）", { error: e });
-    }
-    this.store.isOrderSynced = true;
-    this.clearCalculationCache();
-    await this.core.effects.emit(`${this.name}:onOrderSynced`, {
-      orderUuid: this.store.currentOrder.uuid,
-      realOrderId,
-      virtualOrderId: this.store.currentOrder.order_id,
-      timestamp: Date.now(),
-      isManual,
-      response: checkoutResponse
-    });
-    return {
-      success: true,
-      orderId: realOrderId,
-      orderUuid: this.store.currentOrder.uuid,
-      response: checkoutResponse
-    };
-  }
-  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
-    });
-    try {
-      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
-      });
-      this.logInfo("订单备注编辑响应:", {
-        orderId,
-        status: response.status,
-        message: response.message,
-        response
-      });
-      if (response.status === true || response.status === 200) {
-        if (this.store.currentOrder && (String(this.store.currentOrder.order_id) === String(orderId) || String(this.store.currentOrder.id) === String(orderId))) {
-          const previousNote = this.getOrderNote();
-          if (this.store.localOrderData) {
-            this.store.localOrderData.shop_note = note;
-          }
-          await this.core.effects.emit(`${this.name}: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 || "订单备注修改失败";
-        this.logError(`订单 ${orderId} 备注修改失败:`, errorMessage);
-        return {
-          success: false,
-          message: errorMessage,
-          orderId
-        };
-      }
-    } catch (error) {
-      this.logError("编辑订单备注失败:", 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 {
-      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
-      };
-      this.logInfo("Calling batch email API", {
-        url: "/order/batch-email",
-        ...requestBody
-      });
-      const response = await this.request.post(
-        "/order/batch-email",
-        requestBody
-      );
-      this.logInfo("支付链接邮件发送响应:", {
-        status: response.status,
-        message: response.message,
-        data: response.data,
-        response
-      });
-      if (response.status === true || response.status === 200) {
-        return {
-          success: true,
-          message: response.message || "支付链接邮件发送成功"
-        };
-      } else {
-        const errorMessage = response.message || "支付链接邮件发送失败";
-        console.error("[Checkout] 支付链接邮件发送失败:", errorMessage);
-        return {
-          success: false,
-          message: errorMessage
-        };
-      }
-    } catch (error) {
-      this.logError("发送客户支付链接邮件失败:", error);
-      const errorMessage = error instanceof Error ? error.message : "网络错误或服务器异常";
-      return {
-        success: false,
-        message: `发送支付链接邮件失败: ${errorMessage}`
-      };
-    }
-  }
-  /**
-   * 金额舍入
-   *
-   * @param amount 原始金额
-   * @returns 舍入结果详情，包含原始金额、舍入后金额和舍入差额
-   */
-  async roundAmountAsync(amount) {
-    var _a, _b, _c;
-    const cashManualPayment = this.store.paymentMethods.find((p) => p.code === "CASHMANUAL");
-    if (!((_a = cashManualPayment == null ? void 0 : cashManualPayment.metadata) == null ? void 0 : _a.order_rounding_switch)) {
-      return {
-        originalAmount: amount.toString(),
-        roundedAmount: amount.toString(),
-        roundingDifference: "0.00"
-      };
-    }
-    const result = await this.payment.roundAmountAsync(
-      amount,
-      (_b = this.otherParams.order_rounding_setting) == null ? void 0 : _b.interval,
-      (_c = this.otherParams.order_rounding_setting) == null ? void 0 : _c.type
-    );
-    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 状态
-   *
-   * 在创建新订单前调用，确保状态完全干净
-   *
-   * 🚀 性能优化：改为同步方法，事件发射不阻塞主流程
-   */
-  resetStoreState() {
-    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.clearCalculationCache();
-      console.log("[Checkout] Store 状态重置完成");
-      if (prevOrderInfo) {
-        setTimeout(() => {
-          this.core.effects.emit(`${this.name}:onOrderCleared`, {
-            previousOrder: prevOrderInfo,
-            timestamp: Date.now()
-          });
-        }, 0);
-      }
-    } catch (error) {
-      console.error("[Checkout] 重置 store 状态失败:", error);
-    }
-  }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  CheckoutImpl,
-  ...require("./types")
-});