@pisell/pisellos 2.3.74 → 2.3.76

package/lib/solution/Checkout/index.js

@@ -1,346 +1,362 @@
-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;
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  CheckoutImpl: true
 };
-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
+exports.CheckoutImpl = void 0;
+var _BaseModule = require("../../modules/BaseModule");
+var _decimal = _interopRequireDefault(require("decimal.js"));
+var _Order = require("../../modules/Order");
+var _Payment = require("../../modules/Payment");
+var _types = require("./types");
+Object.keys(_types).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _types[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _types[key];
+    }
+  });
 });
-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 {
+var _types2 = require("../../modules/Payment/types");
+var _utils = require("./utils");
+var _utils2 = require("../../modules/Cart/utils");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * 结账解决方案实现
+ *
+ * 整合订单处理和支付功能，提供完整的结账流程管理。
+ * 支持多种支付方式，提供实时状态跟踪和错误处理。
+ */
+class CheckoutImpl extends _BaseModule.BaseModule {
+  defaultName = 'checkout';
+  defaultVersion = '1.0.0';
+  isSolution = true;
+  request;
+  store;
+  otherParams = {};
+  logger; // LoggerManager 实例
+
+  // 计算缓存（用于性能优化）
+  calculationCache = {};
+
+  // 同步订单到后端锁（按订单维度），防止短时间内重复触发导致同一订单多次同步
+  syncOrderToBackendInFlightByOrderKey = new Map();
+
+  // 直接挂载的模块
+  order;
+  payment;
   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 = {};
-    // 同步订单到后端锁（按订单维度），防止短时间内重复触发导致同一订单多次同步
-    this.syncOrderToBackendInFlightByOrderKey = /* @__PURE__ */ new Map();
+    super(name || 'checkout', version || '1.0.0');
   }
   async initialize(core, options) {
     this.core = core;
     this.otherParams = options.otherParams || {};
-    this.request = core.getPlugin("request");
+
+    // 获取依赖的插件
+    this.request = core.getPlugin('request');
     if (!this.request) {
-      throw new Error("Checkout 解决方案需要 request 插件支持");
+      throw new Error('Checkout 解决方案需要 request 插件支持');
     }
-    const appPlugin = core.getPlugin("app");
+
+    // 获取 logger 实例
+    const appPlugin = core.getPlugin('app');
     if (!appPlugin) {
-      throw new Error("Checkout 解决方案需要 app 插件支持");
+      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.order = new _Order.OrderModule();
+    this.payment = new _Payment.PaymentModule();
+
+    // 初始化状态
     this.store = {
       cartItems: [],
       paymentMethods: [],
-      stateAmount: "0.00",
-      balanceDueAmount: "0.00",
-      cartSummary: void 0,
+      stateAmount: '0.00',
+      balanceDueAmount: '0.00',
+      cartSummary: undefined,
       isOrderSynced: false,
-      currentCustomer: void 0
+      currentCustomer: undefined
     };
+
+    // 注册并初始化子模块
     await this.initializeSubModules(core, options);
-    console.log("[Checkout] 初始化完成");
+
+    // 预加载支付方式（利用缓存机制）
+    // await this.preloadPaymentMethods();
+
+    // 清理过期的已同步订单数据
+    // await this.cleanupExpiredOrdersAsync();
+
     await this.core.effects.emit(`${this.name}:onCheckoutInitialized`, {
       timestamp: Date.now()
     });
-    this.logInfo("CheckoutModule initialized successfully");
+    this.logInfo('CheckoutModule initialized successfully');
   }
+
   /**
    * 记录信息日志
    */
   logInfo(title, metadata) {
     if (this.logger) {
       this.logger.addLog({
-        type: "info",
+        type: 'info',
         title: `[CheckoutModule]  ${this.getCurrentOrderId()} ${title}`,
         metadata: metadata || {}
       });
     }
   }
+
   /**
    * 记录警告日志
    */
   logWarning(title, metadata) {
     if (this.logger) {
       this.logger.addLog({
-        type: "warning",
+        type: 'warning',
         title: `[CheckoutModule] ${title}`,
         metadata: metadata || {}
       });
     }
   }
+
   /**
    * 记录错误日志
    */
   logError(title, metadata) {
     if (this.logger) {
       this.logger.addLog({
-        type: "error",
+        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 }
+      store: options.store?.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 }
+      store: options.store?.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) {
+    // 监听支付成功事件
+    this.core.effects.on('payment:onPaymentSyncSuccess', async data => {
+      if (this.store.currentOrder?.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) {
+
+    // 监听支付失败事件
+    this.core.effects.on('payment:onPaymentSyncError', async data => {
+      if (this.store.currentOrder?.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;
-      }
-    );
+
+    // 监听支付方式加载完成事件
+    this.core.effects.on(_types2.PaymentHooks.OnPaymentMethodsLoaded, async methods => {
+      this.store.paymentMethods = methods;
+    });
+
+    // 监听支付方式变更事件
+    this.core.effects.on(_types2.PaymentHooks.OnPaymentMethodsChanged, async data => {
+      this.store.paymentMethods = data.newMethods;
+    });
   }
+
   /**
    * 初始化结账流程
    */
   async initializeCheckoutAsync(params) {
-    var _a;
-    this.logInfo("initializeCheckoutAsync called", {
-      cartItemsCount: ((_a = params.cartItems) == null ? void 0 : _a.length) || 0,
+    this.logInfo('initializeCheckoutAsync called', {
+      cartItemsCount: params.cartItems?.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(", ")}`
-        );
+        throw (0, _utils.createCheckoutError)(_types.CheckoutErrorType.ValidationFailed, `参数验证失败: ${validation.errors.join(', ')}`);
       }
+
+      // 保存购物车数据
       this.store.cartItems = params.cartItems;
-      console.log("[Checkout] 结账流程初始化完成");
     } catch (error) {
-      await this.handleError(error, import_types.CheckoutErrorType.UnknownError);
+      await this.handleError(error, _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 (!obj) return undefined;
+    let ret = obj.holder_id || obj.holder?.form_record;
     if (Array.isArray(ret)) {
-      return ret.length > 0 ? Number(ret[0]) : void 0;
+      return ret.length > 0 ? Number(ret[0]) : undefined;
     }
-    return Number(ret) || void 0;
+    return Number(ret) || undefined;
   }
   getProductListByOrder() {
-    var _a, _b, _c, _d, _e;
     if (!this.store.currentOrder) {
       return [];
     }
-    const getDiscountListAmount = (list) => {
+    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,
-          is_price_include_tax: item.is_price_include_tax,
-          // 商品是否含税：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 {
-              is_price_include_tax: item.is_price_include_tax,
-              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) => {
+    const formatProduct = items => {
+      return items.map(item => ({
+        product_id: item.product_id,
+        product_variant_id: item.product_variant_id,
+        quantity: item.num,
+        is_price_include_tax: item.is_price_include_tax,
+        // 商品是否含税：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 {
-            ...item.product,
-            holder_id: this.getHolderIdFromBooking(item)
+            is_price_include_tax: item.is_price_include_tax,
+            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 relationProducts = formatProduct(((_e = (_d = this.store.currentOrder.order_info) == null ? void 0 : _d.original_order_data) == null ? void 0 : _e.relation_products) || []);
+        })
+      })) || [];
+    };
+    const productList = formatProduct(this.store.currentOrder.order_info?.original_order_data?.bookings?.map(item => {
+      return {
+        ...item.product,
+        holder_id: this.getHolderIdFromBooking(item)
+      };
+    }) || []);
+    const relationProducts = formatProduct(this.store.currentOrder.order_info?.original_order_data?.relation_products || []);
     return [...productList, ...relationProducts];
   }
   async initWalletData(params) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
-    this.logInfo("initWalletData called", {
+    this.logInfo('initWalletData called', {
       params
     });
     try {
-      const amountInfo = (_b = (_a = this.store.currentOrder) == null ? void 0 : _a.order_info) == null ? void 0 : _b.amount_breakdown;
+      const amountInfo = this.store.currentOrder?.order_info?.amount_breakdown;
       if (!amountInfo) {
-        this.logInfo("initWalletData amountInfo not found", {
+        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,
-        holder: (_f = (_e = (_d = this.store.currentOrder) == null ? void 0 : _d.order_info) == null ? void 0 : _e.original_order_data) == null ? void 0 : _f.holder,
+        customer_id: this.store.currentCustomer?.customer_id ? Number(this.store.currentCustomer.customer_id) : undefined,
+        holder: this.store.currentOrder?.order_info?.original_order_data?.holder,
         amountInfo: {
           totalAmount: amountInfo.totalAmount,
           subTotal: amountInfo.subTotal,
-          depositAmount: (_g = this.store.currentOrder) == null ? void 0 : _g.deposit_amount,
-          isDeposit: (_h = this.store.currentOrder) == null ? void 0 : _h.is_deposit
+          depositAmount: this.store.currentOrder?.deposit_amount,
+          isDeposit: this.store.currentOrder?.is_deposit
         },
         products: this.getProductListByOrder(),
         is_price_include_tax: this.otherParams.is_price_include_tax,
         // core 有
         ...params
       };
+      // 判断订单是否已经同步，如果是则追加payment_order_id参数
       if (this.store.isOrderSynced) {
-        walletBusinessData.payment_order_id = (_i = this.store.currentOrder) == null ? void 0 : _i.order_id;
+        walletBusinessData.payment_order_id = this.store.currentOrder?.order_id;
       }
-      this.logInfo("开始拉取:initializeWalletDataFromBusinessAsync", {
+      this.logInfo('开始拉取:initializeWalletDataFromBusinessAsync', {
         walletBusinessData
       });
-      await this.payment.wallet.initializeWalletDataFromBusinessAsync(
-        walletBusinessData
-      );
-      this.logInfo("调用结束:initializeWalletDataFromBusinessAsync", {
+      await this.payment.wallet.initializeWalletDataFromBusinessAsync(walletBusinessData);
+      this.logInfo('调用结束:initializeWalletDataFromBusinessAsync', {
         walletBusinessData
       });
+
+      // 因为上面是接口 这里最好检查一下还有没有 currentOrder 了，如果没有，则不触发事件
       if (!this.store.currentOrder) {
         return;
       }
-      this.logInfo("initWalletData currentOrder found", {
+      this.logInfo('initWalletData currentOrder found', {
         currentOrder: this.store.currentOrder
       });
+      // 触发钱包数据初始化完成事件
       await this.core.effects.emit(`${this.name}:onWalletDataInitialized`, {
-        orderUuid: (_j = this.store.currentOrder) == null ? void 0 : _j.uuid,
+        orderUuid: this.store.currentOrder?.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
+          order_wait_pay_amount: params?.order_wait_pay_amount
         },
         timestamp: Date.now()
       });
     } catch (error) {
-      this.logError("initWalletData error", {
+      this.logError('initWalletData error', {
         error: error instanceof Error ? error.message : String(error)
       });
       throw error;
@@ -352,11 +368,11 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       protocols: [],
       hasDeposit: false
     };
-    bookings == null ? void 0 : bookings.forEach((item) => {
+    bookings?.forEach(item => {
       const total = item.product.calculated_selling_price;
-      const deposit = (0, import_utils2.getProductDeposit)({
+      const deposit = (0, _utils2.getProductDeposit)({
         cartItem: {
-          total
+          total: total
         },
         product: item.product,
         bundle: item.bundle,
@@ -364,16 +380,14 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         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();
+      if (deposit?.total && Number(deposit.total) > 0) {
+        summaryDeposit.protocols = summaryDeposit.protocols.concat(deposit.protocols);
+        summaryDeposit.total = new _decimal.default(summaryDeposit.total).plus(deposit.total).toNumber();
         summaryDeposit.hasDeposit = true;
       }
     });
-    relationProducts == null ? void 0 : relationProducts.forEach((item) => {
-      const deposit = (0, import_utils2.getProductDeposit)({
+    relationProducts?.forEach(item => {
+      const deposit = (0, _utils2.getProductDeposit)({
         cartItem: {
           total: item.price * item.num
         },
@@ -383,20 +397,22 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         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();
+      if (deposit?.total && Number(deposit.total) > 0) {
+        // 需要减去商品券折扣卡抵扣的金额
+        summaryDeposit.total = new _decimal.default(summaryDeposit.total).plus(deposit.total).toNumber();
+        item.discount_list.forEach(discount => {
+          summaryDeposit.total = new _decimal.default(summaryDeposit.total).minus(discount.amount || 0).toNumber();
         });
-        summaryDeposit.protocols = summaryDeposit.protocols.concat(
-          deposit.protocols
-        );
+        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();
+
+    // 将总金额四舍五入到两位小数
+    summaryDeposit.total = new _decimal.default(summaryDeposit.total).toDecimalPlaces(2, _decimal.default.ROUND_HALF_UP).toNumber();
     return summaryDeposit;
   }
+
   /**
    * 创建本地订单 (前端模拟下单流程)
    *
@@ -405,60 +421,72 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
    * 方法会记录参数并创建本地虚拟订单，然后用 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,
+    this.logInfo('createLocalOrderAsync called', {
+      orderDataType: params.orderData?.type,
+      platform: params.orderData?.platform,
+      bookingsCount: params.orderData?.bookings?.length || 0,
+      relationProductsCount: params.orderData?.relation_products?.length || 0,
+      customerId: params.orderData?.customer_id,
       autoPayment: params.autoPayment,
-      cartSummaryCount: ((_h = params.cartSummary) == null ? void 0 : _h.length) || 0,
+      cartSummaryCount: params.cartSummary?.length || 0,
       totalInfoKeys: params.totalInfo ? Object.keys(params.totalInfo) : []
     });
     try {
+      // 🔧 修改：在创建新订单前，直接重置 store 状态（同步执行）
       this.resetStoreState();
-      const validation = (0, import_utils.validateLocalOrderData)(params.orderData);
+      // 验证订单数据
+      const validation = (0, _utils.validateLocalOrderData)(params.orderData);
       if (!validation.valid) {
-        throw (0, import_utils.createCheckoutError)(
-          import_types.CheckoutErrorType.ValidationFailed,
-          `订单数据验证失败: ${validation.errors.join(", ")}`
-        );
+        throw (0, _utils.createCheckoutError)(_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;
+
+      // 生成本地虚拟订单ID (后续可以被真实订单ID替换)
+      const localOrderId = (0, _utils.generateLocalOrderId)();
+
+      // 从购物车小计数据中提取金额信息
+      const amountInfo = (0, _utils.extractAmountFromCartSummary)(params.cartSummary);
+      // TODO： 外面传的是 pos ，但是现在 后端只有 shop 和 kiosk
+      params.orderData.platform = 'pos';
+      // 补充 created_at 时间 (YYYY-MM-DD hh:mm:ss 格式)
+      params.orderData.created_at = (0, _utils.formatDateTime)(new Date());
+      // 补充附加费信息
+      params.orderData.surcharge_fee = params.totalInfo?.total?.otherAmount;
+      params.orderData.surcharges = params.totalInfo?.total?.surcharge;
+      // 补充订单折扣信息
+      params.orderData.shop_discount = params.totalInfo?.total?.shopDiscount;
+      // 补充税费信息
+      params.orderData.tax_fee = params.totalInfo?.total?.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] 未提供客户信息");
+        this.store.currentCustomer = undefined;
       }
-      const isNeedDeposit = this.checkIsNeedDepositAsync(
-        params.orderData.bookings,
-        params.orderData.relation_products
-      );
+
+      // 计算是否需要支付定金，如果需要默认切换到定金模式，以及记录定金总金额，并把当前默认待付金额调整为定金总金额
+      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",
+        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(),
+          created_at: new Date().toISOString(),
           platform: params.orderData.platform,
           type: params.orderData.type,
           schedule_date: params.orderData.schedule_date,
@@ -467,21 +495,30 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         }
       });
       this.store.currentOrder = paymentOrder;
+
+      // // 如果设置了自动支付，直接跳转到支付步骤
+      // if (params.autoPayment) {
+      //   // 自动支付模式标记
+      // }
+
       this.core.effects.emit(`${this.name}:onOrderCreated`, {
         order: paymentOrder,
         timestamp: Date.now()
       });
+
+      // 自动设置 stateAmount 为剩余未支付金额
+      // 🚀 性能监控：记录 updateStateAmountToRemaining 操作耗时
       const updateAmountStartTime = Date.now();
       await this.updateStateAmountToRemaining(false);
       const updateAmountDuration = Date.now() - updateAmountStartTime;
-      this.logInfo("updateStateAmountToRemaining operation completed", {
-        operation: "updateStateAmountToRemaining",
+      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"
+        performance: updateAmountDuration > 200 ? 'slow' : updateAmountDuration > 100 ? 'medium' : 'fast'
       });
-      this.logInfo("本地订单创建成功:", {
+      this.logInfo('本地订单创建成功:', {
         localOrderId,
         uuid: paymentOrder.uuid,
         totalAmount: amountInfo.totalAmount,
@@ -492,11 +529,8 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       this.initWalletData();
       return paymentOrder;
     } catch (error) {
-      await this.handleError(
-        error,
-        import_types.CheckoutErrorType.OrderCreationFailed
-      );
-      this.logError("本地订单创建失败:", error);
+      await this.handleError(error, _types.CheckoutErrorType.OrderCreationFailed);
+      this.logError('本地订单创建失败:', error);
       this.core.effects.emit(`${this.name}:onOrderCreationFailed`, {
         error: this.store.lastError,
         timestamp: Date.now()
@@ -504,6 +538,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       throw error;
     }
   }
+
   /**
    * 更新本地订单（已同步后端的订单）并设置为当前订单
    *
@@ -511,31 +546,37 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
    * 会覆盖 order_info 与金额等字段，并重新计算待付金额，最后设置为 currentOrder。
    */
   async updateLocalOrderAsync(params) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q;
     this.payment.wallet.clearAllCache();
-    this.logInfo("updateLocalOrderAsync called", {
+    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,
+      orderDataType: params.orderData?.type,
+      bookingsCount: params.orderData?.bookings?.length || 0,
+      cartSummaryCount: params.cartSummary?.length || 0,
       totalInfoKeys: params.totalInfo ? Object.keys(params.totalInfo) : []
     });
-    const validation = (0, import_utils.validateLocalOrderData)(params.orderData);
+
+    // 基础校验
+    const validation = (0, _utils.validateLocalOrderData)(params.orderData);
     if (!validation.valid) {
-      throw (0, import_utils.createCheckoutError)(
-        import_types.CheckoutErrorType.ValidationFailed,
-        `订单数据验证失败: ${validation.errors.join(", ")}`
-      );
+      throw (0, _utils.createCheckoutError)(_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;
+
+    // 计算金额
+    const amountInfo = (0, _utils.extractAmountFromCartSummary)(params.cartSummary);
+
+    // 规范化补充字段
+    params.orderData.created_at = (0, _utils.formatDateTime)(new Date());
+    params.orderData.platform = 'pos';
+    params.orderData.surcharge_fee = params.totalInfo?.total?.otherAmount;
+    params.orderData.surcharges = params.totalInfo?.total?.surcharge;
+    params.orderData.shop_discount = params.totalInfo?.total?.shopDiscount;
+    params.orderData.tax_fee = params.totalInfo?.total?.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
@@ -543,43 +584,49 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
     if (customerInfo.customer_id || customerInfo.customer_name) {
       this.store.currentCustomer = customerInfo;
     } else {
-      this.store.currentCustomer = void 0;
+      this.store.currentCustomer = undefined;
     }
+
+    // 保留原有支付项：通过 orderId 找到现有订单（按 id 或 order_id 匹配）
     const allOrders = await this.payment.getOrderListAsync();
-    const existingOrder = allOrders.find(
-      (o) => String(o.id) === String(params.orderId) || String(o.order_id) === String(params.orderId)
-    );
+    const existingOrder = allOrders.find(o => String(o.id) === String(params.orderId) || String(o.order_id) === String(params.orderId));
     if (existingOrder) {
+      // 🔧 新增: 如果传入了 existPayment，需要更新支付项列表
       if (params.existPayment && params.existPayment.length > 0) {
-        this.logInfo("检测到云端支付项，将替换本地订单的支付项列表", {
+        this.logInfo('检测到云端支付项，将替换本地订单的支付项列表', {
           orderId: params.orderId,
-          existingPaymentCount: ((_m = existingOrder.payment) == null ? void 0 : _m.length) || 0,
+          existingPaymentCount: existingOrder.payment?.length || 0,
           newPaymentCount: params.existPayment.length
         });
+
+        // 标记订单已同步（因为支付项来自云端）
         this.store.isOrderSynced = true;
-        const currentTime = (0, import_utils.formatDateTime)(/* @__PURE__ */ new Date());
-        const formattedExistPayments = params.existPayment.map((payment) => ({
+
+        // 格式化云端支付项（添加时间戳、标记已同步）
+        const currentTime = (0, _utils.formatDateTime)(new Date());
+        const formattedExistPayments = params.existPayment.map(payment => ({
           ...payment,
           isSynced: true,
           // 标记为已同步
-          status: payment.status || "active",
+          status: payment.status || 'active',
           created_at: payment.created_at || currentTime,
           updated_at: payment.updated_at || currentTime
         }));
-        const isNeedDeposit3 = this.checkIsNeedDepositAsync(
-          params.orderData.bookings,
-          params.orderData.relation_products
-        );
+
+        // 计算是否需要支付定金
+        const isNeedDeposit = this.checkIsNeedDepositAsync(params.orderData.bookings, params.orderData.relation_products);
+
+        // 更新订单，替换支付项列表
         await this.payment.updateOrderAsync(existingOrder.uuid, {
           total_amount: amountInfo.totalAmount,
-          is_deposit: isNeedDeposit3.hasDeposit ? 1 : 0,
-          deposit_amount: isNeedDeposit3.total ? isNeedDeposit3.total.toString() : "0.00",
+          is_deposit: isNeedDeposit.hasDeposit ? 1 : 0,
+          deposit_amount: isNeedDeposit.total ? isNeedDeposit.total.toString() : '0.00',
           payment: formattedExistPayments,
           // 🔧 替换支付项列表
           order_info: {
             original_order_data: params.orderData,
             cart_summary: params.cartSummary,
-            created_at: (/* @__PURE__ */ new Date()).toISOString(),
+            created_at: new Date().toISOString(),
             platform: params.orderData.platform,
             type: params.orderData.type,
             schedule_date: params.orderData.schedule_date,
@@ -587,70 +634,68 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
             amount_breakdown: amountInfo
           }
         });
-        const updated2 = await this.payment.getPaymentOrderByUuidAsync(
-          existingOrder.uuid
-        );
-        if (!updated2)
-          throw (0, import_utils.createCheckoutError)(
-            import_types.CheckoutErrorType.UnknownError,
-            "订单更新失败"
-          );
-        this.store.currentOrder = updated2;
+        const updated = await this.payment.getPaymentOrderByUuidAsync(existingOrder.uuid);
+        if (!updated) throw (0, _utils.createCheckoutError)(_types.CheckoutErrorType.UnknownError, '订单更新失败');
+        this.store.currentOrder = updated;
         await this.updateStateAmountToRemaining(false);
-        this.logInfo("本地订单更新成功(已替换云端支付项):", {
+        this.logInfo('本地订单更新成功(已替换云端支付项):', {
           orderId: params.orderId,
-          uuid: updated2.uuid,
-          payments: ((_n = updated2.payment) == null ? void 0 : _n.length) || 0,
-          totalAmount: updated2.total_amount,
-          expectAmount: updated2.expect_amount,
+          uuid: updated.uuid,
+          payments: updated.payment?.length || 0,
+          totalAmount: updated.total_amount,
+          expectAmount: updated.expect_amount,
           isOrderSynced: true
         });
+
+        // 事件通知
         await this.core.effects.emit(`${this.name}:onOrderCreated`, {
-          order: updated2,
+          order: updated,
           timestamp: Date.now()
         });
-        const syncedPayments = updated2.payment.filter((p) => p.isSynced && p.status !== "voided");
-        const syncedAmount2 = syncedPayments.reduce((sum, p) => {
-          let 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();
+
+        // 计算已同步的支付金额
+        const syncedPayments = updated.payment.filter(p => p.isSynced && p.status !== 'voided');
+        const syncedAmount = syncedPayments.reduce((sum, p) => {
+          let amt = new _decimal.default(p.amount || '0');
+          const rounding = new _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 totalAmount2 = new import_decimal.default(amountInfo.totalAmount || "0");
-        const remainingExpectAmount2 = import_decimal.default.max(0, totalAmount2.minus(syncedAmount2)).toFixed(2);
-        let depositDiffAmount2 = new import_decimal.default(0).toFixed(2);
-        if (updated2.is_deposit === 1) {
-          depositDiffAmount2 = new import_decimal.default(updated2.deposit_amount).minus(syncedAmount2).toFixed(2);
+        }, new _decimal.default(0));
+        const totalAmount = new _decimal.default(amountInfo.totalAmount || '0');
+        const remainingExpectAmount = _decimal.default.max(0, totalAmount.minus(syncedAmount)).toFixed(2);
+
+        // 计算定金差值
+        let depositDiffAmount = new _decimal.default(0).toFixed(2);
+        if (updated.is_deposit === 1) {
+          depositDiffAmount = new _decimal.default(updated.deposit_amount).minus(syncedAmount).toFixed(2);
         }
         this.initWalletData({
-          order_wait_pay_amount: Number(depositDiffAmount2) > 0 ? Number(depositDiffAmount2) : Number(remainingExpectAmount2)
+          order_wait_pay_amount: Number(depositDiffAmount) > 0 ? Number(depositDiffAmount) : Number(remainingExpectAmount)
         });
-        return updated2;
+        return updated;
       }
-      const totalAmount = new import_decimal.default(amountInfo.totalAmount || "0");
-      const activePayments = (existingOrder.payment || []).filter(
-        (p) => p.status !== "voided" && (!p.voucher_id || p.voucher_id && p.isSynced)
-      );
+
+      // 原有逻辑：保留现有支付项
+      const totalAmount = new _decimal.default(amountInfo.totalAmount || '0');
+      const activePayments = (existingOrder.payment || []).filter(p => p.status !== 'voided' && (!p.voucher_id || p.voucher_id && p.isSynced));
       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();
+        const amt = new _decimal.default(p.amount || '0');
+        const rounding = new _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
-      );
+      }, new _decimal.default(0));
+      const remaining = _decimal.default.max(0, totalAmount.minus(paidAmount)).toFixed(2);
+      // 计算是否需要支付定金，如果需要默认切换到定金模式，以及记录定金总金额，并把当前默认待付金额调整为定金总金额
+      const isNeedDeposit = this.checkIsNeedDepositAsync(params.orderData.bookings, params.orderData.relation_products);
+
+      // 更新到支付模块（使用 uuid，不修改 payment 列表）
       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",
+        is_deposit: isNeedDeposit.hasDeposit ? 1 : 0,
+        deposit_amount: isNeedDeposit.total ? isNeedDeposit.total.toString() : '0.00',
         expect_amount: remaining,
         order_info: {
           original_order_data: params.orderData,
           cart_summary: params.cartSummary,
-          created_at: (/* @__PURE__ */ new Date()).toISOString(),
+          created_at: new Date().toISOString(),
           platform: params.orderData.platform,
           type: params.orderData.type,
           schedule_date: params.orderData.schedule_date,
@@ -658,59 +703,56 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
           amount_breakdown: amountInfo
         }
       });
-      const updated = await this.payment.getPaymentOrderByUuidAsync(
-        existingOrder.uuid
-      );
-      if (!updated)
-        throw (0, import_utils.createCheckoutError)(
-          import_types.CheckoutErrorType.UnknownError,
-          "订单更新失败"
-        );
+      const updated = await this.payment.getPaymentOrderByUuidAsync(existingOrder.uuid);
+      if (!updated) throw (0, _utils.createCheckoutError)(_types.CheckoutErrorType.UnknownError, '订单更新失败');
       this.store.currentOrder = updated;
       await this.updateStateAmountToRemaining(false);
-      this.logInfo("本地订单更新成功(保留支付项):", {
+      this.logInfo('本地订单更新成功(保留支付项):', {
         orderId: params.orderId,
         uuid: updated.uuid,
-        payments: ((_o = updated.payment) == null ? void 0 : _o.length) || 0,
+        payments: updated.payment?.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();
+        const amt = new _decimal.default(p.amount || '0');
+        const rounding = new _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);
+      }, new _decimal.default(0));
+      const remainingExpectAmount = _decimal.default.max(0, totalAmount.minus(syncedAmount)).toFixed(2);
+      // 要计算一个总价的差值和一个定金的差值，如果定金的差值>0，则需要使用定金的差值，否则使用总价的差值
+      let depositDiffAmount = new _decimal.default(0).toFixed(2);
       if (updated.is_deposit === 1) {
-        depositDiffAmount = new import_decimal.default(updated.deposit_amount).minus(syncedAmount).toFixed(2);
+        depositDiffAmount = new _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 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",
+      deposit_amount: isNeedDeposit.total ? isNeedDeposit.total.toString() : '0.00',
       existPayment: params.existPayment,
       // 🔧 新增: 传递云端支付项
       order_info: {
         original_order_data: params.orderData,
         cart_summary: params.cartSummary,
-        created_at: (/* @__PURE__ */ new Date()).toISOString(),
+        created_at: new Date().toISOString(),
         platform: params.orderData.platform,
         type: params.orderData.type,
         schedule_date: params.orderData.schedule_date,
@@ -719,15 +761,20 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       }
     });
     this.store.currentOrder = created;
-    if (params.existPayment && params.existPayment.length > 0 || ((_p = this.store.currentOrder) == null ? void 0 : _p.order_id) && !(0, import_utils.isVirtualOrderId)((_q = this.store.currentOrder) == null ? void 0 : _q.order_id)) {
+
+    // 🔧 新增: 如果有云端支付项，需要计算正确的待付金额
+    if (params.existPayment && params.existPayment.length > 0 || this.store.currentOrder?.order_id && !(0, _utils.isVirtualOrderId)(this.store.currentOrder?.order_id)) {
+      // 标记订单已同步（因为订单和支付项都来自云端）
       this.store.isOrderSynced = true;
-      const syncedPayments = created.payment.filter((p) => p.isSynced && p.status !== "voided");
+
+      // 计算已同步的支付金额
+      const syncedPayments = created.payment.filter(p => p.isSynced && p.status !== 'voided');
       const syncedAmount = syncedPayments.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();
+        const amt = new _decimal.default(p.amount || '0');
+        const rounding = new _decimal.default(Number(p.rounding_amount) > 0 ? 0 : p.rounding_amount || '0').abs();
         return sum.plus(amt).plus(rounding);
-      }, new import_decimal.default(0));
-      this.logInfo("云端订单初始化钱包数据", {
+      }, new _decimal.default(0));
+      this.logInfo('云端订单初始化钱包数据', {
         orderId: params.orderId,
         totalAmount: created.total_amount,
         expectAmount: created.expect_amount,
@@ -735,57 +782,60 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         syncedPaymentCount: syncedPayments.length,
         isOrderSynced: true
       });
+
+      // 初始化钱包数据，使用系统计算的待付金额
       this.initWalletData({
         order_wait_pay_amount: Number(created.expect_amount)
       });
     } else {
+      // 没有云端支付项，正常初始化
       this.initWalletData();
     }
     return created;
   }
+
   /**
    * 完成结账
    */
   async completeCheckoutAsync() {
     try {
       if (!this.store.currentOrder) {
-        throw (0, import_utils.createCheckoutError)(
-          import_types.CheckoutErrorType.ValidationFailed,
-          "未找到当前订单"
-        );
+        throw (0, _utils.createCheckoutError)(_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,
-          "订单支付未完成，无法完成结账"
-        );
+
+      // 检查支付状态
+      const order = await this.payment.getPaymentOrderByUuidAsync(this.store.currentOrder.uuid);
+      if (!order || order.payment_status !== _types2.PaymentStatus.Finished) {
+        throw (0, _utils.createCheckoutError)(_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);
+      // 🔧 新增：自动重置 store 状态（同步执行）
       this.resetStoreState();
       return {
         success: true,
         orderId: String(order.id)
       };
     } catch (error) {
-      await this.handleError(error, import_types.CheckoutErrorType.UnknownError);
-      return { success: false };
+      await this.handleError(error, _types.CheckoutErrorType.UnknownError);
+      return {
+        success: false
+      };
     }
   }
+
   /**
    * 获取订单原始数据
    */
   getOrderOriginalData() {
-    var _a;
-    return (_a = this.store.currentOrder) == null ? void 0 : _a.order_info;
+    return this.store.currentOrder?.order_info;
   }
+
   /**
    * 获取当前订单基础信息
    *
@@ -793,15 +843,20 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
    */
   getCurrentOrderInfo() {
     try {
-      const { currentOrder, cartItems, localOrderData } = this.store;
+      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 createdAt = orderInfo.created_at || new Date().toISOString();
+      const orderType = localOrderData?.type || orderInfo.type || 'virtual';
+      const platform = localOrderData?.platform || orderInfo.platform || 'pc';
       const result = {
         uuid: currentOrder.uuid,
         orderId: currentOrder.order_id,
@@ -810,18 +865,19 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         paymentStatus: currentOrder.payment_status,
         isDeposit: Boolean(currentOrder.is_deposit),
         depositAmount: currentOrder.deposit_amount,
-        orderType,
-        platform,
+        orderType: orderType,
+        platform: platform,
         createdAt,
         itemCount: cartItems.length,
         hasLocalOrderData: Boolean(localOrderData)
       };
       return result;
     } catch (error) {
-      console.error("[Checkout] 获取当前订单基础信息失败:", error);
+      console.error('[Checkout] 获取当前订单基础信息失败:', error);
       return null;
     }
   }
+
   /**
    * 获取当前订单的支付项
    *
@@ -829,32 +885,36 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
    */
   async getCurrentOrderPaymentItemsAsync() {
     try {
-      const { currentOrder } = this.store;
+      const {
+        currentOrder
+      } = this.store;
       if (!currentOrder) {
-        console.log("[Checkout] 当前没有活跃订单，无法获取支付项");
         return [];
       }
-      const paymentItems = await this.payment.getPaymentItemsAsync(
-        currentOrder.uuid
-      );
+
+      // 调用Payment模块获取支付项
+      const paymentItems = await this.payment.getPaymentItemsAsync(currentOrder.uuid);
       return paymentItems;
     } catch (error) {
-      console.error("[Checkout] 获取当前订单支付项失败:", error);
+      console.error('[Checkout] 获取当前订单支付项失败:', error);
       return [];
     }
   }
+
   /**
    * 获取订单模块
    */
   getOrderModule() {
     return this.order;
   }
+
   /**
    * 获取支付模块
    */
   getPaymentModule() {
     return this.payment;
   }
+
   /**
    * 替换本地订单ID为真实订单ID
    *
@@ -866,43 +926,45 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
   async replaceLocalOrderIdAsync(newOrderId) {
     try {
       if (!this.store.currentOrder) {
-        console.warn("[Checkout] 没有当前订单，无法替换订单ID");
+        console.warn('[Checkout] 没有当前订单，无法替换订单ID');
         return null;
       }
       const previousOrder = this.store.currentOrder;
       const latestPaymentStatus = previousOrder.payment_status;
-      const updatedOrder = await this.payment.replaceOrderIdByUuidAsync(
-        previousOrder.uuid,
-        newOrderId
-      );
+      const updatedOrder = await this.payment.replaceOrderIdByUuidAsync(previousOrder.uuid, newOrderId);
       if (updatedOrder) {
+        // 🔧 重要：Payment.replaceOrderIdByUuidAsync 返回的是 DB 快照（只保证 order_id 变化）
+        // 这里需要合并到内存态，避免覆盖掉刚刚从后端拿到的 payment_status 等字段
         this.store.currentOrder = {
           ...previousOrder,
           ...updatedOrder,
           payment_status: latestPaymentStatus
         };
-        if (latestPaymentStatus)
-          await this.payment.updateOrderAsync(previousOrder.uuid, {
-            payment_status: latestPaymentStatus
-          });
+
+        // 同步更新 Payment 模块 DB，避免后续再次从 DB 读回旧的 payment_status
+        if (latestPaymentStatus) await this.payment.updateOrderAsync(previousOrder.uuid, {
+          payment_status: latestPaymentStatus
+        });
+
+        // 触发订单更新事件
         await this.core.effects.emit(`${this.name}:onOrderCreated`, {
           order: updatedOrder,
           timestamp: Date.now()
         });
-        console.log("[Checkout] 本地订单ID替换成功:", {
-          uuid: updatedOrder.uuid,
-          newOrderId: updatedOrder.id
-        });
+        // 标记订单已同步（替换ID意味着订单已在后端创建）
         this.store.isOrderSynced = true;
+
+        // 订单ID替换后更新 stateAmount
         await this.updateStateAmountToRemaining(false);
       }
       return updatedOrder;
     } catch (error) {
-      console.error("[Checkout] 替换订单ID失败:", error);
-      await this.handleError(error, import_types.CheckoutErrorType.UnknownError);
+      console.error('[Checkout] 替换订单ID失败:', error);
+      await this.handleError(error, _types.CheckoutErrorType.UnknownError);
       return null;
     }
   }
+
   /**
    * 设置自定义支付金额
    *
@@ -912,35 +974,40 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
    */
   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] 设置自定义支付金额:", {
+      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
-      );
+      const errorMessage = error instanceof Error ? error.message : '设置支付金额失败';
+      console.error('[Checkout] 设置自定义支付金额失败:', errorMessage);
+      await this.handleError(new Error(errorMessage), _types.CheckoutErrorType.ValidationFailed);
       throw error;
     }
   }
+
   /**
    * 获取当前自定义支付金额
    *
@@ -949,6 +1016,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
   getStateAmount() {
     return this.store.stateAmount;
   }
+
   /**
    * 获取系统计算的待付金额（只读）
    *
@@ -959,6 +1027,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
   getBalanceDueAmount() {
     return this.store.balanceDueAmount;
   }
+
   /**
    * 获取购物车小计数据
    *
@@ -968,19 +1037,20 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
    */
   getCartSummary() {
     if (!this.store.cartSummary || this.store.cartSummary.length === 0) {
-      console.warn("[Checkout] 没有可用的购物车小计数据");
+      console.warn('[Checkout] 没有可用的购物车小计数据');
       return null;
     }
-    this.logInfo("获取购物车小计数据:", {
+    this.logInfo('获取购物车小计数据:', {
       itemCount: this.store.cartSummary.length,
-      items: this.store.cartSummary.map((item) => ({
+      items: this.store.cartSummary.map(item => ({
         key: item.key,
         value: item.value,
         label: item.label
       }))
     });
-    return [...this.store.cartSummary];
+    return [...this.store.cartSummary]; // 返回副本，避免外部修改
   }
+
   /**
    * 获取支付方式列表
    *
@@ -990,25 +1060,26 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
    * @returns 支付方式列表
    */
   async getPaymentMethodsAsync() {
+    // 优先使用 store 中的缓存数据
     if (this.store.paymentMethods && this.store.paymentMethods.length > 0) {
-      this.logInfo(
-        `使用缓存的支付方式数据，共 ${this.store.paymentMethods.length} 种`
-      );
+      this.logInfo(`使用缓存的支付方式数据，共 ${this.store.paymentMethods.length} 种`);
       return this.store.paymentMethods;
     }
-    this.logInfo("store 中无缓存，从 Payment 模块获取支付方式...");
+
+    // 如果缓存为空，调用 Payment 模块获取
+    this.logInfo('store 中无缓存，从 Payment 模块获取支付方式...');
     try {
       const methods = await this.payment.getPayMethodListAsync();
+      // 更新缓存
       this.store.paymentMethods = methods;
-      this.logInfo(
-        `从 Payment 模块获取到 ${methods.length} 种支付方式，已更新缓存`
-      );
+      this.logInfo(`从 Payment 模块获取到 ${methods.length} 种支付方式，已更新缓存`);
       return methods;
     } catch (error) {
-      this.logError("获取支付方式失败:", error);
+      this.logError('获取支付方式失败:', error);
       return [];
     }
   }
+
   /**
    * 为当前订单添加支付项
    *
@@ -1018,14 +1089,16 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
    * @throws 当前没有活跃订单时抛出错误
    */
   async addPaymentItemAsync(paymentItem, orderUuid) {
-    var _a, _b, _c, _d, _e;
-    this.logInfo("addPaymentItemAsync called", { paymentItem, orderUuid });
-    const isEftposPayment = ((_a = paymentItem.type) == null ? void 0 : _a.toLowerCase()) === "eftpos" || ((_b = paymentItem.code) == null ? void 0 : _b.toUpperCase().includes("EFTPOS"));
+    this.logInfo('addPaymentItemAsync called', {
+      paymentItem,
+      orderUuid
+    });
+    const isEftposPayment = paymentItem.type?.toLowerCase() === 'eftpos' || paymentItem.code?.toUpperCase().includes('EFTPOS');
     const shouldRepairFromIndexDb = !!orderUuid && isEftposPayment && (!this.store.currentOrder || this.store.currentOrder.uuid !== orderUuid);
     if (shouldRepairFromIndexDb) {
-      this.logError("EFTPOS push payment repair triggered", {
+      this.logError('EFTPOS push payment repair triggered', {
         orderUuid,
-        currentOrderUuid: (_c = this.store.currentOrder) == null ? void 0 : _c.uuid,
+        currentOrderUuid: this.store.currentOrder?.uuid,
         paymentCode: paymentItem.code,
         paymentType: paymentItem.type
       });
@@ -1035,7 +1108,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
           paymentItem
         });
       } catch (error) {
-        this.logError("EFTPOS push payment repair failed", {
+        this.logError('EFTPOS push payment repair failed', {
           orderUuid,
           error: error instanceof Error ? error.message : String(error)
         });
@@ -1043,63 +1116,73 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       return;
     }
     try {
+      // 检查是否有当前订单
       if (!this.store.currentOrder) {
-        throw (0, import_utils.createCheckoutError)(
-          import_types.CheckoutErrorType.ValidationFailed,
-          "未找到当前订单，无法添加支付项"
-        );
+        throw (0, _utils.createCheckoutError)(_types.CheckoutErrorType.ValidationFailed, '未找到当前订单，无法添加支付项');
       }
-      const orderPaymentType = this.store.currentOrder.is_deposit === 1 ? "deposit" : "normal";
+
+      // 根据当前订单的定金状态设置订单支付类型
+      const orderPaymentType = this.store.currentOrder.is_deposit === 1 ? 'deposit' : 'normal';
+
+      // 处理现金支付的找零逻辑
       const processedPaymentItem = await this.processCashPaymentItem(paymentItem);
+
+      // 从 otherParams 获取 metadata 字段
       const metadata = {
         ...processedPaymentItem.metadata,
         rounding_rule: this.otherParams.order_rounding_setting,
         shop_wallet_pass_id: this.otherParams.shop_wallet_pass_id
       };
+
+      // 设置支付项的订单支付类型和 metadata
       const paymentItemWithType = {
         ...processedPaymentItem,
         order_payment_type: orderPaymentType,
         metadata
       };
-      await this.payment.addPaymentItemAsync(
-        this.store.currentOrder.uuid,
-        paymentItemWithType
-      );
-      this.logInfo("支付项添加成功");
+
+      // 添加支付项到订单
+      await this.payment.addPaymentItemAsync(this.store.currentOrder.uuid, paymentItemWithType);
+      this.logInfo('支付项添加成功');
+
+      // 🚀 清除计算缓存，确保获取最新数据
       this.clearCalculationCache();
+
+      // 支付项添加后，更新 stateAmount 为剩余未支付金额
       await this.updateStateAmountToRemaining();
+
+      // 检查订单金额是否还有待付的，如果有才同步 EFTPOS 支付
       const remainingAmount = await this.calculateRemainingAmountAsync();
       if (Number(remainingAmount) > 0) {
-        this.logInfo("订单金额还有待付的，同步 EFTPOS 支付");
-        const isEftposPayment2 = ((_d = paymentItem.type) == null ? void 0 : _d.toLowerCase()) === "eftpos" || ((_e = paymentItem.code) == null ? void 0 : _e.toUpperCase().includes("EFTPOS"));
-        const isCash = (0, import_utils.isCashPayment)(paymentItem);
-        const isCustomePayment = paymentItem.type === "custom";
-        this.logInfo("EFTPOS 支付检查:", {
+        this.logInfo('订单金额还有待付的，同步 EFTPOS 支付');
+        // 检查是否是 EFTPOS 支付，如果是则立即同步订单
+        const isEftposPayment = paymentItem.type?.toLowerCase() === 'eftpos' || paymentItem.code?.toUpperCase().includes('EFTPOS');
+        const isCash = (0, _utils.isCashPayment)(paymentItem);
+        const isCustomePayment = paymentItem.type === 'custom';
+        this.logInfo('EFTPOS 支付检查:', {
           paymentCode: paymentItem.code,
           paymentType: paymentItem.type,
-          isEftposPayment: isEftposPayment2,
+          isEftposPayment,
           currentOrderSynced: this.store.isOrderSynced
         });
-        if (isEftposPayment2 || isCash || isCustomePayment) {
-          this.logInfo("检测到 EFTPOS 支付，立即同步订单到后端...");
+        if (isEftposPayment || isCash || isCustomePayment) {
+          this.logInfo('检测到 EFTPOS 支付，立即同步订单到后端...');
           try {
+            // EFTPOS 支付后的同步标记为手动同步，确保 OnOrderSynced 事件中 isManual = true
             const syncResult = await this.syncOrderToBackendWithReturn(true);
-            this.logInfo("EFTPOS 支付后订单同步完成 (已标记为手动同步):", {
+            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.logError('EFTPOS 支付后订单同步失败:', error);
+            // 不抛出错误，避免影响支付流程，但记录错误
+            await this.handleError(new Error(`EFTPOS 支付后订单同步失败: ${error instanceof Error ? error.message : String(error)}`), _types.CheckoutErrorType.OrderCreationFailed);
           }
         }
       }
+      // 触发支付项添加事件（可以复用支付开始事件）
       this.core.effects.emit(`${this.name}:onPaymentItemAdded`, {
         orderUuid: this.store.currentOrder.uuid,
         paymentMethodCode: paymentItem.code,
@@ -1108,11 +1191,12 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         timestamp: Date.now()
       });
     } catch (error) {
-      this.logError("添加支付项失败:", error);
-      await this.handleError(error, import_types.CheckoutErrorType.PaymentFailed);
+      this.logError('添加支付项失败:', error);
+      await this.handleError(error, _types.CheckoutErrorType.PaymentFailed);
       throw error;
     }
   }
+
   /**
    * 删除当前订单的支付项
    *
@@ -1124,59 +1208,56 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
    */
   async deletePaymentItemAsync(paymentUuid) {
     try {
+      // 检查是否有当前订单
       if (!this.store.currentOrder) {
-        throw (0, import_utils.createCheckoutError)(
-          import_types.CheckoutErrorType.ValidationFailed,
-          "当前没有活跃订单，无法删除支付项"
-        );
+        throw (0, _utils.createCheckoutError)(_types.CheckoutErrorType.ValidationFailed, '当前没有活跃订单，无法删除支付项');
       }
-      this.logWarning("开始删除支付项:", {
+      this.logWarning('开始删除支付项:', {
         orderUuid: this.store.currentOrder.uuid,
-        paymentUuid
+        paymentUuid: paymentUuid
       });
-      const currentPayments = await this.payment.getPaymentItemsAsync(
-        this.store.currentOrder.uuid,
-        true
-        // 包括已撤销的支付项，因为我们需要验证是否存在
+
+      // 从 Payment 模块验证支付项是否存在
+      const currentPayments = await this.payment.getPaymentItemsAsync(this.store.currentOrder.uuid, true // 包括已撤销的支付项，因为我们需要验证是否存在
       );
-      const paymentItem = currentPayments.find((p) => p.uuid === paymentUuid);
+      const paymentItem = currentPayments.find(p => p.uuid === paymentUuid);
       if (!paymentItem) {
-        throw (0, import_utils.createCheckoutError)(
-          import_types.CheckoutErrorType.ValidationFailed,
-          `支付项不存在: ${paymentUuid}`
-        );
+        throw (0, _utils.createCheckoutError)(_types.CheckoutErrorType.ValidationFailed, `支付项不存在: ${paymentUuid}`);
       }
-      this.logInfo("找到要删除的支付项:", {
+      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);
+
+      // 调用 Payment 模块删除支付项
+      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
-      );
+
+      // 重新从Payment模块获取最新的订单数据，确保支付项同步
+      const currentOrderId = this.store.currentOrder.order_id; // 保存当前的订单ID
+      const isCurrentOrderReal = currentOrderId && !(0, _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;
+        // 如果当前订单ID是真实ID，但获取到的订单ID是虚拟ID，需要保护真实ID
+        if (isCurrentOrderReal && (0, _utils.isVirtualOrderId)(updatedOrder.order_id)) {
+          this.logWarning('[Checkout] deletePaymentItemAsync: 检测到订单ID回退，保护真实订单ID:', {
+            currentRealId: currentOrderId,
+            retrievedVirtualId: updatedOrder.order_id
+          });
+          updatedOrder.order_id = currentOrderId; // 恢复真实的订单ID
         }
         this.store.currentOrder = updatedOrder;
       }
+
+      // 更新 stateAmount 为剩余未支付金额
       await this.updateStateAmountToRemaining(false);
+
+      // 触发支付项删除事件
       await this.core.effects.emit(`${this.name}:onPaymentStarted`, {
         orderUuid: this.store.currentOrder.uuid,
         paymentMethodCode: paymentItem.code,
@@ -1185,11 +1266,12 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         timestamp: Date.now()
       });
     } catch (error) {
-      this.logError("删除支付项失败:", error);
-      await this.handleError(error, import_types.CheckoutErrorType.PaymentFailed);
+      this.logError('删除支付项失败:', error);
+      await this.handleError(error, _types.CheckoutErrorType.PaymentFailed);
       throw error;
     }
   }
+
   /**
    * 批量更新当前订单的代金券支付项（覆盖更新）
    *
@@ -1202,55 +1284,56 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
    */
   async updateVoucherPaymentItemsAsync(voucherPaymentItems) {
     try {
-      this.logInfo("updateVoucherPaymentItemsAsync called:", {
+      this.logInfo('updateVoucherPaymentItemsAsync called:', {
         voucherPaymentItems
       });
+      // 检查是否有当前订单
       if (!this.store.currentOrder) {
-        throw (0, import_utils.createCheckoutError)(
-          import_types.CheckoutErrorType.ValidationFailed,
-          "当前没有活跃订单，无法更新代金券支付项"
-        );
+        throw (0, _utils.createCheckoutError)(_types.CheckoutErrorType.ValidationFailed, '当前没有活跃订单，无法更新代金券支付项');
       }
-      const paymentItems = await this.payment.getPaymentItemsAsync(
-        this.store.currentOrder.uuid
-      );
-      if (!voucherPaymentItems || (voucherPaymentItems == null ? void 0 : voucherPaymentItems.length) === 0) {
-        const savedVoucherPaymentItems = (paymentItems == null ? void 0 : paymentItems.filter((item) => item.voucher_id && !item.isSynced)) || [];
-        this.logInfo("未传入 voucher 且本地订单无 voucher 记录，阻断updateVoucherPaymentItemsAsync", {
+
+      // 🔒 防重复操作检查：只有订单已同步且支付完成且所有支付项都已经同步
+      const paymentItems = await this.payment.getPaymentItemsAsync(this.store.currentOrder.uuid);
+      if (!voucherPaymentItems || voucherPaymentItems?.length === 0) {
+        const savedVoucherPaymentItems = paymentItems?.filter(item => item.voucher_id && !item.isSynced) || [];
+        this.logInfo('未传入 voucher 且本地订单无 voucher 记录，阻断updateVoucherPaymentItemsAsync', {
           voucherPaymentItems,
           savedVoucherPaymentItems
         });
-        if ((savedVoucherPaymentItems == null ? void 0 : savedVoucherPaymentItems.length) === 0) {
+        if (savedVoucherPaymentItems?.length === 0) {
           this.updateStateAmountToRemaining(false);
           return;
         }
       }
-      const allPaymentItemsSynced = paymentItems.every((item) => item.isSynced);
+      const allPaymentItemsSynced = paymentItems.every(item => item.isSynced);
       const remainingAmount = await this.calculateRemainingAmountAsync();
-      const remainingValue = new import_decimal.default(remainingAmount);
+      const remainingValue = new _decimal.default(remainingAmount);
       const isOrderSynced = this.store.isOrderSynced;
       if (remainingValue.lte(0) && isOrderSynced && voucherPaymentItems.length === 0 && allPaymentItemsSynced) {
-        this.logInfo("订单已同步且支付完成，跳过清空代金券操作避免重复同步:", {
+        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"
+          reason: 'Order synced and payment completed, skip clear vouchers to avoid duplicate sync'
         });
-        return;
+        return; // 直接返回，不执行任何操作
       }
-      this.logInfo("开始批量更新代金券支付项:", {
+      this.logInfo('开始批量更新代金券支付项:', {
         voucherPaymentItems
       });
-      const orderPaymentType = this.store.currentOrder.is_deposit === 1 ? "deposit" : "normal";
-      const voucherPaymentItemsWithType = voucherPaymentItems.map((item) => {
+
+      // 根据当前订单的定金状态设置订单支付类型
+      const orderPaymentType = this.store.currentOrder.is_deposit === 1 ? 'deposit' : 'normal';
+
+      // 验证所有支付项都包含 voucher_id，并设置 order_payment_type 和 metadata
+      const voucherPaymentItemsWithType = voucherPaymentItems.map(item => {
         if (!item.voucher_id) {
-          throw (0, import_utils.createCheckoutError)(
-            import_types.CheckoutErrorType.ValidationFailed,
-            `代金券支付项缺少 voucher_id: ${JSON.stringify(item)}`
-          );
+          throw (0, _utils.createCheckoutError)(_types.CheckoutErrorType.ValidationFailed, `代金券支付项缺少 voucher_id: ${JSON.stringify(item)}`);
         }
+
+        // 从 otherParams 获取 metadata 字段
         const metadata = {
           ...item.metadata,
           rounding_rule: this.otherParams.order_rounding_setting,
@@ -1262,43 +1345,49 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
           metadata
         };
       });
-      await this.payment.updateVoucherPaymentItemsAsync(
-        this.store.currentOrder.uuid,
-        voucherPaymentItemsWithType
-      );
+
+      // 调用 Payment 模块的批量更新方法
+      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
-      );
+
+      // 重新从Payment模块获取最新的订单数据，确保支付项同步
+      const currentOrderId = this.store.currentOrder.order_id; // 保存当前的订单ID
+      const isCurrentOrderReal = currentOrderId && !(0, _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;
+        // 如果当前订单ID是真实ID，但获取到的订单ID是虚拟ID，需要保护真实ID
+        if (isCurrentOrderReal && (0, _utils.isVirtualOrderId)(updatedOrder.order_id)) {
+          this.logWarning('updateVoucherPaymentItemsAsync: 检测到订单ID回退，保护真实订单ID:', {
+            currentRealId: currentOrderId,
+            retrievedVirtualId: updatedOrder.order_id
+          });
+          updatedOrder.order_id = currentOrderId; // 恢复真实的订单ID
         }
         this.store.currentOrder = updatedOrder;
       }
+
+      // 更新 stateAmount 为剩余未支付金额
       await this.updateStateAmountToRemaining(false);
+
+      // 触发支付项更新事件
       await this.core.effects.emit(`${this.name}:onPaymentStarted`, {
         orderUuid: this.store.currentOrder.uuid,
-        paymentMethodCode: "VOUCHER_BATCH",
+        paymentMethodCode: 'VOUCHER_BATCH',
         amount: voucherPaymentItems.reduce((sum, item) => sum + parseFloat(String(item.amount)), 0).toFixed(2),
         timestamp: Date.now()
       });
-      this.logInfo("代金券支付项批量更新成功");
+      this.logInfo('代金券支付项批量更新成功');
     } catch (error) {
-      this.logInfo("[Checkout] 批量更新代金券支付项失败:", { error });
-      await this.handleError(error, import_types.CheckoutErrorType.PaymentFailed);
+      this.logInfo('[Checkout] 批量更新代金券支付项失败:', {
+        error
+      });
+      await this.handleError(error, _types.CheckoutErrorType.PaymentFailed);
       throw error;
     }
   }
+
   /**
    * 修改当前订单的定金状态
    *
@@ -1309,62 +1398,77 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
    */
   async updateOrderDepositStatusAsync(isDeposit) {
     try {
+      // 验证参数
       if (isDeposit !== 0 && isDeposit !== 1) {
-        throw (0, import_utils.createCheckoutError)(
-          import_types.CheckoutErrorType.ValidationFailed,
-          "isDeposit 参数只能是 0（全款订单）或 1（定金订单）"
-        );
+        throw (0, _utils.createCheckoutError)(_types.CheckoutErrorType.ValidationFailed, 'isDeposit 参数只能是 0（全款订单）或 1（定金订单）');
       }
+
+      // 检查是否有当前订单
       if (!this.store.currentOrder) {
-        throw (0, import_utils.createCheckoutError)(
-          import_types.CheckoutErrorType.ValidationFailed,
-          "未找到当前订单，无法修改定金状态"
-        );
+        throw (0, _utils.createCheckoutError)(_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";
+      let deposit_amount = this.store.currentOrder.deposit_amount || '0.00';
+      // 如果原来没有 deposit_amount，则默认把待付金额置为 deposit_amount
       if (!deposit_amount || Number(deposit_amount) === 0) {
         deposit_amount = this.store.currentOrder.expect_amount;
       }
+
+      // 准备更新参数
       const updateParams = {
         is_deposit: newDepositValue,
-        deposit_amount
+        deposit_amount: deposit_amount
       };
-      await this.payment.updateOrderAsync(
-        this.store.currentOrder.uuid,
-        updateParams
-      );
+
+      // 如果从定金改为全款，可以清空定金金额
+      // if (
+      //   isDeposit === 0 &&
+      //   this.store.currentOrder.deposit_amount !== '0.00'
+      // ) {
+      //   updateParams.deposit_amount = '0.00';
+      //   this.logInfo('订单从定金改为全款，清空定金金额');
+      // }
+
+      // 调用 Payment 模块更新订单
+      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("订单定金状态更新成功:", {
+      this.logInfo('订单定金状态更新成功:', {
         isDeposit: newDepositValue,
         depositAmount: this.store.currentOrder.deposit_amount
       });
     } catch (error) {
-      this.logError("更新订单定金状态失败:", error);
-      await this.handleError(
-        error,
-        import_types.CheckoutErrorType.ValidationFailed
-      );
+      this.logError('更新订单定金状态失败:', error);
+      await this.handleError(error, _types.CheckoutErrorType.ValidationFailed);
       throw error;
     }
   }
+
   /**
    * 手动设置当前订单的定金金额
    *
@@ -1375,76 +1479,89 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
    * @throws 定金金额格式无效或超过订单总额时抛出错误
    */
   async setDepositAmountAsync(depositAmount) {
-    var _a, _b;
-    this.logInfo("setDepositAmountAsync called", {
+    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
+      currentOrderId: this.store.currentOrder?.order_id,
+      currentTotalAmount: this.store.currentOrder?.total_amount
     });
     try {
-      const depositValue = new import_decimal.default(depositAmount);
+      // 验证定金金额格式
+      const depositValue = new _decimal.default(depositAmount);
       if (depositValue.isNaN() || depositValue.lt(0)) {
-        throw (0, import_utils.createCheckoutError)(
-          import_types.CheckoutErrorType.ValidationFailed,
-          `无效的定金金额格式: ${depositAmount}`
-        );
+        throw (0, _utils.createCheckoutError)(_types.CheckoutErrorType.ValidationFailed, `无效的定金金额格式: ${depositAmount}`);
       }
+
+      // 检查是否有当前订单
       if (!this.store.currentOrder) {
-        throw (0, import_utils.createCheckoutError)(
-          import_types.CheckoutErrorType.ValidationFailed,
-          "未找到当前订单，无法设置定金金额"
-        );
+        throw (0, _utils.createCheckoutError)(_types.CheckoutErrorType.ValidationFailed, '未找到当前订单，无法设置定金金额');
       }
       const formattedDepositAmount = depositValue.toFixed(2);
-      const oldDepositAmount = this.store.currentOrder.deposit_amount || "0.00";
+      const oldDepositAmount = this.store.currentOrder.deposit_amount || '0.00';
+
+      // 如果定金金额没有变化，直接返回
       if (formattedDepositAmount === oldDepositAmount) {
-        this.logInfo("定金金额无变化，跳过更新:", {
+        this.logInfo('定金金额无变化，跳过更新:', {
           currentAmount: oldDepositAmount,
           newAmount: formattedDepositAmount
         });
         return;
       }
-      this.logInfo("开始设置订单定金金额:", {
+      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
       };
+
+      // 如果设置的定金金额大于0，自动将订单标记为定金订单
       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) {
+        this.logInfo('定金金额大于0，自动设置为定金订单');
+      }
+      // 如果设置的定金金额为0，可以考虑将订单标记为全款订单
+      else if (depositValue.eq(0) && this.store.currentOrder.is_deposit === 1) {
         updateParams.is_deposit = 0;
-        this.logInfo("定金金额为0，自动设置为全款订单");
+        this.logInfo('定金金额为0，自动设置为全款订单');
       }
-      await this.payment.updateOrderAsync(
-        this.store.currentOrder.uuid,
-        updateParams
-      );
+
+      // 调用 Payment 模块更新订单
+      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) {
+        // 注意：本地订单数据中没有deposit_amount字段，但如果需要可以在这里添加
+        if ('deposit_amount' in this.store.localOrderData) {
           this.store.localOrderData.deposit_amount = formattedDepositAmount;
         }
-        if (updateParams.is_deposit !== void 0) {
+        // 同步更新 is_deposit 状态（如果有变化）
+        if (updateParams.is_deposit !== undefined) {
           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("订单定金金额设置成功:", {
+      this.logInfo('订单定金金额设置成功:', {
         orderUuid: this.store.currentOrder.uuid,
         orderId: this.store.currentOrder.order_id,
         oldDepositAmount,
@@ -1453,84 +1570,83 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         totalAmount: this.store.currentOrder.total_amount
       });
     } catch (error) {
-      this.logError("设置订单定金金额失败:", error);
-      await this.handleError(
-        error,
-        import_types.CheckoutErrorType.ValidationFailed
-      );
+      this.logError('设置订单定金金额失败:', error);
+      await this.handleError(error, _types.CheckoutErrorType.ValidationFailed);
       throw error;
     }
   }
+
   /**
    * 手动同步订单到后端
    *
    * 用于强制同步订单到后端，特别适用于纯代金券支付完成的订单
    */
   async manualSyncOrderAsync() {
-    var _a, _b, _c, _d, _e;
-    console.log("manualSyncOrderAsync called");
-    this.logInfo("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,
+      currentOrderId: this.store.currentOrder?.order_id,
+      orderUuid: this.store.currentOrder?.uuid,
+      totalAmount: this.store.currentOrder?.total_amount,
       isOrderSynced: this.store.isOrderSynced,
-      isVirtualOrderId: this.store.currentOrder ? (0, import_utils.isVirtualOrderId)(this.store.currentOrder.order_id) : false
+      isVirtualOrderId: this.store.currentOrder ? (0, _utils.isVirtualOrderId)(this.store.currentOrder.order_id) : false
     });
     try {
+      // 检查是否有当前订单
       if (!this.store.currentOrder) {
         return {
           success: false,
-          message: "当前没有活跃订单，无法同步"
+          message: '当前没有活跃订单，无法同步'
         };
       }
       const orderUuid = this.store.currentOrder.uuid;
       const oldOrderId = this.store.currentOrder.order_id;
+
+      // 检查订单是否已经同步
       if (this.store.isOrderSynced) {
-        this.logInfo("订单已同步过，将执行更新操作");
+        this.logInfo('订单已同步过，将执行更新操作');
       }
-      this.logInfo("开始手动同步订单到后端:", {
-        orderUuid,
+      this.logInfo('开始手动同步订单到后端:', {
+        orderUuid: 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,
+      this.logInfo('手动同步订单完成:', {
+        orderUuid: orderUuid,
+        syncResult: syncResult,
+        oldOrderId: oldOrderId,
         realOrderId: syncResult.orderId,
         isOrderSynced: this.store.isOrderSynced
       });
+
+      // 🔍 关键验证：检查最终状态是否正确
       const finalOrderId = this.store.currentOrder.order_id;
-      const finalIsVirtual = (0, import_utils.isVirtualOrderId)(finalOrderId);
+      const finalIsVirtual = (0, _utils.isVirtualOrderId)(finalOrderId);
       if (finalIsVirtual) {
-        this.logError("严重警告：手动同步完成后订单ID仍为虚拟ID！");
+        this.logError('严重警告：手动同步完成后订单ID仍为虚拟ID！');
       }
       if (syncResult.orderId !== finalOrderId) {
-        this.logError(
-          "[Checkout] 严重警告：返回的订单ID与存储的订单ID不一致！"
-        );
+        this.logError('[Checkout] 严重警告：返回的订单ID与存储的订单ID不一致！');
       }
       let newRes = {
         ...syncResult,
-        is_deposit: ((_d = this.store.currentOrder) == null ? void 0 : _d.is_deposit) || 0
+        is_deposit: this.store.currentOrder?.is_deposit || 0
       };
       await this.updateStateAmountToRemaining(false);
       return newRes;
     } catch (error) {
-      this.logError("手动同步订单失败:", error);
-      const errorMessage = error instanceof Error ? error.message : "同步失败";
+      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
+        orderUuid: this.store.currentOrder?.uuid
       };
     }
   }
+
   /**
    * 获取当前订单备注
    *
@@ -1538,11 +1654,11 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
    */
   getOrderNote() {
     if (!this.store.localOrderData) {
-      console.log("[Checkout] 没有本地订单数据，无法获取备注");
-      return "";
+      return '';
     }
-    return this.store.localOrderData.shop_note || "";
+    return this.store.localOrderData.shop_note || '';
   }
+
   /**
    * 获取当前订单ID
    *
@@ -1554,24 +1670,21 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
     }
     return this.store.currentOrder.order_id;
   }
+
   /**
    * 获取当前订单是否已同步到后端
    *
    * @returns 当前订单是否已同步状态，如果没有订单则返回false
    */
   isCurrentOrderSynced() {
+    // 如果没有当前订单，返回false
     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;
   }
+
   /**
    * 取消当前本地订单
    *
@@ -1581,81 +1694,92 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
    * @returns 取消结果
    */
   async cancelCurrentOrderAsync(cancelReason) {
-    var _a, _b;
     try {
-      this.logInfo("开始取消当前本地订单:", {
+      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,
+        orderUuid: this.store.currentOrder?.uuid,
+        orderId: this.store.currentOrder?.order_id,
         isOrderSynced: this.store.isOrderSynced,
-        cancelReason
+        cancelReason: cancelReason
       });
+
+      // 检查是否有当前订单
       if (!this.store.currentOrder) {
-        this.logInfo("没有当前订单，无需取消");
+        this.logInfo('没有当前订单，无需取消');
         return {
           success: false,
-          message: "没有当前订单可取消"
+          message: '没有当前订单可取消'
         };
       }
       const currentOrderUuid = this.store.currentOrder.uuid;
       const currentOrderId = this.store.currentOrder.order_id;
       const isOrderSynced = this.store.isOrderSynced;
+
+      // 检查订单是否已同步，已同步的订单不能取消
       if (isOrderSynced) {
-        this.logInfo("订单已同步到后端，不能取消:", {
+        this.logInfo('订单已同步到后端，不能取消:', {
           orderId: currentOrderId,
           orderUuid: currentOrderUuid
         });
         return {
           success: false,
-          message: "订单已同步到后端，无法取消",
+          message: '订单已同步到后端，无法取消',
           orderId: currentOrderId
         };
       }
+      // 标记本地订单为已删除（不从 IndexDB 物理删除）
       try {
-        this.logInfo("标记本地订单为已删除");
+        this.logInfo('标记本地订单为已删除');
         await this.payment.updateOrderAsync(currentOrderUuid, {
-          payment_status: import_types2.PaymentStatus.Voided
+          payment_status: _types2.PaymentStatus.Voided
         });
-        this.logInfo("本地订单删除标记成功");
+        this.logInfo('本地订单删除标记成功');
       } catch (error) {
-        this.logWarning("标记本地订单删除失败，但继续执行:", 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";
+
+      // 清理订单相关状态，确保正确释放 currentOrder
+      this.logInfo('清理订单相关状态');
+      this.store.currentOrder = undefined; // 释放 currentOrder
+      this.store.localOrderData = undefined;
+      this.store.stateAmount = '0.00';
+      this.store.balanceDueAmount = '0.00';
       this.store.isOrderSynced = false;
-      this.store.currentCustomer = void 0;
+      this.store.currentCustomer = undefined;
+
+      // 清理钱包缓存
       this.payment.wallet.clearAllCache();
-      this.logInfo("订单状态清理完成，currentOrder已释放");
+      this.logInfo('订单状态清理完成，currentOrder已释放');
+
+      // 触发订单取消事件
       await this.core.effects.emit(`${this.name}:onOrderCancelled`, {
         orderUuid: currentOrderUuid,
         orderId: currentOrderId,
-        cancelReason,
+        cancelReason: cancelReason,
         wasSynced: false,
         // 只有未同步订单可以被取消
         timestamp: Date.now()
       });
-      this.logInfo("本地订单取消完成:", {
+      this.logInfo('本地订单取消完成:', {
         orderUuid: currentOrderUuid,
         orderId: currentOrderId,
-        cancelReason
+        cancelReason: cancelReason
       });
       return {
         success: true,
-        message: "本地订单已成功取消",
+        message: '本地订单已成功取消',
         orderId: currentOrderId
       };
     } catch (error) {
-      this.logError("取消本地订单失败:", error);
-      const errorMessage = error instanceof Error ? error.message : "未知错误";
+      this.logError('取消本地订单失败:', error);
+      const errorMessage = error instanceof Error ? error.message : '未知错误';
       return {
         success: false,
         message: `取消订单失败: ${errorMessage}`
       };
     }
   }
+
   /**
    * 保存订单并稍后支付
    *
@@ -1663,163 +1787,149 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
    * 适用于用户想要保存订单但稍后完成支付的场景
    */
   async saveForLaterPaymentAsync() {
-    var _a;
     try {
+      // 检查是否有当前订单
       if (!this.store.currentOrder) {
         return {
           success: false,
-          message: "当前没有活跃订单，无法保存"
+          message: '当前没有活跃订单，无法保存'
         };
       }
       const orderUuid = this.store.currentOrder.uuid;
       const currentOrderId = this.store.currentOrder.order_id;
-      this.logInfo("开始保存订单并稍后支付:", {
-        orderUuid,
+      this.logInfo('开始保存订单并稍后支付:', {
+        orderUuid: orderUuid,
         orderId: currentOrderId,
         totalAmount: this.store.currentOrder.total_amount
       });
-      const allPaymentItems = await this.payment.getPaymentItemsAsync(
-        this.store.currentOrder.uuid
-      );
-      const orderPaymentStatus = allPaymentItems.filter((item) => item.status !== "voided").length > 0 ? "partially_paid" : "payment_processing";
-      const syncResult = await this.syncOrderToBackendWithReturn(
-        true,
-        allPaymentItems,
-        orderPaymentStatus
-      );
-      this.logInfo("保存订单完成:", {
-        orderUuid,
+
+      // 获取当前订单的所有支付项
+      const allPaymentItems = await this.payment.getPaymentItemsAsync(this.store.currentOrder.uuid);
+
+      // 保存并稍后支付的订单状态需要特殊处理
+      // 如果当前订单已经有支付项了，则标记为partially_paid 否则标记为 payment_processing
+      const orderPaymentStatus = allPaymentItems.filter(item => item.status !== 'voided').length > 0 ? 'partially_paid' : 'payment_processing';
+
+      // 调用同步方法，传入过滤后的支付项
+      const syncResult = await this.syncOrderToBackendWithReturn(true, allPaymentItems, orderPaymentStatus);
+      this.logInfo('保存订单完成:', {
+        orderUuid: orderUuid,
         oldOrderId: currentOrderId,
-        syncResult,
+        syncResult: syncResult,
         realOrderId: syncResult.orderId,
         isOrderSynced: this.store.isOrderSynced,
         filteredPaymentsCount: allPaymentItems.length
       });
       return {
         success: true,
-        message: "订单保存成功，可稍后继续支付",
+        message: '订单保存成功，可稍后继续支付',
         orderId: syncResult.orderId,
-        orderUuid,
+        orderUuid: orderUuid,
         response: syncResult.response
       };
     } catch (error) {
-      this.logError("保存订单失败:", error);
-      const errorMessage = error instanceof Error ? error.message : "保存失败";
+      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
+        orderUuid: this.store.currentOrder?.uuid
       };
     }
   }
+
   /**
    * 更新订单备注
    *
    * @param note 订单备注内容
    */
   async updateOrderNoteAsync(note) {
-    var _a, _b;
     try {
+      // 检查是否有本地订单数据
       if (!this.store.localOrderData) {
-        throw (0, import_utils.createCheckoutError)(
-          import_types.CheckoutErrorType.ValidationFailed,
-          "没有本地订单数据，无法更新备注"
-        );
+        throw (0, _utils.createCheckoutError)(_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;
+
+      // 如果有当前订单，也同步到Payment模块中的订单数据
       if (this.store.currentOrder) {
+        // 更新Payment模块中的订单数据（如果订单对象中有note字段）
         try {
-          const orderInPayment = await this.payment.getPaymentOrderByUuidAsync(
-            this.store.currentOrder.uuid
-          );
-          if (orderInPayment && orderInPayment.note !== void 0) {
-            console.log("[Checkout] 同步备注到Payment模块的订单数据中");
-          }
+          const orderInPayment = await this.payment.getPaymentOrderByUuidAsync(this.store.currentOrder.uuid);
+          if (orderInPayment && orderInPayment.note !== undefined) {}
         } catch (syncError) {
-          console.warn(
-            "[Checkout] 同步备注到Payment模块失败，但本地更新成功:",
-            syncError
-          );
+          console.warn('[Checkout] 同步备注到Payment模块失败，但本地更新成功:', syncError);
         }
       }
+
+      // 触发订单数据变更事件
       await this.core.effects.emit(`${this.name}:onOrderNoteChanged`, {
-        orderUuid: (_b = this.store.currentOrder) == null ? void 0 : _b.uuid,
+        orderUuid: this.store.currentOrder?.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
-      );
+      console.error('[Checkout] 更新订单备注失败:', error);
+      await this.handleError(error, _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);
+    const checkoutError = error instanceof Error && 'type' in error ? error : (0, _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);
+    console.error('[Checkout] 错误:', checkoutError);
   }
+
   /**
    * 处理支付成功
    */
   async handlePaymentSuccess(data) {
-    var _a;
+    // 支付状态变更后更新 stateAmount
     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",
+      paymentMethodCode: '',
+      amount: this.store.currentOrder?.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
-    );
+    const error = (0, _utils.createCheckoutError)(_types.CheckoutErrorType.PaymentFailed, data.error || '支付同步失败');
+    await this.handleError(error instanceof Error ? error : new Error(String(error)), _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",
+      paymentMethodCode: '',
+      amount: this.store.currentOrder?.total_amount || '0',
       timestamp: data.timestamp
     });
   }
+
   /**
    * 验证结账参数
    */
   validateCheckoutParams(params) {
-    return (0, import_utils.validateCheckoutData)(params);
+    return (0, _utils.validateCheckoutData)(params);
   }
+
   /**
    * 处理现金支付项的找零逻辑
    *
@@ -1827,26 +1937,32 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
    * @returns 处理后的支付项（包含找零信息）
    */
   async processCashPaymentItem(paymentItem) {
-    const cashPayment = (0, import_utils.isCashPayment)(paymentItem);
+    // 检查是否是现金支付
+    const cashPayment = (0, _utils.isCashPayment)(paymentItem);
     if (!cashPayment) {
+      // 非现金支付，直接返回原始支付项
       return paymentItem;
     }
     try {
+      // 获取剩余待付金额
       const remainingAmountStr = await this.calculateRemainingAmountAsync();
-      const remainingAmount = new import_decimal.default(remainingAmountStr);
-      const cashAmount = new import_decimal.default(String(paymentItem.amount));
-      const roundingAmount = new import_decimal.default(String(paymentItem.rounding_amount || "0"));
+      const remainingAmount = new _decimal.default(remainingAmountStr);
+      const cashAmount = new _decimal.default(String(paymentItem.amount));
+      const roundingAmount = new _decimal.default(String(paymentItem.rounding_amount || '0'));
+
+      // 如果现金金额小于等于剩余待付金额，无需找零
       if (cashAmount.lte(remainingAmount)) {
         return paymentItem;
       }
-      const chargeAmount = import_decimal.default.max(
-        remainingAmount.add(roundingAmount),
-        new import_decimal.default(0)
-      );
+
+      // 超付场景使用 rounding 回算应收金额（兼容 UI 已做抹零 + 允许超付）
+      const chargeAmount = _decimal.default.max(remainingAmount.add(roundingAmount), new _decimal.default(0));
       if (cashAmount.lte(chargeAmount)) {
         return paymentItem;
       }
       const changeAmount = cashAmount.sub(chargeAmount);
+
+      // 创建包含找零信息的支付项
       const processedPaymentItem = {
         ...paymentItem,
         amount: chargeAmount.toFixed(2),
@@ -1856,7 +1972,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
           change_given_amount: changeAmount.toNumber()
         }
       };
-      this.logInfo("Cash payment with change processed", {
+      this.logInfo('Cash payment with change processed', {
         originalAmount: cashAmount.toFixed(2),
         remainingAmount: remainingAmount.toFixed(2),
         roundingAmount: roundingAmount.toFixed(2),
@@ -1875,24 +1991,25 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       });
       return processedPaymentItem;
     } catch (error) {
-      this.logError("处理现金支付项时出错:", 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);
+      console.error('[Checkout] 预加载支付方式失败:', error);
       this.store.paymentMethods = [];
     }
   }
+
   /**
    * 清理过期的已同步订单数据
    *
@@ -1900,53 +2017,57 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
    */
   /** @deprecated */
   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;
+      const isCleanupEnabled = cleanupConfig.enabled !== false; // 默认启用
+      const retentionDays = cleanupConfig.retentionDays || 7; // 默认保留7天
+      const maxOrdersToDelete = cleanupConfig.maxOrdersToDelete || 100; // 默认最多删除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();
+      const thresholdDate = 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);
+          // 检查订单是否已同步（订单ID不是虚拟ID）
+          const isSynced = order.order_id && !(0, _utils.isVirtualOrderId)(order.order_id);
           if (!isSynced) {
-            continue;
+            continue; // 跳过未同步的订单
           }
+
+          // 检查创建时间
           let orderCreatedAt = null;
-          if ((_a = order.order_info) == null ? void 0 : _a.created_at) {
+
+          // 尝试从 order_info.created_at 获取创建时间
+          if (order.order_info?.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
-            );
           }
+          // 如果没有，尝试从 order_info.original_order_data.created_at 获取
+          else if (order.order_info?.original_order_data?.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)
-              )
+              daysSinceCreated: Math.floor((Date.now() - orderCreatedAt.getTime()) / (1000 * 60 * 60 * 24))
             });
           }
         } catch (error) {
@@ -1954,17 +2075,16 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
           continue;
         }
       }
-      ordersToDelete.sort(
-        (a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime()
-      );
+
+      // 按创建时间排序（最老的先删除）并限制删除数量
+      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);
         }
@@ -1972,76 +2092,93 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       const summary = {
         totalOrders: allOrders.length,
         expiredSyncedOrders: ordersToDelete.length,
-        maxOrdersToDelete,
+        maxOrdersToDelete: maxOrdersToDelete,
         actualDeletedOrders: deletedCount,
-        retentionDays,
-        cleanupDate: (/* @__PURE__ */ new Date()).toISOString(),
+        retentionDays: retentionDays,
+        cleanupDate: 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} 个过期已同步订单`
-        );
-      }
+
+      // 记录清理结果
+      this.logInfo('Expired orders cleanup completed', summary);
+      if (ordersToDelete.length > maxOrdersToDelete) {} else {}
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      console.error("[Checkout] 清理过期订单数据失败:", error);
-      this.logError("Expired orders cleanup failed", { error: errorMessage });
+      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 };
+      return {
+        paymentItems: [],
+        currentOrder: null
+      };
     }
     const orderUuid = this.store.currentOrder.uuid;
+
+    // 检查缓存是否有效（5秒内的缓存认为有效）
     const now = Date.now();
-    const cacheValid = this.calculationCache.orderUuid === orderUuid && this.calculationCache.timestamp && now - this.calculationCache.timestamp < 5e3;
+    const cacheValid = this.calculationCache.orderUuid === orderUuid && this.calculationCache.timestamp && now - this.calculationCache.timestamp < 5000;
     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)
-    ]);
+
+    // 并行获取数据，减少等待时间
+    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 };
+    return {
+      paymentItems,
+      currentOrder
+    };
   }
+
   /**
    * 从支付项数组计算已支付金额（纯计算，不查询数据库）
    */
   calculatePaidAmountFromItems(payments) {
-    const paidAmount = payments.filter((payment) => payment.status !== "voided").reduce((sum, payment) => {
-      const paymentAmount = new import_decimal.default(payment.amount || 0);
-      const roundingAmount = new import_decimal.default(payment.rounding_amount || 0);
+    // 使用 Decimal.js 进行安全的金额计算
+    const paidAmount = payments.filter(payment => payment.status !== 'voided') // 只计算未撤销的支付项
+    .reduce((sum, payment) => {
+      // const amount = new Decimal(payment.amount || '0');
+      // 计算有效支付金额：支付金额 + 抹零金额的绝对值
+      // 当 rounding_amount 为负数时，表示抹掉的金额，按绝对值计算有效支付
+      // 例如：amount=15, rounding_amount=-0.2，有效支付=15.2（抹掉0.2元零头）
+      // 例2：amount=15,rounding_amount=0.2,有效支付 14.8 
+      const paymentAmount = new _decimal.default(payment.amount || 0);
+      const roundingAmount = new _decimal.default(payment.rounding_amount || 0);
       const effectiveAmount = paymentAmount.minus(roundingAmount);
       return sum.add(effectiveAmount);
-    }, new import_decimal.default(0));
+    }, new _decimal.default(0));
     return paidAmount.toFixed(2);
   }
+
   /**
    * 计算已支付金额（从 Payment 模块获取最新数据）
    *
@@ -2050,50 +2187,63 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
    */
   async calculatePaidAmountAsync() {
     if (!this.store.currentOrder) {
-      this.logWarning("[Checkout] calculatePaidAmountAsync: 没有当前订单");
-      return "0.00";
+      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;
+      const cacheValid = this.calculationCache.orderUuid === this.store.currentOrder.uuid && this.calculationCache.timestamp && now - this.calculationCache.timestamp < 5000 && this.calculationCache.paidAmount;
       if (cacheValid && this.calculationCache.paidAmount) {
         return this.calculationCache.paidAmount;
       }
-      const payments = await this.payment.getPaymentItemsAsync(
-        this.store.currentOrder.uuid,
-        false
-        // 不包括已撤销的支付项
+
+      // 从 Payment 模块获取最新的支付项数据
+      const payments = await this.payment.getPaymentItemsAsync(this.store.currentOrder.uuid, false // 不包括已撤销的支付项
       );
       const result = this.calculatePaidAmountFromItems(payments);
+
+      // 更新缓存
       this.calculationCache.paidAmount = result;
-      this.logInfo("calculatePaidAmountAsync: 计算结果 =", result);
+      this.logInfo('calculatePaidAmountAsync: 计算结果 =', result);
       return result;
     } catch (error) {
-      this.logError("calculatePaidAmountAsync 失败:", error);
-      return "0.00";
+      this.logError('calculatePaidAmountAsync 失败:', error);
+      return '0.00';
     }
   }
+
   /**
    * 从订单和支付项计算剩余金额（纯计算，不查询数据库）
    */
   calculateRemainingAmountFromData(currentOrder, paidAmount) {
-    let totalAmount = new import_decimal.default(currentOrder.total_amount || "0");
+    // 使用 Decimal.js 进行安全的金额计算
+    let totalAmount = new _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);
+      totalAmount = new _decimal.default(currentOrder.deposit_amount);
     }
-    const paid = new import_decimal.default(paidAmount);
+    const paid = new _decimal.default(paidAmount);
     const remainingAmount = totalAmount.sub(paid);
-    return import_decimal.default.max(0, remainingAmount).toFixed(2);
+
+    // 确保剩余金额不为负数
+    return _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 totalAmount = new _decimal.default(currentOrder.total_amount || '0');
+    const paid = new _decimal.default(paidAmount);
     const remainingAmount = totalAmount.sub(paid);
-    return import_decimal.default.max(0, remainingAmount).toFixed(2);
+
+    // 确保剩余金额不为负数
+    return _decimal.default.max(0, remainingAmount).toFixed(2);
   }
+
   /**
    * 计算剩余未支付金额（从 Payment 模块获取最新数据）
    *
@@ -2102,18 +2252,23 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
    */
   async calculateRemainingAmountAsync() {
     if (!this.store.currentOrder) {
-      this.logWarning("calculateRemainingAmountAsync: 没有当前订单");
-      return "0.00";
+      this.logWarning('calculateRemainingAmountAsync: 没有当前订单');
+      return '0.00';
     }
-    const { currentOrder } = await this.fetchOrderDataBatch();
+
+    // 尝试使用批量获取的数据
+    const {
+      currentOrder
+    } = await this.fetchOrderDataBatch();
     if (!currentOrder) {
-      return "0.00";
+      return '0.00';
     }
     const paidAmountStr = await this.calculatePaidAmountAsync();
     const result = this.calculateRemainingAmountFromData(currentOrder, paidAmountStr);
-    this.logInfo("calculateRemainingAmountAsync: 计算=", result);
+    this.logInfo('calculateRemainingAmountAsync: 计算=', result);
     return result;
   }
+
   /**
    * 计算剩余未支付金额（排除定金计算，始终使用订单总金额）
    *
@@ -2122,18 +2277,23 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
    */
   async calculateRemainingTotalAmountAsync() {
     if (!this.store.currentOrder) {
-      this.logWarning("calculateRemainingTotalAmountAsync: 没有当前订单");
-      return "0.00";
+      this.logWarning('calculateRemainingTotalAmountAsync: 没有当前订单');
+      return '0.00';
     }
-    const { currentOrder } = await this.fetchOrderDataBatch();
+
+    // 尝试使用批量获取的数据
+    const {
+      currentOrder
+    } = await this.fetchOrderDataBatch();
     if (!currentOrder) {
-      return "0.00";
+      return '0.00';
     }
     const paidAmountStr = await this.calculatePaidAmountAsync();
     const result = this.calculateRemainingTotalAmountFromData(currentOrder, paidAmountStr);
-    this.logInfo("calculateRemainingTotalAmountAsync: 计算=", result);
+    this.logInfo('calculateRemainingTotalAmountAsync: 计算=', result);
     return result;
   }
+
   /**
    * 更新 balanceDueAmount 为当前剩余未支付金额（系统内部计算）
    */
@@ -2142,28 +2302,33 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       const remainingAmount = await this.calculateRemainingAmountAsync();
       const remainingTotalAmount = await this.calculateRemainingTotalAmountAsync();
       const currentBalanceDueAmount = this.store.balanceDueAmount;
+
+      // 只有当剩余金额与当前 balanceDueAmount 不同时才更新
       if (remainingAmount !== currentBalanceDueAmount) {
         this.store.balanceDueAmount = remainingAmount;
+
+        // 发出 balanceDueAmount 变更事件
         await this.core.effects.emit(`${this.name}:onBalanceDueAmountChanged`, {
           oldAmount: currentBalanceDueAmount,
           newAmount: remainingAmount,
           timestamp: Date.now(),
           totalAmount: remainingTotalAmount
         });
-        this.logInfo("balanceDueAmount 已自动更新:", {
+        this.logInfo('balanceDueAmount 已自动更新:', {
           oldAmount: currentBalanceDueAmount,
           newAmount: remainingAmount
         });
       } else {
-        this.logInfo("balanceDueAmount 无需更新，当前值已是最新:", {
+        this.logInfo('balanceDueAmount 无需更新，当前值已是最新:', {
           balanceDueAmount: currentBalanceDueAmount,
-          remainingAmount
+          remainingAmount: remainingAmount
         });
       }
     } catch (error) {
-      this.logError("更新 balanceDueAmount 失败:", error);
+      this.logError('更新 balanceDueAmount 失败:', error);
     }
   }
+
   /**
    * 更新 stateAmount 为当前剩余未支付金额
    *
@@ -2174,37 +2339,51 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       if (!this.store.currentOrder) {
         return;
       }
-      console.time("updateStateAmountToRemaining");
-      const { paymentItems, currentOrder } = await this.fetchOrderDataBatch();
-      console.timeEnd("updateStateAmountToRemaining");
+      // 🚀 性能优化：一次性批量获取所有需要的数据
+      const {
+        paymentItems,
+        currentOrder
+      } = await this.fetchOrderDataBatch();
       if (!currentOrder) {
-        this.logWarning("updateStateAmountToRemaining: 未找到当前订单");
+        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) {
+        const depositPaidAmount = paymentItems.filter(item => item.order_payment_type === 'deposit' && item.status !== 'voided').reduce((sum, item) => {
+          // 如果是 wallet，并且还没同步到后端，且此时还没有其他类型的支付项（现金，eftpos，标记支付）,不计入已付金额
+          // 如果有其他支付项了，代表此时处于马上要同步的状态，所以计入
+          if (item.voucher_id && !item.isSynced && paymentItems.filter(item => !item.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");
+          const amount = new _decimal.default(item.amount || '0');
+          const roundingAmount = new _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")) {
+        }, new _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,
@@ -2215,11 +2394,12 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         });
         hasStateChanged = true;
       }
-      console.time("updateStateAmountToRemaining: remainingAmount");
+      // 更新 stateAmount
       if (remainingAmount !== currentStateAmount) {
         this.store.stateAmount = remainingAmount;
         hasStateChanged = true;
         setTimeout(() => {
+          // 发出 stateAmount 变更事件
           this.core.effects.emit(`${this.name}:onStateAmountChanged`, {
             oldAmount: currentStateAmount,
             newAmount: remainingAmount,
@@ -2227,16 +2407,17 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
             totalAmount: remainingTotalAmount
           });
         }, 0);
-        this.logInfo("stateAmount 已自动更新为剩余金额:", {
+        this.logInfo('stateAmount 已自动更新为剩余金额:', {
           oldAmount: currentStateAmount,
           newAmount: remainingAmount
         });
       }
-      console.timeEnd("updateStateAmountToRemaining: remainingAmount");
-      console.time("updateStateAmountToRemaining: updateStateAmountToRemaining");
+      // 更新 balanceDueAmount
       if (remainingAmount !== currentBalanceDueAmount) {
         this.store.balanceDueAmount = remainingAmount;
         hasStateChanged = true;
+
+        // 发出 balanceDueAmount 变更事件
         setTimeout(() => {
           this.core.effects.emit(`${this.name}:onBalanceDueAmountChanged`, {
             oldAmount: currentBalanceDueAmount,
@@ -2245,27 +2426,29 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
             totalAmount: remainingTotalAmount
           });
         }, 0);
-        this.logInfo("balanceDueAmount 已自动更新:", {
+        this.logInfo('balanceDueAmount 已自动更新:', {
           oldAmount: currentBalanceDueAmount,
           newAmount: remainingAmount
         });
       }
-      console.timeEnd("updateStateAmountToRemaining: updateStateAmountToRemaining");
       if (!hasStateChanged) {
-        this.logInfo("状态无需更新，当前值已是最新:", {
+        this.logInfo('状态无需更新，当前值已是最新:', {
           stateAmount: currentStateAmount,
-          remainingAmount
+          remainingAmount: remainingAmount
         });
       }
+
+      // 检查订单支付完成（复用已获取的数据）
       if (checkOrder) {
         await this.checkOrderPaymentCompletionOptimized(paymentItems, remainingAmount);
       } else {
-        this.logInfo("外部传入无需 checkOrder，不执行订单支付完成检测和同步");
+        this.logInfo('外部传入无需 checkOrder，不执行订单支付完成检测和同步');
       }
     } catch (error) {
-      this.logError("更新 stateAmount 为剩余金额失败:", error);
+      this.logError('更新 stateAmount 为剩余金额失败:', error);
     }
   }
+
   /**
    * 检查订单支付是否完成（优化版，复用已获取的数据）
    *
@@ -2277,11 +2460,13 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       if (!this.store.currentOrder) {
         return;
       }
-      const remainingValue = new import_decimal.default(remainingAmount);
+      const remainingValue = new _decimal.default(remainingAmount);
+
+      // 当剩余金额小于等于0时，认为订单已完成支付
       if (remainingValue.lte(0)) {
         const totalAmount = this.store.currentOrder.total_amount;
-        const paidAmount = this.calculationCache.paidAmount || "0.00";
-        this.logInfo("检测到订单支付完成:", {
+        const paidAmount = this.calculationCache.paidAmount || '0.00';
+        this.logInfo('检测到订单支付完成:', {
           orderUuid: this.store.currentOrder.uuid,
           orderId: this.store.currentOrder.order_id,
           totalAmount,
@@ -2289,38 +2474,40 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
           remainingAmount,
           isOrderSynced: this.store.isOrderSynced
         });
+
+        // 检查自动同步条件（复用已获取的支付项数据）
         const hasPaymentItems = paymentItems.length > 0;
-        const allPaymentsHaveVoucherId = hasPaymentItems && paymentItems.every(
-          (item) => item.status !== "voided" && item.voucher_id
-        );
+        const allPaymentsHaveVoucherId = hasPaymentItems && paymentItems.every(item => item.status !== 'voided' && item.voucher_id);
         const shouldAutoSync = hasPaymentItems && !allPaymentsHaveVoucherId;
-        this.logInfo("自动同步订单条件检查:", {
+        this.logInfo('自动同步订单条件检查:', {
           paymentCount: paymentItems.length,
           hasPaymentItems,
           allHaveVoucherId: allPaymentsHaveVoucherId,
           isOrderSynced: this.store.isOrderSynced,
           shouldAutoSync,
-          reason: shouldAutoSync ? "支付完成，需要同步最终支付状态" : "跳过同步",
-          paymentItems: paymentItems.map((p) => ({
+          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),
+            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("满足自动同步条件，开始同步订单到后端...");
+          this.logInfo('满足自动同步条件，开始同步订单到后端...');
           await this.syncOrderToBackendWithReturn(false);
         } else {
           if (!hasPaymentItems) {
-            this.logInfo("没有支付项，跳过订单同步");
+            this.logInfo('没有支付项，跳过订单同步');
           } else if (allPaymentsHaveVoucherId) {
-            this.logInfo("所有支付项均为代金券类型，跳过订单同步");
+            this.logInfo('所有支付项均为代金券类型，跳过订单同步');
           }
         }
+
+        // 触发订单支付完成事件
         await this.core.effects.emit(`${this.name}:onOrderPaymentCompleted`, {
           orderUuid: this.store.currentOrder.uuid,
           orderId: this.store.currentOrder.order_id,
@@ -2331,9 +2518,10 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         });
       }
     } catch (error) {
-      this.logError("检查订单支付完成状态失败:", error);
+      this.logError('检查订单支付完成状态失败:', error);
     }
   }
+
   /**
    * 检查订单支付是否完成
    *
@@ -2348,11 +2536,13 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         return;
       }
       const remainingAmount = await this.calculateRemainingAmountAsync();
-      const remainingValue = new import_decimal.default(remainingAmount);
+      const remainingValue = new _decimal.default(remainingAmount);
+
+      // 当剩余金额小于等于0时，认为订单已完成支付
       if (remainingValue.lte(0)) {
         const totalAmount = this.store.currentOrder.total_amount;
         const paidAmount = await this.calculatePaidAmountAsync();
-        this.logInfo("检测到订单支付完成:", {
+        this.logInfo('检测到订单支付完成:', {
           orderUuid: this.store.currentOrder.uuid,
           orderId: this.store.currentOrder.order_id,
           totalAmount,
@@ -2360,43 +2550,53 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
           remainingAmount,
           isOrderSynced: this.store.isOrderSynced
         });
-        const currentPayments = await this.payment.getPaymentItemsAsync(
-          this.store.currentOrder.uuid,
-          false
-          // 不包括已撤销的支付项
+
+        // 从 Payment 模块获取最新支付项，检查自动同步条件
+        const currentPayments = await this.payment.getPaymentItemsAsync(this.store.currentOrder.uuid, false // 不包括已撤销的支付项
         );
+
+        // 检查自动同步条件：
+        // 1. 待付金额为 0 ✓ (已在上面检查)
+        // 2. 需要有支付项
+        // 3. 支付项不能全是带 voucher_id 的数据
         const hasPaymentItems = currentPayments.length > 0;
-        const allPaymentsHaveVoucherId = hasPaymentItems && currentPayments.every(
-          (item) => item.status !== "voided" && item.voucher_id
-        );
+        const allPaymentsHaveVoucherId = hasPaymentItems && currentPayments.every(item => item.status !== 'voided' && item.voucher_id);
+
+        // 判断是否需要自动同步订单
+        // 条件：
+        // 1. 有支付项
+        // 2. 不全是代金券支付
+        // 3. 订单未同步 OR (订单已同步但支付刚完成，需要同步最终支付状态)
         const shouldAutoSync = hasPaymentItems && !allPaymentsHaveVoucherId;
-        this.logInfo("自动同步订单条件检查:", {
+        this.logInfo('自动同步订单条件检查:', {
           paymentCount: currentPayments.length,
           hasPaymentItems,
           allHaveVoucherId: allPaymentsHaveVoucherId,
           isOrderSynced: this.store.isOrderSynced,
           shouldAutoSync,
-          reason: shouldAutoSync ? "支付完成，需要同步最终支付状态" : "跳过同步",
-          paymentItems: currentPayments.map((p) => ({
+          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),
+            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("满足自动同步条件，开始同步订单到后端...");
+          this.logInfo('满足自动同步条件，开始同步订单到后端...');
           await this.syncOrderToBackendWithReturn(false);
         } else {
           if (!hasPaymentItems) {
-            this.logInfo("没有支付项，跳过订单同步");
+            this.logInfo('没有支付项，跳过订单同步');
           } else if (allPaymentsHaveVoucherId) {
-            this.logInfo("所有支付项均为代金券类型，跳过订单同步");
+            this.logInfo('所有支付项均为代金券类型，跳过订单同步');
           }
         }
+
+        // 触发订单支付完成事件
         await this.core.effects.emit(`${this.name}:onOrderPaymentCompleted`, {
           orderUuid: this.store.currentOrder.uuid,
           orderId: this.store.currentOrder.order_id,
@@ -2407,20 +2607,23 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         });
       }
     } catch (error) {
-      this.logError("检查订单支付完成状态失败:", error);
+      this.logError('检查订单支付完成状态失败:', error);
     }
   }
   async repairEftposPaymentFromIndexDbAsync(params) {
-    const { orderUuid, paymentItem } = params;
+    const {
+      orderUuid,
+      paymentItem
+    } = params;
     const order = await this.payment.getPaymentOrderByUuidAsync(orderUuid);
     if (!order) {
-      this.logError("EFTPOS repair failed: order not found in IndexDB", {
+      this.logError('EFTPOS repair failed: order not found in IndexDB', {
         orderUuid,
         paymentItem
       });
       return;
     }
-    const orderPaymentType = order.is_deposit === 1 ? "deposit" : "normal";
+    const orderPaymentType = order.is_deposit === 1 ? 'deposit' : 'normal';
     const processedPaymentItem = await this.processCashPaymentItem(paymentItem);
     const metadata = {
       ...processedPaymentItem.metadata,
@@ -2433,81 +2636,79 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       metadata
     };
     await this.payment.addPaymentItemAsync(orderUuid, paymentItemWithType);
-    await this.syncOrderToBackendFromIndexDbAsync({ orderUuid });
+    await this.syncOrderToBackendFromIndexDbAsync({
+      orderUuid
+    });
   }
   async syncOrderToBackendFromIndexDbAsync(params) {
-    var _a, _b, _c, _d, _e, _f, _g, _h;
-    const { orderUuid } = params;
+    const {
+      orderUuid
+    } = params;
     const paymentOrder = await this.payment.getPaymentOrderByUuidAsync(orderUuid);
     if (!paymentOrder) {
-      this.logError("EFTPOS repair sync failed: missing payment order", {
+      this.logError('EFTPOS repair sync failed: missing payment order', {
         orderUuid
       });
-      return { success: false };
+      return {
+        success: false
+      };
     }
-    const localOrderData = ((_a = paymentOrder.order_info) == null ? void 0 : _a.original_order_data) || ((_b = paymentOrder.order_info) == null ? void 0 : _b.order_data);
+    const localOrderData = paymentOrder.order_info?.original_order_data || paymentOrder.order_info?.order_data;
     if (!localOrderData) {
-      this.logError("EFTPOS repair sync failed: missing local order data", {
+      this.logError('EFTPOS repair sync failed: missing local order data', {
         orderUuid,
         orderInfoKeys: Object.keys(paymentOrder.order_info || {})
       });
-      return { success: false };
-    }
-    const paymentItems = await this.payment.getPaymentItemsAsync(orderUuid);
-    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
-        }
+        success: false
       };
-    });
+    }
+    const paymentItems = await this.payment.getPaymentItemsAsync(orderUuid);
+    const processedPaymentItems = paymentItems.map(item => ({
+      ...item,
+      metadata: {
+        ...item.metadata,
+        rounding_rule: item.metadata?.rounding_rule || this.otherParams.order_rounding_setting,
+        shop_wallet_pass_id: item.metadata?.shop_wallet_pass_id || this.otherParams.shop_wallet_pass_id
+      }
+    }));
     let finalDepositAmount;
-    const manualDepositAmount = paymentOrder.deposit_amount || "0.00";
-    const manualDepositValue = new import_decimal.default(manualDepositAmount);
+    const manualDepositAmount = paymentOrder.deposit_amount || '0.00';
+    const manualDepositValue = new _decimal.default(manualDepositAmount);
     if (manualDepositValue.gt(0)) {
       finalDepositAmount = manualDepositAmount;
     } else {
-      finalDepositAmount = "0.00";
+      finalDepositAmount = '0.00';
     }
-    if (paymentOrder.is_deposit === 0 && processedPaymentItems.every((item) => item.order_payment_type !== "deposit")) {
-      finalDepositAmount = "0.00";
+    if (paymentOrder.is_deposit === 0 && processedPaymentItems.every(item => item.order_payment_type !== 'deposit')) {
+      finalDepositAmount = '0.00';
     }
-    if (paymentOrder.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 amountValue = new import_decimal.default(item.amount || "0");
-        const roundingValue = new import_decimal.default(item.rounding_amount || "0");
+    if (paymentOrder.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 amountValue = new _decimal.default(item.amount || '0');
+        const roundingValue = new _decimal.default(item.rounding_amount || '0');
         return sum.plus(amountValue).sub(roundingValue);
-      }, new import_decimal.default(0)).toFixed(2);
-    }
-    if (paymentOrder.is_deposit === 1 && new import_decimal.default(finalDepositAmount).gte(
-      new import_decimal.default(paymentOrder.total_amount)
-    )) {
-      finalDepositAmount = processedPaymentItems.filter(
-        (item) => item.status !== "voided" && item.order_payment_type === "deposit"
-      ).reduce((sum, item) => {
-        const amountValue = new import_decimal.default(item.amount || "0");
-        const roundingValue = new import_decimal.default(item.rounding_amount || "0");
+      }, new _decimal.default(0)).toFixed(2);
+    }
+    if (paymentOrder.is_deposit === 1 && new _decimal.default(finalDepositAmount).gte(new _decimal.default(paymentOrder.total_amount))) {
+      finalDepositAmount = processedPaymentItems.filter(item => item.status !== 'voided' && item.order_payment_type === 'deposit').reduce((sum, item) => {
+        const amountValue = new _decimal.default(item.amount || '0');
+        const roundingValue = new _decimal.default(item.rounding_amount || '0');
         return sum.plus(amountValue).sub(roundingValue);
-      }, new import_decimal.default(0)).toFixed(2);
+      }, new _decimal.default(0)).toFixed(2);
     }
     let orderPaymentStatus;
-    const totalPaidAmount = processedPaymentItems.filter((item) => item.status !== "voided").reduce((sum, item) => {
-      const amountValue = new import_decimal.default(item.amount || "0");
-      const roundingValue = new import_decimal.default(item.rounding_amount || "0");
+    const totalPaidAmount = processedPaymentItems.filter(item => item.status !== 'voided').reduce((sum, item) => {
+      const amountValue = new _decimal.default(item.amount || '0');
+      const roundingValue = new _decimal.default(item.rounding_amount || '0');
       return sum.plus(amountValue).sub(roundingValue);
-    }, new import_decimal.default(0));
-    if (totalPaidAmount.gte(new import_decimal.default(paymentOrder.total_amount))) {
-      orderPaymentStatus = "paid";
+    }, new _decimal.default(0));
+    if (totalPaidAmount.gte(new _decimal.default(paymentOrder.total_amount))) {
+      orderPaymentStatus = 'paid';
     } else if (totalPaidAmount.gt(0)) {
-      orderPaymentStatus = "partially_paid";
+      orderPaymentStatus = 'partially_paid';
     } else {
-      orderPaymentStatus = "unpaid";
+      orderPaymentStatus = 'unpaid';
     }
     const orderParams = {
       ...localOrderData,
@@ -2523,44 +2724,46 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       currency_code: this.otherParams.currency_code,
       currency_symbol: this.otherParams.currency_symbol,
       currency_format: this.otherParams.currency_format,
-      business_code: ((_c = this.otherParams) == null ? void 0 : _c.business_code) || void 0,
+      business_code: this.otherParams?.business_code || undefined,
       is_deposit: (paymentOrder.is_deposit || Number(finalDepositAmount) > 0 ? 1 : 0) || 0,
       deposit_amount: finalDepositAmount,
       product_tax_fee: localOrderData.tax_fee,
       note: localOrderData.shop_note,
-      bookings: (_d = localOrderData.bookings) == null ? void 0 : _d.map((item) => {
+      bookings: localOrderData.bookings?.map(item => {
         return {
           ...item,
           product: {
             ...item.product,
-            custom_deposit_data: void 0
+            custom_deposit_data: undefined
           },
-          deposit: void 0
+          deposit: undefined
         };
       }),
-      relation_products: (_e = localOrderData.relation_products) == null ? void 0 : _e.map((item) => {
+      relation_products: localOrderData.relation_products?.map(item => {
         return {
           ...item,
-          custom_deposit_data: void 0,
-          deposit: void 0
+          custom_deposit_data: undefined,
+          deposit: undefined
         };
       })
     };
     const currentOrderId = paymentOrder.order_id;
-    const isUpdateOperation = currentOrderId && !(0, import_utils.isVirtualOrderId)(currentOrderId);
+    const isUpdateOperation = currentOrderId && !(0, _utils.isVirtualOrderId)(currentOrderId);
     if (isUpdateOperation) {
       orderParams.order_id = currentOrderId;
     }
-    this.logError("EFTPOS repair sync start", {
+    this.logError('EFTPOS repair sync start', {
       orderUuid,
       orderId: currentOrderId,
       isUpdateOperation,
       paymentItemCount: processedPaymentItems.length
     });
+
+    // 发送下单接口请求开始事件
     const startTime = Date.now();
     await this.core.effects.emit(`${this.name}:onOrderSubmitStart`, {
-      orderUuid,
-      operation: isUpdateOperation ? "update" : "create",
+      orderUuid: orderUuid,
+      operation: isUpdateOperation ? 'update' : 'create',
       isManual: false,
       paymentItemCount: processedPaymentItems.length,
       timestamp: startTime
@@ -2569,80 +2772,85 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
     let submitSuccess = false;
     let submitError;
     try {
-      this.logError("EFTPOS repair calling backend checkout API", {
-        url: "/order/checkout",
+      this.logError('EFTPOS repair calling backend checkout API', {
+        url: '/order/checkout',
         isManual: true,
         ...orderParams
       });
       checkoutResponse = await this.order.createOrderByCheckout(orderParams);
       submitSuccess = true;
     } catch (error) {
-      this.logError("EFTPOS repair checkout API failed", {
+      this.logError('EFTPOS repair checkout API failed', {
         orderUuid,
         error: error instanceof Error ? error.message : String(error)
       });
       submitError = error instanceof Error ? error.message : String(error);
       throw error;
     } finally {
-      this.logError("EFTPOS repair sync end", {
+      this.logError('EFTPOS repair sync end', {
         orderUuid,
         orderId: currentOrderId,
-        responseStatus: checkoutResponse == null ? void 0 : checkoutResponse.status
+        responseStatus: checkoutResponse?.status
       });
       this.core.effects.emit(`${this.name}:onOrderSubmitEnd`, {
         success: submitSuccess,
-        orderUuid,
-        operation: isUpdateOperation ? "update" : "create",
+        orderUuid: orderUuid,
+        operation: isUpdateOperation ? 'update' : 'create',
         isManual: false,
-        orderId: submitSuccess ? ((_f = checkoutResponse == null ? void 0 : checkoutResponse.data) == null ? void 0 : _f.order_id) || (checkoutResponse == null ? void 0 : checkoutResponse.order_id) : void 0,
+        orderId: submitSuccess ? checkoutResponse?.data?.order_id || checkoutResponse?.order_id : undefined,
         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;
+    const responseStatus = checkoutResponse?.status;
+    const isSuccessResponse = responseStatus === true || responseStatus === 200 || responseStatus === 'success' || responseStatus === 1 && checkoutResponse?.code === 200;
     if (!isSuccessResponse) {
-      const errorMessage = (checkoutResponse == null ? void 0 : checkoutResponse.message) || "订单同步失败，后端返回非成功状态";
-      this.logError("EFTPOS repair sync failed: api error", {
+      const errorMessage = checkoutResponse?.message || '订单同步失败，后端返回非成功状态';
+      this.logError('EFTPOS repair sync failed: api error', {
         orderUuid,
         errorMessage,
         response: checkoutResponse
       });
-      return { success: false, response: checkoutResponse };
+      return {
+        success: false,
+        response: checkoutResponse
+      };
     }
     let realOrderId = currentOrderId;
     if (!isUpdateOperation) {
-      let extractedOrderId = (_g = checkoutResponse == null ? void 0 : checkoutResponse.data) == null ? void 0 : _g.order_id;
+      let extractedOrderId = checkoutResponse?.data?.order_id;
       if (!extractedOrderId) {
-        extractedOrderId = checkoutResponse == null ? void 0 : checkoutResponse.order_id;
+        extractedOrderId = checkoutResponse?.order_id;
       }
-      if (extractedOrderId !== void 0 && extractedOrderId !== null) {
+      if (extractedOrderId !== undefined && extractedOrderId !== null) {
         extractedOrderId = String(extractedOrderId);
       }
       realOrderId = extractedOrderId;
       if (realOrderId) {
         await this.payment.replaceOrderIdByUuidAsync(orderUuid, realOrderId);
       } else {
-        this.logError("EFTPOS repair missing order_id in response", {
+        this.logError('EFTPOS repair missing order_id in response', {
           orderUuid,
           response: checkoutResponse
         });
       }
     }
-    const syncedPaymentUuids = processedPaymentItems.filter((item) => item.status !== "voided").map((item) => item.uuid).filter(Boolean);
+    const syncedPaymentUuids = processedPaymentItems.filter(item => item.status !== 'voided').map(item => item.uuid).filter(Boolean);
     for (const paymentUuid of syncedPaymentUuids) {
       await this.payment.updatePaymentAsync(orderUuid, paymentUuid, {
         isSynced: true,
-        syncError: void 0
+        syncError: undefined
       });
     }
-    const latestPaymentStatus = ((_h = checkoutResponse == null ? void 0 : checkoutResponse.data) == null ? void 0 : _h.payment_status) || orderPaymentStatus;
+    const latestPaymentStatus = checkoutResponse?.data?.payment_status || orderPaymentStatus;
     await this.payment.updateOrderAsync(orderUuid, {
       payment_status: latestPaymentStatus
     });
+
+    // 触发订单同步完成事件
     await this.core.effects.emit(`${this.name}:onOrderSynced`, {
-      orderUuid,
+      orderUuid: orderUuid,
       realOrderId,
       virtualOrderId: orderUuid,
       timestamp: Date.now(),
@@ -2656,6 +2864,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       response: checkoutResponse
     };
   }
+
   /**
    * 同步订单到后端并返回真实订单ID
    *
@@ -2664,26 +2873,22 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
    * @returns 包含订单ID、UUID和完整后端响应的对象
    */
   async syncOrderToBackendWithReturn(isManual = false, customPaymentItems, paymentStatus) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i;
     if (!this.store.localOrderData || !this.store.currentOrder) {
-      throw new Error("缺少必要的订单数据，无法同步到后端");
+      throw new Error('缺少必要的订单数据，无法同步到后端');
     }
     const orderLockKey = this.store.currentOrder.uuid || this.store.currentOrder.order_id;
     if (!orderLockKey) {
-      throw new Error("缺少订单标识，无法同步到后端");
+      throw new Error('缺少订单标识，无法同步到后端');
     }
     const existingInFlight = this.syncOrderToBackendInFlightByOrderKey.get(orderLockKey);
     if (existingInFlight) {
-      this.logInfo(
-        "syncOrderToBackendWithReturn 触发锁：当前订单正在同步中，将等待当前同步结束",
-        {
-          orderLockKey,
-          orderUuid: this.store.currentOrder.uuid,
-          orderId: this.store.currentOrder.order_id,
-          isManual,
-          hasCustomPaymentItems: !!customPaymentItems
-        }
-      );
+      this.logInfo('syncOrderToBackendWithReturn 触发锁：当前订单正在同步中，将等待当前同步结束', {
+        orderLockKey,
+        orderUuid: this.store.currentOrder.uuid,
+        orderId: this.store.currentOrder.order_id,
+        isManual,
+        hasCustomPaymentItems: !!customPaymentItems
+      });
       return await existingInFlight;
     }
     let resolveInFlight;
@@ -2694,65 +2899,77 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
     });
     this.syncOrderToBackendInFlightByOrderKey.set(orderLockKey, inFlightPromise);
     try {
-      this.logInfo("syncOrderToBackendWithReturn called", { isManual });
+      this.logInfo('syncOrderToBackendWithReturn called', {
+        isManual
+      });
       const currentOrderId = this.store.currentOrder.order_id;
-      const isUpdateOperation = this.store.isOrderSynced || !(0, import_utils.isVirtualOrderId)(currentOrderId);
+      const isUpdateOperation = this.store.isOrderSynced || !(0, _utils.isVirtualOrderId)(currentOrderId);
       this.logInfo(`开始同步订单到后端...`, {
         currentOrderId,
-        isVirtualId: (0, import_utils.isVirtualOrderId)(currentOrderId || ""),
+        isVirtualId: (0, _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
-          }
-        };
-      });
+
+      // 获取当前订单的支付项
+      const paymentItems = customPaymentItems || (await this.payment.getPaymentItemsAsync(this.store.currentOrder.uuid));
+
+      // 处理支付项数据，确保包含完整的 metadata
+      const processedPaymentItems = paymentItems.map(item => ({
+        ...item,
+        metadata: {
+          ...item.metadata,
+          rounding_rule: item.metadata?.rounding_rule || this.otherParams.order_rounding_setting,
+          shop_wallet_pass_id: item.metadata?.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);
+      const manualDepositAmount = this.store.currentOrder?.deposit_amount || '0.00';
+
+      // 优先级逻辑：手动设置的定金金额 > 从支付项计算的金额
+      const manualDepositValue = new _decimal.default(manualDepositAmount);
       if (manualDepositValue.gt(0)) {
+        // 如果手动设置了定金金额且大于0，使用手动设置的值
         finalDepositAmount = manualDepositAmount;
-        this.logInfo("使用手动设置的定金金额", {
+        this.logInfo('使用手动设置的定金金额', {
           manualDepositAmount,
-          reason: "用户通过setDepositAmountAsync手动设置了定金金额"
+          reason: '用户通过setDepositAmountAsync手动设置了定金金额'
         });
       } else {
-        finalDepositAmount = "0.00";
-        this.logInfo("定金金额为0", {
+        // 都为0，使用0
+        finalDepositAmount = '0.00';
+        this.logInfo('定金金额为0', {
           manualDepositAmount,
-          reason: "手动设置和计算值均为0"
+          reason: '手动设置和计算值均为0'
         });
       }
-      if (this.store.currentOrder.is_deposit === 0 && processedPaymentItems.every((item) => item.order_payment_type !== "deposit")) {
-        finalDepositAmount = "0.00";
+      // 如果此时是普通支付状态，并且要同步的支付项里一个定金支付的都没有，则 is_deposit 和 deposit_amount 都置为 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");
+      // 如果此时是普通支付，并且有普通支付项进来了，则提交给后端的 deposit_amount 只能是支付项里已经支付的order_payment_type = deposit 的金额
+      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 _decimal.default(item.amount || '0');
+          const rounding = new _decimal.default(item.rounding_amount || '0');
           return sum.plus(amt).sub(rounding);
-        }, new import_decimal.default(0)).toFixed(2);
+        }, new _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");
+      // 如果当前是定金支付，并且定金额度已经大于等于了订单总计，则 finalDepositAmount 为实际付出去的定金金额
+      if (this.store.currentOrder.is_deposit === 1 && new _decimal.default(finalDepositAmount).gte(new _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 _decimal.default(item.amount || '0');
+          const rounding = new _decimal.default(item.rounding_amount || '0');
           return sum.plus(amt).sub(rounding);
-        }, new import_decimal.default(0)).toFixed(2);
+        }, new _decimal.default(0)).toFixed(2);
       }
-      this.logInfo("定金金额确定结果", {
+      this.logInfo('定金金额确定结果', {
         depositPaymentItemsCount: processedPaymentItems.length,
-        depositPaymentItems: processedPaymentItems.map((item) => ({
+        depositPaymentItems: processedPaymentItems.map(item => ({
           uuid: item.uuid,
           code: item.code,
           amount: item.amount,
@@ -2762,23 +2979,32 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         })),
         manualDepositAmount,
         finalDepositAmount,
-        isDeposit: ((_b = this.store.currentOrder) == null ? void 0 : _b.is_deposit) || 0
+        isDeposit: this.store.currentOrder?.is_deposit || 0
       });
+
+      // 计算订单状态，优先读取外面传递的，如果没有则根据订单支付数据来
+      // paid 已全额付款
+      // partially_paid 部分付款
+      // unpaid 未支付（弃单状态）
+      // payment_processing 待支付
       let orderPaymentStatus = paymentStatus;
       if (!orderPaymentStatus) {
-        const totalPaidAmount = processedPaymentItems.filter((item) => item.status !== "voided").reduce((sum, item) => {
-          const amt = new import_decimal.default(item.amount || "0");
-          const rounding = new import_decimal.default(item.rounding_amount || "0");
+        // 判断当前支付项里的数据是否已经满足订单的金额
+        const totalPaidAmount = processedPaymentItems.filter(item => item.status !== 'voided').reduce((sum, item) => {
+          const amt = new _decimal.default(item.amount || '0');
+          const rounding = new _decimal.default(item.rounding_amount || '0');
           return sum.plus(amt).sub(rounding);
-        }, new import_decimal.default(0));
-        if (totalPaidAmount.gte(new import_decimal.default(this.store.currentOrder.total_amount))) {
-          orderPaymentStatus = "paid";
+        }, new _decimal.default(0));
+        if (totalPaidAmount.gte(new _decimal.default(this.store.currentOrder.total_amount))) {
+          orderPaymentStatus = 'paid';
         } else if (totalPaidAmount.gt(0)) {
-          orderPaymentStatus = "partially_paid";
+          orderPaymentStatus = 'partially_paid';
         } else {
-          orderPaymentStatus = "unpaid";
+          orderPaymentStatus = 'unpaid';
         }
       }
+
+      // 构造订单参数，直接使用 localOrderData 中已处理好的数据
       const orderParams = {
         ...this.store.localOrderData,
         payment_status: orderPaymentStatus,
@@ -2786,7 +3012,7 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         platform: this.store.localOrderData.platform,
         payments: processedPaymentItems,
         // 使用处理过的支付项数据
-        customer_id: (_c = this.store.currentCustomer) == null ? void 0 : _c.customer_id,
+        customer_id: this.store.currentCustomer?.customer_id,
         // 添加客户ID
         is_price_include_tax: this.otherParams.is_price_include_tax,
         // core 有
@@ -2799,45 +3025,46 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         currency_code: this.otherParams.currency_code,
         currency_symbol: this.otherParams.currency_symbol,
         currency_format: this.otherParams.currency_format,
-        business_code: ((_d = this.otherParams) == null ? void 0 : _d.business_code) || void 0,
-        is_deposit: (((_e = this.store.currentOrder) == null ? void 0 : _e.is_deposit) || Number(finalDepositAmount) > 0 ? 1 : 0) || 0,
+        business_code: this.otherParams?.business_code || undefined,
+        is_deposit: (this.store.currentOrder?.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: (_f = this.store.localOrderData.bookings) == null ? void 0 : _f.map((item) => {
+        bookings: this.store.localOrderData.bookings?.map(item => {
           return {
             ...item,
             product: {
               ...item.product,
-              custom_deposit_data: void 0
+              custom_deposit_data: undefined
             },
-            deposit: void 0
+            deposit: undefined
           };
         }),
-        relation_products: (_g = this.store.localOrderData.relation_products) == null ? void 0 : _g.map(
-          (item) => {
-            return {
-              ...item,
-              custom_deposit_data: void 0,
-              deposit: void 0
-            };
-          }
-        )
+        relation_products: this.store.localOrderData.relation_products?.map(item => {
+          return {
+            ...item,
+            custom_deposit_data: undefined,
+            deposit: undefined
+          };
+        })
       };
+
+      // 如果是更新操作，需要在参数中包含真实的订单ID
       if (isUpdateOperation) {
-        if ((0, import_utils.isVirtualOrderId)(currentOrderId)) {
-          this.logWarning(
-            "尝试数据修复：暂时不包含order_id，注意：这次调用将作为创建操作处理，但后续会修复数据一致性"
-          );
+        // 如果当前订单ID是虚拟ID，但订单已同步过，可能存在数据不一致的问题
+        if ((0, _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",
+        operation: isUpdateOperation ? 'update' : 'create',
         isManual,
         paymentItemCount: paymentItems.length,
         timestamp: startTime
@@ -2846,73 +3073,93 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       let submitSuccess = false;
       let submitError;
       try {
-        this.logInfo("Calling backend checkout API", {
-          url: "/order/checkout",
+        // 记录接口调用参数
+        this.logInfo('Calling backend checkout API', {
+          url: '/order/checkout',
           isManual,
           ...orderParams
         });
+
+        // 调用 Order 模块的专用 createOrderByCheckout 方法
         checkoutResponse = await this.order.createOrderByCheckout(orderParams);
         submitSuccess = true;
         this.store.currentOrder.payment_status = checkoutResponse.data.payment_status;
-        this.logInfo("下单接口调用成功", checkoutResponse);
+        this.logInfo('下单接口调用成功', checkoutResponse);
       } catch (error) {
         submitSuccess = false;
         submitError = error instanceof Error ? error.message : String(error);
-        this.logError("下单接口调用失败:", submitError);
+        this.logError('下单接口调用失败:', submitError);
+
+        // 发送订单同步失败事件（网络错误或请求失败）
         await this.core.effects.emit(`${this.name}:onOrderSyncFailed`, {
           orderUuid: this.store.currentOrder.uuid,
-          operation: isUpdateOperation ? "update" : "create",
+          operation: isUpdateOperation ? 'update' : 'create',
           isManual,
           error: submitError,
-          errorType: "network_error",
+          errorType: 'network_error',
           duration: Date.now() - startTime,
           timestamp: Date.now()
         });
-        throw error;
+        throw error; // 重新抛出错误以保持原有逻辑
       } finally {
+        // 发送下单接口请求完成事件
         await this.core.effects.emit(`${this.name}:onOrderSubmitEnd`, {
           success: submitSuccess,
           orderUuid: this.store.currentOrder.uuid,
-          operation: isUpdateOperation ? "update" : "create",
+          operation: isUpdateOperation ? 'update' : 'create',
           isManual,
-          orderId: submitSuccess ? ((_h = checkoutResponse == null ? void 0 : checkoutResponse.data) == null ? void 0 : _h.order_id) || (checkoutResponse == null ? void 0 : checkoutResponse.order_id) : void 0,
+          orderId: submitSuccess ? checkoutResponse?.data?.order_id || checkoutResponse?.order_id : undefined,
           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;
+
+      // 检查响应状态是否为成功状态
+      const responseStatus = checkoutResponse?.status;
+      const isSuccessResponse = responseStatus === true || responseStatus === 200 || responseStatus === 'success' || responseStatus === 1 && checkoutResponse?.code === 200;
       if (!isSuccessResponse) {
-        const errorMessage = (checkoutResponse == null ? void 0 : checkoutResponse.message) || "订单同步失败，后端返回非成功状态";
+        const errorMessage = checkoutResponse?.message || '订单同步失败，后端返回非成功状态';
+
+        // 发送订单同步失败事件
         await this.core.effects.emit(`${this.name}:onOrderSyncFailed`, {
           orderUuid: this.store.currentOrder.uuid,
-          operation: isUpdateOperation ? "update" : "create",
+          operation: isUpdateOperation ? 'update' : 'create',
           isManual,
           error: errorMessage,
-          errorType: "api_error",
+          errorType: 'api_error',
           response: checkoutResponse,
           duration: Date.now() - startTime,
           timestamp: Date.now()
         });
+
+        // 抛出错误，终止后续处理
         throw new Error(errorMessage);
       }
       let realOrderId;
       if (isUpdateOperation) {
+        // 更新操作：使用现有的订单ID
         realOrderId = currentOrderId;
       } else {
-        let extractedOrderId = (_i = checkoutResponse == null ? void 0 : checkoutResponse.data) == null ? void 0 : _i.order_id;
+        // 创建操作：从响应中提取新的订单ID
+        let extractedOrderId = checkoutResponse?.data?.order_id;
+
+        // 如果data.order_id不存在，尝试直接从根级获取
         if (!extractedOrderId) {
-          extractedOrderId = checkoutResponse == null ? void 0 : checkoutResponse.order_id;
+          extractedOrderId = checkoutResponse?.order_id;
         }
-        if (extractedOrderId !== void 0 && extractedOrderId !== null) {
+
+        // 确保转换为字符串类型
+        if (extractedOrderId !== undefined && extractedOrderId !== null) {
           extractedOrderId = String(extractedOrderId);
         }
         if (!extractedOrderId) {
-          this.logError("后端返回的订单信息中未包含订单ID");
+          this.logError('后端返回的订单信息中未包含订单ID');
         }
         realOrderId = extractedOrderId;
-        this.logInfo("准备替换订单ID:", {
+
+        // 替换虚拟订单ID为真实订单ID
+        this.logInfo('准备替换订单ID:', {
           orderUuid: this.store.currentOrder.uuid,
           oldOrderId: this.store.currentOrder.order_id,
           newOrderId: realOrderId
@@ -2920,74 +3167,84 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         try {
           const latestPaymentStatus = this.store.currentOrder.payment_status;
           const previousOrder = this.store.currentOrder;
-          const updatedOrder = await this.payment.replaceOrderIdByUuidAsync(
-            previousOrder.uuid,
-            realOrderId
-          );
-          this.logInfo("Payment模块替换订单ID结果:", {
+          const updatedOrder = await this.payment.replaceOrderIdByUuidAsync(previousOrder.uuid, realOrderId);
+          this.logInfo('Payment模块替换订单ID结果:', {
             wasSuccessful: !!updatedOrder,
-            returnedOrderId: updatedOrder == null ? void 0 : updatedOrder.order_id,
+            returnedOrderId: updatedOrder?.order_id,
             expectedOrderId: realOrderId
           });
           if (updatedOrder) {
-            this.logInfo("Payment模块返回的更新后订单:", {
+            this.logInfo('Payment模块返回的更新后订单:', {
               uuid: updatedOrder.uuid,
               orderId: updatedOrder.order_id,
               totalAmount: updatedOrder.total_amount
             });
+
+            // 🔧 合并 DB 快照到内存态，避免覆盖 payment_status（以及其它刚更新过的内存字段）
             this.store.currentOrder = {
               ...previousOrder,
               ...updatedOrder,
               payment_status: latestPaymentStatus
             };
-            if (latestPaymentStatus)
-              await this.payment.updateOrderAsync(previousOrder.uuid, {
-                payment_status: latestPaymentStatus
-              });
-            this.logInfo(
-              "[Checkout] 订单ID替换成功，当前订单ID:",
-              this.store.currentOrder.order_id
-            );
+
+            // 同步更新 Payment 模块 DB，避免后续读取 DB 时又拿回旧状态
+            if (latestPaymentStatus) await this.payment.updateOrderAsync(previousOrder.uuid, {
+              payment_status: latestPaymentStatus
+            });
+            this.logInfo('[Checkout] 订单ID替换成功，当前订单ID:', this.store.currentOrder.order_id);
           } else {
-            this.logError(
-              "[Checkout] Payment模块返回空订单，订单ID替换失败，开始手动替换"
-            );
+            this.logError('[Checkout] Payment模块返回空订单，订单ID替换失败，开始手动替换');
+
+            // 如果替换失败，手动更新订单ID
             const beforeManualUpdate = this.store.currentOrder.order_id;
             this.store.currentOrder.order_id = realOrderId;
-            this.logInfo("手动设置订单ID:", {
+            this.logInfo('手动设置订单ID:', {
               beforeReplacement: beforeManualUpdate,
               afterReplacement: this.store.currentOrder.order_id,
               目标ID: realOrderId
             });
           }
         } catch (error) {
-          this.logError("调用Payment模块替换订单ID时发生错误:", error);
+          this.logError('调用Payment模块替换订单ID时发生错误:', error);
+
+          // 发生错误时也进行手动替换
           this.store.currentOrder.order_id = realOrderId;
-          this.logInfo("错误恢复：手动设置订单ID:", realOrderId);
+          this.logInfo('错误恢复：手动设置订单ID:', realOrderId);
         }
       }
+
+      // 成功后：标记本次传递给后端的支付项为已同步
       try {
-        const syncedPaymentUuids = processedPaymentItems.filter((item) => item.status !== "voided").map((item) => item.uuid).filter(Boolean);
+        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 }
-          );
+          await this.payment.updatePaymentAsync(this.store.currentOrder.uuid, paymentUuid, {
+            isSynced: true,
+            syncError: undefined
+          });
         }
       } catch (e) {
-        this.logWarning("标记支付项已同步失败（不阻塞主流程）", { error: 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,
+        isManual: isManual,
         response: checkoutResponse
       });
+
+      // 返回同步结果
       const result = {
         success: true,
         orderId: realOrderId,
@@ -3006,8 +3263,10 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
       }
     }
   }
-  async setOtherParams(params, { cover = false } = {}) {
-    this.logInfo("setOtherParams called", {
+  async setOtherParams(params, {
+    cover = false
+  } = {}) {
+    this.logInfo('setOtherParams called', {
       metadata: {
         params,
         cover
@@ -3016,9 +3275,13 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
     if (cover) {
       this.otherParams = params;
     } else {
-      this.otherParams = { ...this.otherParams, ...params };
+      this.otherParams = {
+        ...this.otherParams,
+        ...params
+      };
     }
   }
+
   /**
    * 通过订单ID编辑订单备注
    *
@@ -3029,41 +3292,54 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
    * @returns 修改结果
    */
   async editOrderNoteByOrderIdAsync(orderId, note) {
-    this.logInfo("editOrderNoteByOrderIdAsync called", {
-      orderId,
-      note,
+    this.logInfo('editOrderNoteByOrderIdAsync called', {
+      orderId: orderId,
+      note: note,
       noteLength: note.length
     });
     try {
+      // 参数验证
       if (!orderId) {
         return {
           success: false,
-          message: "订单ID不能为空",
-          orderId
+          message: '订单ID不能为空',
+          orderId: orderId
         };
       }
-      this.logInfo("Calling order note edit API", {
+
+      // 记录接口调用
+      this.logInfo('Calling order note edit API', {
         url: `/order/order/${orderId}/note`,
-        method: "PUT",
-        orderId,
-        note,
+        method: 'PUT',
+        orderId: orderId,
+        note: note,
         noteLength: note.length
       });
+
+      // 调用后端API修改订单备注
       const response = await this.request.put(`/order/order/${orderId}/note`, {
-        note
+        note: note
       });
-      this.logInfo("订单备注编辑响应:", {
-        orderId,
+      this.logInfo('订单备注编辑响应:', {
+        orderId: orderId,
         status: response.status,
         message: response.message,
-        response
+        response: 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,
@@ -3073,28 +3349,30 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         }
         return {
           success: true,
-          message: response.message || "订单备注修改成功",
-          orderId
+          message: response.message || '订单备注修改成功',
+          orderId: orderId
         };
       } else {
-        const errorMessage = response.message || "订单备注修改失败";
+        // API返回失败状态
+        const errorMessage = response.message || '订单备注修改失败';
         this.logError(`订单 ${orderId} 备注修改失败:`, errorMessage);
         return {
           success: false,
           message: errorMessage,
-          orderId
+          orderId: orderId
         };
       }
     } catch (error) {
-      this.logError("编辑订单备注失败:", error);
-      const errorMessage = error instanceof Error ? error.message : "网络错误或服务器异常";
+      this.logError('编辑订单备注失败:', error);
+      const errorMessage = error instanceof Error ? error.message : '网络错误或服务器异常';
       return {
         success: false,
         message: `编辑订单备注失败: ${errorMessage}`,
-        orderId
+        orderId: orderId
       };
     }
   }
+
   /**
    * 发送客户支付链接邮件
    *
@@ -3104,78 +3382,85 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
    * @returns 发送结果
    */
   async sendCustomerPayLinkAsync(params) {
-    var _a, _b;
-    this.logInfo("sendCustomerPayLinkAsync called", {
+    this.logInfo('sendCustomerPayLinkAsync called', {
       orderIds: params.order_ids,
-      orderIdsCount: ((_a = params.order_ids) == null ? void 0 : _a.length) || 0,
+      orderIdsCount: params.order_ids?.length || 0,
       emails: params.emails,
-      emailsCount: ((_b = params.emails) == null ? void 0 : _b.length) || 0,
-      notifyAction: params.notify_action || "order_payment_reminder"
+      emailsCount: params.emails?.length || 0,
+      notifyAction: params.notify_action || 'order_payment_reminder'
     });
     try {
+      // 参数验证
       if (!params.order_ids || params.order_ids.length === 0) {
         return {
           success: false,
-          message: "订单ID列表不能为空"
+          message: '订单ID列表不能为空'
         };
       }
       if (!params.emails || params.emails.length === 0) {
         return {
           success: false,
-          message: "邮箱地址列表不能为空"
+          message: '邮箱地址列表不能为空'
         };
       }
+
+      // 验证邮箱格式
       const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-      const invalidEmails = params.emails.filter(
-        (email) => !emailRegex.test(email)
-      );
+      const invalidEmails = params.emails.filter(email => !emailRegex.test(email));
       if (invalidEmails.length > 0) {
         return {
           success: false,
-          message: `邮箱格式无效: ${invalidEmails.join(", ")}`
+          message: `邮箱格式无效: ${invalidEmails.join(', ')}`
         };
       }
+
+      // 构建请求参数
       const requestBody = {
         order_ids: params.order_ids,
-        notify_action: params.notify_action || "order_payment_reminder",
+        notify_action: params.notify_action || 'order_payment_reminder',
         emails: params.emails
       };
-      this.logInfo("Calling batch email API", {
-        url: "/order/batch-email",
+
+      // 记录接口调用
+      this.logInfo('Calling batch email API', {
+        url: '/order/batch-email',
         ...requestBody
       });
-      const response = await this.request.post(
-        "/order/batch-email",
-        requestBody
-      );
-      this.logInfo("支付链接邮件发送响应:", {
+
+      // 调用后端API发送邮件
+      const response = await this.request.post('/order/batch-email', requestBody);
+      this.logInfo('支付链接邮件发送响应:', {
         status: response.status,
         message: response.message,
         data: response.data,
-        response
+        response: response
       });
+
+      // 检查响应状态
       if (response.status === true || response.status === 200) {
         return {
           success: true,
-          message: response.message || "支付链接邮件发送成功"
+          message: response.message || '支付链接邮件发送成功'
         };
       } else {
-        const errorMessage = response.message || "支付链接邮件发送失败";
-        console.error("[Checkout] 支付链接邮件发送失败:", errorMessage);
+        // API返回失败状态
+        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 : "网络错误或服务器异常";
+      this.logError('发送客户支付链接邮件失败:', error);
+      const errorMessage = error instanceof Error ? error.message : '网络错误或服务器异常';
       return {
         success: false,
         message: `发送支付链接邮件失败: ${errorMessage}`
       };
     }
   }
+
   /**
    * 金额舍入
    *
@@ -3183,31 +3468,33 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
    * @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)) {
+    // 检查 CASHMANUAL 的支付项是否开启了舍入，如果没开直接返回 amount
+    const cashManualPayment = this.store.paymentMethods.find(p => p.code === 'CASHMANUAL');
+    if (!cashManualPayment?.metadata?.order_rounding_switch) {
       return {
         originalAmount: amount.toString(),
         roundedAmount: amount.toString(),
-        roundingDifference: "0.00"
+        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
-    );
+    const result = await this.payment.roundAmountAsync(amount, this.otherParams.order_rounding_setting?.interval, this.otherParams.order_rounding_setting?.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));
+
+    // 销毁子模块
+    await this.order?.destroy?.();
+    await this.payment?.destroy?.();
+
+    // 取消注册模块
     this.core.unregisterModule(this);
-    console.log("[Checkout] 已销毁");
   }
+
   /**
    * 重置 store 状态
    *
@@ -3221,19 +3508,29 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         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";
+      // 重置订单相关的 store 状态（保留 paymentMethods，因为支付方式数据变更不频繁）
+      this.store.currentOrder = undefined;
+      this.store.localOrderData = undefined;
+      this.store.cartSummary = undefined;
+      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.currentCustomer = undefined;
+      this.store.lastError = undefined;
+
+      // 清空购物车项目
       this.store.cartItems = [];
+
+      // 清理钱包缓存（同步操作）
       this.payment.wallet.clearAllCache();
+
+      // 🚀 清除计算缓存
       this.clearCalculationCache();
-      console.log("[Checkout] Store 状态重置完成");
+
+      // 注意：故意保留 this.store.paymentMethods，因为支付方式数据不易变更，保留在内存中提高性能
+
+      // 🚀 性能优化：异步触发订单清理事件（不阻塞主流程）
+      // 使用 setTimeout 确保事件处理不会阻塞状态重置
       if (prevOrderInfo) {
         setTimeout(() => {
           this.core.effects.emit(`${this.name}:onOrderCleared`, {
@@ -3243,12 +3540,8 @@ var CheckoutImpl = class extends import_BaseModule.BaseModule {
         }, 0);
       }
     } catch (error) {
-      console.error("[Checkout] 重置 store 状态失败:", error);
+      console.error('[Checkout] 重置 store 状态失败:', error);
     }
   }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  CheckoutImpl,
-  ...require("./types")
-});
+}
+exports.CheckoutImpl = CheckoutImpl;