@pisell/pisellos 0.0.568 → 0.10.1

package/lib/solution/Checkout/index.js

@@ -1,361 +1,346 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-var _exportNames = {
-  CheckoutImpl: true
+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;
 };
-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];
-    }
-  });
+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
 });
-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;
+module.exports = __toCommonJS(Checkout_exports);
+var import_BaseModule = require("../../modules/BaseModule");
+var import_decimal = __toESM(require("decimal.js"));
+var import_Order = require("../../modules/Order");
+var import_Payment = require("../../modules/Payment");
+var import_types = require("./types");
+var import_types2 = require("../../modules/Payment/types");
+var import_utils = require("./utils");
+var import_utils2 = require("../../modules/Cart/utils");
+__reExport(Checkout_exports, require("./types"), module.exports);
+var CheckoutImpl = class extends import_BaseModule.BaseModule {
   constructor(name, version) {
-    super(name || 'checkout', version || '1.0.0');
+    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();
   }
   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 插件支持");
     }
-
-    // 获取 logger 实例
-    const appPlugin = core.getPlugin('app');
+    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 _Order.OrderModule();
-    this.payment = new _Payment.PaymentModule();
-
-    // 初始化状态
+    this.order = new import_Order.OrderModule();
+    this.payment = new import_Payment.PaymentModule();
     this.store = {
       cartItems: [],
       paymentMethods: [],
-      stateAmount: '0.00',
-      balanceDueAmount: '0.00',
-      cartSummary: undefined,
+      stateAmount: "0.00",
+      balanceDueAmount: "0.00",
+      cartSummary: void 0,
       isOrderSynced: false,
-      currentCustomer: undefined
+      currentCustomer: void 0
     };
-
-    // 注册并初始化子模块
     await this.initializeSubModules(core, options);
-
-    // 预加载支付方式（利用缓存机制）
-    await this.preloadPaymentMethods();
-
-    // 清理过期的已同步订单数据
-    await this.cleanupExpiredOrdersAsync();
+    console.log("[Checkout] 初始化完成");
     await this.core.effects.emit(`${this.name}:onCheckoutInitialized`, {
       timestamp: Date.now()
     });
-    this.logInfo('CheckoutModule initialized successfully');
+    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: options.store?.order || {},
-      otherParams: {
-        ...this.otherParams,
-        fatherModule: this.name
-      }
+      store: ((_a = options.store) == null ? void 0 : _a.order) || {},
+      otherParams: { ...this.otherParams, fatherModule: this.name }
     });
-
-    // 初始化支付模块
     core.registerModule(this.payment, {
-      store: options.store?.payment || {},
-      otherParams: {
-        ...this.otherParams,
-        fatherModule: this.name
-      }
+      store: ((_b = options.store) == null ? void 0 : _b.payment) || {},
+      otherParams: { ...this.otherParams, fatherModule: this.name }
     });
-
-    // 监听支付模块事件
     this.setupPaymentEventListeners();
   }
-
   /**
    * 设置支付模块事件监听
    */
   setupPaymentEventListeners() {
-    // 监听支付成功事件
-    this.core.effects.on('payment:onPaymentSyncSuccess', async data => {
-      if (this.store.currentOrder?.uuid === data.orderUuid) {
+    this.core.effects.on("payment:onPaymentSyncSuccess", async (data) => {
+      var _a;
+      if (((_a = this.store.currentOrder) == null ? void 0 : _a.uuid) === data.orderUuid) {
         await this.handlePaymentSuccess(data);
       }
     });
-
-    // 监听支付失败事件
-    this.core.effects.on('payment:onPaymentSyncError', async data => {
-      if (this.store.currentOrder?.uuid === data.orderUuid) {
+    this.core.effects.on("payment:onPaymentSyncError", async (data) => {
+      var _a;
+      if (((_a = this.store.currentOrder) == null ? void 0 : _a.uuid) === data.orderUuid) {
         await this.handlePaymentError(data);
       }
     });
-
-    // 监听支付方式加载完成事件
-    this.core.effects.on(_types2.PaymentHooks.OnPaymentMethodsLoaded, async methods => {
-      this.store.paymentMethods = methods;
-    });
-
-    // 监听支付方式变更事件
-    this.core.effects.on(_types2.PaymentHooks.OnPaymentMethodsChanged, async data => {
-      this.store.paymentMethods = data.newMethods;
-    });
+    this.core.effects.on(
+      import_types2.PaymentHooks.OnPaymentMethodsLoaded,
+      async (methods) => {
+        console.log("[Checkout] 收到支付方式加载完成事件:", methods.length);
+        this.store.paymentMethods = methods;
+      }
+    );
+    this.core.effects.on(
+      import_types2.PaymentHooks.OnPaymentMethodsChanged,
+      async (data) => {
+        console.log("[Checkout] 收到支付方式变更事件:", {
+          oldCount: data.oldMethods.length,
+          newCount: data.newMethods.length
+        });
+        this.store.paymentMethods = data.newMethods;
+      }
+    );
   }
-
   /**
    * 初始化结账流程
    */
   async initializeCheckoutAsync(params) {
-    this.logInfo('initializeCheckoutAsync called', {
-      cartItemsCount: params.cartItems?.length || 0,
+    var _a;
+    this.logInfo("initializeCheckoutAsync called", {
+      cartItemsCount: ((_a = params.cartItems) == null ? void 0 : _a.length) || 0,
       orderType: params.orderType,
       platform: params.platform
     });
     try {
-      // 验证参数
       const validation = this.validateCheckoutParams(params);
       if (!validation.valid) {
-        throw (0, _utils.createCheckoutError)(_types.CheckoutErrorType.ValidationFailed, `参数验证失败: ${validation.errors.join(', ')}`);
+        throw (0, import_utils.createCheckoutError)(
+          import_types.CheckoutErrorType.ValidationFailed,
+          `参数验证失败: ${validation.errors.join(", ")}`
+        );
       }
-
-      // 保存购物车数据
       this.store.cartItems = params.cartItems;
+      console.log("[Checkout] 结账流程初始化完成");
     } catch (error) {
-      await this.handleError(error, _types.CheckoutErrorType.UnknownError);
+      await this.handleError(error, import_types.CheckoutErrorType.UnknownError);
       throw error;
     }
   }
   getHolderIdFromBooking(obj) {
-    if (!obj) return undefined;
-    let ret = obj.holder_id || obj.holder?.form_record;
+    var _a;
+    if (!obj)
+      return void 0;
+    let ret = obj.holder_id || ((_a = obj.holder) == null ? void 0 : _a.form_record);
     if (Array.isArray(ret)) {
-      return ret.length > 0 ? Number(ret[0]) : undefined;
+      return ret.length > 0 ? Number(ret[0]) : void 0;
     }
-    return Number(ret) || undefined;
+    return Number(ret) || void 0;
   }
   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 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(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 || []);
+    const productList = formatProduct(
+      ((_c = (_b = (_a = this.store.currentOrder.order_info) == null ? void 0 : _a.original_order_data) == null ? void 0 : _b.bookings) == null ? void 0 : _c.map(
+        (item) => {
+          return {
+            ...item.product,
+            holder_id: this.getHolderIdFromBooking(item)
+          };
+        }
+      )) || []
+    );
+    const relationProducts = formatProduct(((_e = (_d = this.store.currentOrder.order_info) == null ? void 0 : _d.original_order_data) == null ? void 0 : _e.relation_products) || []);
     return [...productList, ...relationProducts];
   }
   async initWalletData(params) {
-    this.logInfo('initWalletData called', {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+    this.logInfo("initWalletData called", {
       params
     });
     try {
-      const amountInfo = this.store.currentOrder?.order_info?.amount_breakdown;
+      const amountInfo = (_b = (_a = this.store.currentOrder) == null ? void 0 : _a.order_info) == null ? void 0 : _b.amount_breakdown;
       if (!amountInfo) {
-        this.logInfo('initWalletData amountInfo not found', {
+        this.logInfo("initWalletData amountInfo not found", {
           params
         });
         return;
       }
-      // 准备钱包初始化的业务数据
       const walletBusinessData = {
-        customer_id: this.store.currentCustomer?.customer_id ? Number(this.store.currentCustomer.customer_id) : undefined,
-        holder: this.store.currentOrder?.order_info?.original_order_data?.holder,
+        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,
         amountInfo: {
           totalAmount: amountInfo.totalAmount,
           subTotal: amountInfo.subTotal,
-          depositAmount: this.store.currentOrder?.deposit_amount,
-          isDeposit: this.store.currentOrder?.is_deposit
+          depositAmount: (_g = this.store.currentOrder) == null ? void 0 : _g.deposit_amount,
+          isDeposit: (_h = this.store.currentOrder) == null ? void 0 : _h.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 = this.store.currentOrder?.order_id;
+        walletBusinessData.payment_order_id = (_i = this.store.currentOrder) == null ? void 0 : _i.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: this.store.currentOrder?.uuid,
+        orderUuid: (_j = this.store.currentOrder) == null ? void 0 : _j.uuid,
         customerId: walletBusinessData.customer_id,
         walletBusinessData: {
           customer_id: walletBusinessData.customer_id,
           amountInfo: walletBusinessData.amountInfo,
-          order_wait_pay_amount: params?.order_wait_pay_amount
+          order_wait_pay_amount: params == null ? void 0 : 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;
@@ -367,11 +352,11 @@ class CheckoutImpl extends _BaseModule.BaseModule {
       protocols: [],
       hasDeposit: false
     };
-    bookings?.forEach(item => {
+    bookings == null ? void 0 : bookings.forEach((item) => {
       const total = item.product.calculated_selling_price;
-      const deposit = (0, _utils2.getProductDeposit)({
+      const deposit = (0, import_utils2.getProductDeposit)({
         cartItem: {
-          total: total
+          total
         },
         product: item.product,
         bundle: item.bundle,
@@ -379,14 +364,16 @@ class CheckoutImpl extends _BaseModule.BaseModule {
         num: item.num
       });
       item.deposit = deposit;
-      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();
+      if ((deposit == null ? void 0 : deposit.total) && Number(deposit.total) > 0) {
+        summaryDeposit.protocols = summaryDeposit.protocols.concat(
+          deposit.protocols
+        );
+        summaryDeposit.total = new import_decimal.default(summaryDeposit.total).plus(deposit.total).toNumber();
         summaryDeposit.hasDeposit = true;
       }
     });
-    relationProducts?.forEach(item => {
-      const deposit = (0, _utils2.getProductDeposit)({
+    relationProducts == null ? void 0 : relationProducts.forEach((item) => {
+      const deposit = (0, import_utils2.getProductDeposit)({
         cartItem: {
           total: item.price * item.num
         },
@@ -396,22 +383,20 @@ class CheckoutImpl extends _BaseModule.BaseModule {
         num: item.num
       });
       item.deposit = deposit;
-      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();
+      if ((deposit == null ? void 0 : deposit.total) && Number(deposit.total) > 0) {
+        summaryDeposit.total = new import_decimal.default(summaryDeposit.total).plus(deposit.total).toNumber();
+        item.discount_list.forEach((discount) => {
+          summaryDeposit.total = new import_decimal.default(summaryDeposit.total).minus(discount.amount || 0).toNumber();
         });
-        summaryDeposit.protocols = summaryDeposit.protocols.concat(deposit.protocols);
+        summaryDeposit.protocols = summaryDeposit.protocols.concat(
+          deposit.protocols
+        );
         summaryDeposit.hasDeposit = true;
       }
     });
-
-    // 将总金额四舍五入到两位小数
-    summaryDeposit.total = new _decimal.default(summaryDeposit.total).toDecimalPlaces(2, _decimal.default.ROUND_HALF_UP).toNumber();
+    summaryDeposit.total = new import_decimal.default(summaryDeposit.total).toDecimalPlaces(2, import_decimal.default.ROUND_HALF_UP).toNumber();
     return summaryDeposit;
   }
-
   /**
    * 创建本地订单 (前端模拟下单流程)
    *
@@ -420,72 +405,60 @@ class CheckoutImpl extends _BaseModule.BaseModule {
    * 方法会记录参数并创建本地虚拟订单，然后用 Payment 模块管理支付流程。
    */
   async createLocalOrderAsync(params) {
-    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,
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p;
+    this.logInfo("createLocalOrderAsync called", {
+      orderDataType: (_a = params.orderData) == null ? void 0 : _a.type,
+      platform: (_b = params.orderData) == null ? void 0 : _b.platform,
+      bookingsCount: ((_d = (_c = params.orderData) == null ? void 0 : _c.bookings) == null ? void 0 : _d.length) || 0,
+      relationProductsCount: ((_f = (_e = params.orderData) == null ? void 0 : _e.relation_products) == null ? void 0 : _f.length) || 0,
+      customerId: (_g = params.orderData) == null ? void 0 : _g.customer_id,
       autoPayment: params.autoPayment,
-      cartSummaryCount: params.cartSummary?.length || 0,
+      cartSummaryCount: ((_h = params.cartSummary) == null ? void 0 : _h.length) || 0,
       totalInfoKeys: params.totalInfo ? Object.keys(params.totalInfo) : []
     });
     try {
-      // 🔧 修改：在创建新订单前，直接重置 store 状态（同步执行）
       this.resetStoreState();
-      // 验证订单数据
-      const validation = (0, _utils.validateLocalOrderData)(params.orderData);
+      const validation = (0, import_utils.validateLocalOrderData)(params.orderData);
       if (!validation.valid) {
-        throw (0, _utils.createCheckoutError)(_types.CheckoutErrorType.ValidationFailed, `订单数据验证失败: ${validation.errors.join(', ')}`);
+        throw (0, import_utils.createCheckoutError)(
+          import_types.CheckoutErrorType.ValidationFailed,
+          `订单数据验证失败: ${validation.errors.join(", ")}`
+        );
       }
-
-      // 生成本地虚拟订单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;
-
-      // 保存原始订单数据和小计数据到状态中
+      const localOrderId = (0, import_utils.generateLocalOrderId)();
+      const amountInfo = (0, import_utils.extractAmountFromCartSummary)(params.cartSummary);
+      params.orderData.platform = "pos";
+      params.orderData.created_at = (0, import_utils.formatDateTime)(/* @__PURE__ */ new Date());
+      params.orderData.surcharge_fee = (_j = (_i = params.totalInfo) == null ? void 0 : _i.total) == null ? void 0 : _j.otherAmount;
+      params.orderData.surcharges = (_l = (_k = params.totalInfo) == null ? void 0 : _k.total) == null ? void 0 : _l.surcharge;
+      params.orderData.shop_discount = (_n = (_m = params.totalInfo) == null ? void 0 : _m.total) == null ? void 0 : _n.shopDiscount;
+      params.orderData.tax_fee = (_p = (_o = params.totalInfo) == null ? void 0 : _o.total) == null ? void 0 : _p.tax;
       this.store.localOrderData = params.orderData;
       this.store.cartSummary = params.cartSummary;
-
-      // 提取并保存客户信息（如果有）
       const customerInfo = {
         customer_id: params.orderData.customer_id,
         customer_name: params.orderData.customer_name
       };
-
-      // 只有在有客户信息时才存储
       if (customerInfo.customer_id || customerInfo.customer_name) {
         this.store.currentCustomer = customerInfo;
+        console.log("[Checkout] 保存客户信息:", customerInfo);
       } else {
-        this.store.currentCustomer = undefined;
+        this.store.currentCustomer = void 0;
+        console.log("[Checkout] 未提供客户信息");
       }
-
-      // 计算是否需要支付定金，如果需要默认切换到定金模式，以及记录定金总金额，并把当前默认待付金额调整为定金总金额
-      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: new Date().toISOString(),
+          created_at: (/* @__PURE__ */ new Date()).toISOString(),
           platform: params.orderData.platform,
           type: params.orderData.type,
           schedule_date: params.orderData.schedule_date,
@@ -494,30 +467,21 @@ class CheckoutImpl extends _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,
@@ -528,8 +492,11 @@ class CheckoutImpl extends _BaseModule.BaseModule {
       this.initWalletData();
       return paymentOrder;
     } catch (error) {
-      await this.handleError(error, _types.CheckoutErrorType.OrderCreationFailed);
-      this.logError('本地订单创建失败:', error);
+      await this.handleError(
+        error,
+        import_types.CheckoutErrorType.OrderCreationFailed
+      );
+      this.logError("本地订单创建失败:", error);
       this.core.effects.emit(`${this.name}:onOrderCreationFailed`, {
         error: this.store.lastError,
         timestamp: Date.now()
@@ -537,7 +504,6 @@ class CheckoutImpl extends _BaseModule.BaseModule {
       throw error;
     }
   }
-
   /**
    * 更新本地订单（已同步后端的订单）并设置为当前订单
    *
@@ -545,37 +511,31 @@ class CheckoutImpl extends _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: params.orderData?.type,
-      bookingsCount: params.orderData?.bookings?.length || 0,
-      cartSummaryCount: params.cartSummary?.length || 0,
+      orderDataType: (_a = params.orderData) == null ? void 0 : _a.type,
+      bookingsCount: ((_c = (_b = params.orderData) == null ? void 0 : _b.bookings) == null ? void 0 : _c.length) || 0,
+      cartSummaryCount: ((_d = params.cartSummary) == null ? void 0 : _d.length) || 0,
       totalInfoKeys: params.totalInfo ? Object.keys(params.totalInfo) : []
     });
-
-    // 基础校验
-    const validation = (0, _utils.validateLocalOrderData)(params.orderData);
+    const validation = (0, import_utils.validateLocalOrderData)(params.orderData);
     if (!validation.valid) {
-      throw (0, _utils.createCheckoutError)(_types.CheckoutErrorType.ValidationFailed, `订单数据验证失败: ${validation.errors.join(', ')}`);
+      throw (0, import_utils.createCheckoutError)(
+        import_types.CheckoutErrorType.ValidationFailed,
+        `订单数据验证失败: ${validation.errors.join(", ")}`
+      );
     }
-
-    // 计算金额
-    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;
-
-    // 持久化原始数据
+    const amountInfo = (0, import_utils.extractAmountFromCartSummary)(params.cartSummary);
+    params.orderData.created_at = (0, import_utils.formatDateTime)(/* @__PURE__ */ new Date());
+    params.orderData.platform = "pos";
+    params.orderData.surcharge_fee = (_f = (_e = params.totalInfo) == null ? void 0 : _e.total) == null ? void 0 : _f.otherAmount;
+    params.orderData.surcharges = (_h = (_g = params.totalInfo) == null ? void 0 : _g.total) == null ? void 0 : _h.surcharge;
+    params.orderData.shop_discount = (_j = (_i = params.totalInfo) == null ? void 0 : _i.total) == null ? void 0 : _j.shopDiscount;
+    params.orderData.tax_fee = (_l = (_k = params.totalInfo) == null ? void 0 : _k.total) == null ? void 0 : _l.tax;
     this.store.localOrderData = params.orderData;
     this.store.cartSummary = params.cartSummary;
-
-    // 同步客户信息
     const customerInfo = {
       customer_id: params.orderData.customer_id,
       customer_name: params.orderData.customer_name
@@ -583,49 +543,43 @@ class CheckoutImpl extends _BaseModule.BaseModule {
     if (customerInfo.customer_id || customerInfo.customer_name) {
       this.store.currentCustomer = customerInfo;
     } else {
-      this.store.currentCustomer = undefined;
+      this.store.currentCustomer = void 0;
     }
-
-    // 保留原有支付项：通过 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: existingOrder.payment?.length || 0,
+          existingPaymentCount: ((_m = existingOrder.payment) == null ? void 0 : _m.length) || 0,
           newPaymentCount: params.existPayment.length
         });
-
-        // 标记订单已同步（因为支付项来自云端）
         this.store.isOrderSynced = true;
-
-        // 格式化云端支付项（添加时间戳、标记已同步）
-        const currentTime = (0, _utils.formatDateTime)(new Date());
-        const formattedExistPayments = params.existPayment.map(payment => ({
+        const currentTime = (0, import_utils.formatDateTime)(/* @__PURE__ */ 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 isNeedDeposit = this.checkIsNeedDepositAsync(params.orderData.bookings, params.orderData.relation_products);
-
-        // 更新订单，替换支付项列表
+        const isNeedDeposit3 = this.checkIsNeedDepositAsync(
+          params.orderData.bookings,
+          params.orderData.relation_products
+        );
         await this.payment.updateOrderAsync(existingOrder.uuid, {
           total_amount: amountInfo.totalAmount,
-          is_deposit: isNeedDeposit.hasDeposit ? 1 : 0,
-          deposit_amount: isNeedDeposit.total ? isNeedDeposit.total.toString() : '0.00',
+          is_deposit: isNeedDeposit3.hasDeposit ? 1 : 0,
+          deposit_amount: isNeedDeposit3.total ? isNeedDeposit3.total.toString() : "0.00",
           payment: formattedExistPayments,
           // 🔧 替换支付项列表
           order_info: {
             original_order_data: params.orderData,
             cart_summary: params.cartSummary,
-            created_at: new Date().toISOString(),
+            created_at: (/* @__PURE__ */ new Date()).toISOString(),
             platform: params.orderData.platform,
             type: params.orderData.type,
             schedule_date: params.orderData.schedule_date,
@@ -633,68 +587,70 @@ class CheckoutImpl extends _BaseModule.BaseModule {
             amount_breakdown: amountInfo
           }
         });
-        const updated = await this.payment.getPaymentOrderByUuidAsync(existingOrder.uuid);
-        if (!updated) throw (0, _utils.createCheckoutError)(_types.CheckoutErrorType.UnknownError, '订单更新失败');
-        this.store.currentOrder = updated;
+        const updated2 = await this.payment.getPaymentOrderByUuidAsync(
+          existingOrder.uuid
+        );
+        if (!updated2)
+          throw (0, import_utils.createCheckoutError)(
+            import_types.CheckoutErrorType.UnknownError,
+            "订单更新失败"
+          );
+        this.store.currentOrder = updated2;
         await this.updateStateAmountToRemaining(false);
-        this.logInfo('本地订单更新成功(已替换云端支付项):', {
+        this.logInfo("本地订单更新成功(已替换云端支付项):", {
           orderId: params.orderId,
-          uuid: updated.uuid,
-          payments: updated.payment?.length || 0,
-          totalAmount: updated.total_amount,
-          expectAmount: updated.expect_amount,
+          uuid: updated2.uuid,
+          payments: ((_n = updated2.payment) == null ? void 0 : _n.length) || 0,
+          totalAmount: updated2.total_amount,
+          expectAmount: updated2.expect_amount,
           isOrderSynced: true
         });
-
-        // 事件通知
         await this.core.effects.emit(`${this.name}:onOrderCreated`, {
-          order: updated,
+          order: updated2,
           timestamp: Date.now()
         });
-
-        // 计算已同步的支付金额
-        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();
+        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();
           return sum.plus(amt).plus(rounding);
-        }, 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);
+        }, 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);
         }
         this.initWalletData({
-          order_wait_pay_amount: Number(depositDiffAmount) > 0 ? Number(depositDiffAmount) : Number(remainingExpectAmount)
+          order_wait_pay_amount: Number(depositDiffAmount2) > 0 ? Number(depositDiffAmount2) : Number(remainingExpectAmount2)
         });
-        return updated;
+        return updated2;
       }
-
-      // 原有逻辑：保留现有支付项
-      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 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 paidAmount = activePayments.reduce((sum, p) => {
-        const amt = new _decimal.default(p.amount || '0');
-        const rounding = new _decimal.default(Number(p.rounding_amount) > 0 ? 0 : p.rounding_amount || '0').abs();
+        const amt = new import_decimal.default(p.amount || "0");
+        const rounding = new import_decimal.default(Number(p.rounding_amount) > 0 ? 0 : p.rounding_amount || "0").abs();
         return sum.plus(amt).plus(rounding);
-      }, new _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 列表）
+      }, new import_decimal.default(0));
+      const remaining = import_decimal.default.max(0, totalAmount.minus(paidAmount)).toFixed(
+        2
+      );
+      const isNeedDeposit2 = this.checkIsNeedDepositAsync(
+        params.orderData.bookings,
+        params.orderData.relation_products
+      );
       await this.payment.updateOrderAsync(existingOrder.uuid, {
         total_amount: amountInfo.totalAmount,
-        is_deposit: isNeedDeposit.hasDeposit ? 1 : 0,
-        deposit_amount: isNeedDeposit.total ? isNeedDeposit.total.toString() : '0.00',
+        is_deposit: isNeedDeposit2.hasDeposit ? 1 : 0,
+        deposit_amount: isNeedDeposit2.total ? isNeedDeposit2.total.toString() : "0.00",
         expect_amount: remaining,
         order_info: {
           original_order_data: params.orderData,
           cart_summary: params.cartSummary,
-          created_at: new Date().toISOString(),
+          created_at: (/* @__PURE__ */ new Date()).toISOString(),
           platform: params.orderData.platform,
           type: params.orderData.type,
           schedule_date: params.orderData.schedule_date,
@@ -702,56 +658,59 @@ class CheckoutImpl extends _BaseModule.BaseModule {
           amount_breakdown: amountInfo
         }
       });
-      const updated = await this.payment.getPaymentOrderByUuidAsync(existingOrder.uuid);
-      if (!updated) throw (0, _utils.createCheckoutError)(_types.CheckoutErrorType.UnknownError, '订单更新失败');
+      const updated = await this.payment.getPaymentOrderByUuidAsync(
+        existingOrder.uuid
+      );
+      if (!updated)
+        throw (0, import_utils.createCheckoutError)(
+          import_types.CheckoutErrorType.UnknownError,
+          "订单更新失败"
+        );
       this.store.currentOrder = updated;
       await this.updateStateAmountToRemaining(false);
-      this.logInfo('本地订单更新成功(保留支付项):', {
+      this.logInfo("本地订单更新成功(保留支付项):", {
         orderId: params.orderId,
         uuid: updated.uuid,
-        payments: updated.payment?.length || 0,
+        payments: ((_o = updated.payment) == null ? void 0 : _o.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 _decimal.default(p.amount || '0');
-        const rounding = new _decimal.default(Number(p.rounding_amount) > 0 ? 0 : p.rounding_amount || '0').abs();
+        const amt = new import_decimal.default(p.amount || "0");
+        const rounding = new import_decimal.default(Number(p.rounding_amount) > 0 ? 0 : p.rounding_amount || "0").abs();
         return sum.plus(amt).plus(rounding);
-      }, new _decimal.default(0));
-      const remainingExpectAmount = _decimal.default.max(0, totalAmount.minus(syncedAmount)).toFixed(2);
-      // 要计算一个总价的差值和一个定金的差值，如果定金的差值>0，则需要使用定金的差值，否则使用总价的差值
-      let depositDiffAmount = new _decimal.default(0).toFixed(2);
+      }, new import_decimal.default(0));
+      const remainingExpectAmount = import_decimal.default.max(0, totalAmount.minus(syncedAmount)).toFixed(
+        2
+      );
+      let depositDiffAmount = new import_decimal.default(0).toFixed(2);
       if (updated.is_deposit === 1) {
-        depositDiffAmount = new _decimal.default(updated.deposit_amount).minus(syncedAmount).toFixed(2);
+        depositDiffAmount = new import_decimal.default(updated.deposit_amount).minus(syncedAmount).toFixed(2);
       }
       this.initWalletData({
         order_wait_pay_amount: Number(depositDiffAmount) > 0 ? Number(depositDiffAmount) : Number(remainingExpectAmount)
       });
       return updated;
     }
-    // 计算是否需要支付定金，如果需要默认切换到定金模式，以及记录定金总金额，并把当前默认待付金额调整为定金总金额
-    const isNeedDeposit = this.checkIsNeedDepositAsync(params.orderData.bookings, params.orderData.relation_products);
-
-    // 没找到现有订单时，回退为创建逻辑（用于异常兜底）
+    const 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: new Date().toISOString(),
+        created_at: (/* @__PURE__ */ new Date()).toISOString(),
         platform: params.orderData.platform,
         type: params.orderData.type,
         schedule_date: params.orderData.schedule_date,
@@ -760,20 +719,15 @@ class CheckoutImpl extends _BaseModule.BaseModule {
       }
     });
     this.store.currentOrder = created;
-
-    // 🔧 新增: 如果有云端支付项，需要计算正确的待付金额
-    if (params.existPayment && params.existPayment.length > 0 || this.store.currentOrder?.order_id && !(0, _utils.isVirtualOrderId)(this.store.currentOrder?.order_id)) {
-      // 标记订单已同步（因为订单和支付项都来自云端）
+    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)) {
       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 _decimal.default(p.amount || '0');
-        const rounding = new _decimal.default(Number(p.rounding_amount) > 0 ? 0 : p.rounding_amount || '0').abs();
+        const amt = new import_decimal.default(p.amount || "0");
+        const rounding = new import_decimal.default(Number(p.rounding_amount) > 0 ? 0 : p.rounding_amount || "0").abs();
         return sum.plus(amt).plus(rounding);
-      }, new _decimal.default(0));
-      this.logInfo('云端订单初始化钱包数据', {
+      }, new import_decimal.default(0));
+      this.logInfo("云端订单初始化钱包数据", {
         orderId: params.orderId,
         totalAmount: created.total_amount,
         expectAmount: created.expect_amount,
@@ -781,60 +735,57 @@ class CheckoutImpl extends _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, _utils.createCheckoutError)(_types.CheckoutErrorType.ValidationFailed, '未找到当前订单');
+        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, '订单支付未完成，无法完成结账');
+      const order = await this.payment.getPaymentOrderByUuidAsync(
+        this.store.currentOrder.uuid
+      );
+      if (!order || order.payment_status !== import_types2.PaymentStatus.Finished) {
+        throw (0, import_utils.createCheckoutError)(
+          import_types.CheckoutErrorType.ValidationFailed,
+          "订单支付未完成，无法完成结账"
+        );
       }
-
-      // 清理钱包模块的所有缓存数据
       this.payment.wallet.clearAllCache();
       await this.core.effects.emit(`${this.name}:onCheckoutCompleted`, {
         orderId: order.id,
         timestamp: Date.now()
       });
-      // 🔧 新增：自动重置 store 状态（同步执行）
+      console.log("[Checkout] 结账流程完成:", order.id);
       this.resetStoreState();
       return {
         success: true,
         orderId: String(order.id)
       };
     } catch (error) {
-      await this.handleError(error, _types.CheckoutErrorType.UnknownError);
-      return {
-        success: false
-      };
+      await this.handleError(error, import_types.CheckoutErrorType.UnknownError);
+      return { success: false };
     }
   }
-
   /**
    * 获取订单原始数据
    */
   getOrderOriginalData() {
-    return this.store.currentOrder?.order_info;
+    var _a;
+    return (_a = this.store.currentOrder) == null ? void 0 : _a.order_info;
   }
-
   /**
    * 获取当前订单基础信息
    *
@@ -842,20 +793,15 @@ class CheckoutImpl extends _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 || new Date().toISOString();
-      const orderType = localOrderData?.type || orderInfo.type || 'virtual';
-      const platform = localOrderData?.platform || orderInfo.platform || 'pc';
+      const createdAt = orderInfo.created_at || (/* @__PURE__ */ new Date()).toISOString();
+      const orderType = (localOrderData == null ? void 0 : localOrderData.type) || orderInfo.type || "virtual";
+      const platform = (localOrderData == null ? void 0 : localOrderData.platform) || orderInfo.platform || "pc";
       const result = {
         uuid: currentOrder.uuid,
         orderId: currentOrder.order_id,
@@ -864,19 +810,18 @@ class CheckoutImpl extends _BaseModule.BaseModule {
         paymentStatus: currentOrder.payment_status,
         isDeposit: Boolean(currentOrder.is_deposit),
         depositAmount: currentOrder.deposit_amount,
-        orderType: orderType,
-        platform: platform,
+        orderType,
+        platform,
         createdAt,
         itemCount: cartItems.length,
         hasLocalOrderData: Boolean(localOrderData)
       };
       return result;
     } catch (error) {
-      console.error('[Checkout] 获取当前订单基础信息失败:', error);
+      console.error("[Checkout] 获取当前订单基础信息失败:", error);
       return null;
     }
   }
-
   /**
    * 获取当前订单的支付项
    *
@@ -884,36 +829,32 @@ class CheckoutImpl extends _BaseModule.BaseModule {
    */
   async getCurrentOrderPaymentItemsAsync() {
     try {
-      const {
-        currentOrder
-      } = this.store;
+      const { currentOrder } = this.store;
       if (!currentOrder) {
+        console.log("[Checkout] 当前没有活跃订单，无法获取支付项");
         return [];
       }
-
-      // 调用Payment模块获取支付项
-      const paymentItems = await this.payment.getPaymentItemsAsync(currentOrder.uuid);
+      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
    *
@@ -925,45 +866,43 @@ class CheckoutImpl extends _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
         };
-
-        // 同步更新 Payment 模块 DB，避免后续再次从 DB 读回旧的 payment_status
-        if (latestPaymentStatus) await this.payment.updateOrderAsync(previousOrder.uuid, {
-          payment_status: latestPaymentStatus
-        });
-
-        // 触发订单更新事件
+        if (latestPaymentStatus)
+          await this.payment.updateOrderAsync(previousOrder.uuid, {
+            payment_status: latestPaymentStatus
+          });
         await this.core.effects.emit(`${this.name}:onOrderCreated`, {
           order: updatedOrder,
           timestamp: Date.now()
         });
-        // 标记订单已同步（替换ID意味着订单已在后端创建）
+        console.log("[Checkout] 本地订单ID替换成功:", {
+          uuid: updatedOrder.uuid,
+          newOrderId: updatedOrder.id
+        });
         this.store.isOrderSynced = true;
-
-        // 订单ID替换后更新 stateAmount
         await this.updateStateAmountToRemaining(false);
       }
       return updatedOrder;
     } catch (error) {
-      console.error('[Checkout] 替换订单ID失败:', error);
-      await this.handleError(error, _types.CheckoutErrorType.UnknownError);
+      console.error("[Checkout] 替换订单ID失败:", error);
+      await this.handleError(error, import_types.CheckoutErrorType.UnknownError);
       return null;
     }
   }
-
   /**
    * 设置自定义支付金额
    *
@@ -973,40 +912,35 @@ class CheckoutImpl extends _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), _types.CheckoutErrorType.ValidationFailed);
+      const errorMessage = error instanceof Error ? error.message : "设置支付金额失败";
+      console.error("[Checkout] 设置自定义支付金额失败:", errorMessage);
+      await this.handleError(
+        new Error(errorMessage),
+        import_types.CheckoutErrorType.ValidationFailed
+      );
       throw error;
     }
   }
-
   /**
    * 获取当前自定义支付金额
    *
@@ -1015,7 +949,6 @@ class CheckoutImpl extends _BaseModule.BaseModule {
   getStateAmount() {
     return this.store.stateAmount;
   }
-
   /**
    * 获取系统计算的待付金额（只读）
    *
@@ -1026,7 +959,6 @@ class CheckoutImpl extends _BaseModule.BaseModule {
   getBalanceDueAmount() {
     return this.store.balanceDueAmount;
   }
-
   /**
    * 获取购物车小计数据
    *
@@ -1036,20 +968,19 @@ class CheckoutImpl extends _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];
   }
-
   /**
    * 获取支付方式列表
    *
@@ -1059,26 +990,25 @@ class CheckoutImpl extends _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;
     }
-
-    // 如果缓存为空，调用 Payment 模块获取
-    this.logInfo('store 中无缓存，从 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 [];
     }
   }
-
   /**
    * 为当前订单添加支付项
    *
@@ -1088,16 +1018,14 @@ class CheckoutImpl extends _BaseModule.BaseModule {
    * @throws 当前没有活跃订单时抛出错误
    */
   async addPaymentItemAsync(paymentItem, orderUuid) {
-    this.logInfo('addPaymentItemAsync called', {
-      paymentItem,
-      orderUuid
-    });
-    const isEftposPayment = paymentItem.type?.toLowerCase() === 'eftpos' || paymentItem.code?.toUpperCase().includes('EFTPOS');
+    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"));
     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: this.store.currentOrder?.uuid,
+        currentOrderUuid: (_c = this.store.currentOrder) == null ? void 0 : _c.uuid,
         paymentCode: paymentItem.code,
         paymentType: paymentItem.type
       });
@@ -1107,7 +1035,7 @@ class CheckoutImpl extends _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)
         });
@@ -1115,73 +1043,63 @@ class CheckoutImpl extends _BaseModule.BaseModule {
       return;
     }
     try {
-      // 检查是否有当前订单
       if (!this.store.currentOrder) {
-        throw (0, _utils.createCheckoutError)(_types.CheckoutErrorType.ValidationFailed, '未找到当前订单，无法添加支付项');
+        throw (0, import_utils.createCheckoutError)(
+          import_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 支付');
-        // 检查是否是 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 支付检查:', {
+        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 支付检查:", {
           paymentCode: paymentItem.code,
           paymentType: paymentItem.type,
-          isEftposPayment,
+          isEftposPayment: isEftposPayment2,
           currentOrderSynced: this.store.isOrderSynced
         });
-        if (isEftposPayment || isCash || isCustomePayment) {
-          this.logInfo('检测到 EFTPOS 支付，立即同步订单到后端...');
+        if (isEftposPayment2 || 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)}`), _types.CheckoutErrorType.OrderCreationFailed);
+            this.logError("EFTPOS 支付后订单同步失败:", error);
+            await this.handleError(
+              new Error(
+                `EFTPOS 支付后订单同步失败: ${error instanceof Error ? error.message : String(error)}`
+              ),
+              import_types.CheckoutErrorType.OrderCreationFailed
+            );
           }
         }
       }
-      // 触发支付项添加事件（可以复用支付开始事件）
       this.core.effects.emit(`${this.name}:onPaymentItemAdded`, {
         orderUuid: this.store.currentOrder.uuid,
         paymentMethodCode: paymentItem.code,
@@ -1190,12 +1108,11 @@ class CheckoutImpl extends _BaseModule.BaseModule {
         timestamp: Date.now()
       });
     } catch (error) {
-      this.logError('添加支付项失败:', error);
-      await this.handleError(error, _types.CheckoutErrorType.PaymentFailed);
+      this.logError("添加支付项失败:", error);
+      await this.handleError(error, import_types.CheckoutErrorType.PaymentFailed);
       throw error;
     }
   }
-
   /**
    * 删除当前订单的支付项
    *
@@ -1207,56 +1124,59 @@ class CheckoutImpl extends _BaseModule.BaseModule {
    */
   async deletePaymentItemAsync(paymentUuid) {
     try {
-      // 检查是否有当前订单
       if (!this.store.currentOrder) {
-        throw (0, _utils.createCheckoutError)(_types.CheckoutErrorType.ValidationFailed, '当前没有活跃订单，无法删除支付项');
+        throw (0, import_utils.createCheckoutError)(
+          import_types.CheckoutErrorType.ValidationFailed,
+          "当前没有活跃订单，无法删除支付项"
+        );
       }
-      this.logWarning('开始删除支付项:', {
+      this.logWarning("开始删除支付项:", {
         orderUuid: this.store.currentOrder.uuid,
-        paymentUuid: paymentUuid
+        paymentUuid
       });
-
-      // 从 Payment 模块验证支付项是否存在
-      const currentPayments = await this.payment.getPaymentItemsAsync(this.store.currentOrder.uuid, true // 包括已撤销的支付项，因为我们需要验证是否存在
+      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, _utils.createCheckoutError)(_types.CheckoutErrorType.ValidationFailed, `支付项不存在: ${paymentUuid}`);
+        throw (0, import_utils.createCheckoutError)(
+          import_types.CheckoutErrorType.ValidationFailed,
+          `支付项不存在: ${paymentUuid}`
+        );
       }
-      this.logInfo('找到要删除的支付项:', {
+      this.logInfo("找到要删除的支付项:", {
         uuid: paymentItem.uuid,
         code: paymentItem.code,
         amount: paymentItem.amount,
         status: paymentItem.status
       });
-
-      // 调用 Payment 模块删除支付项
-      await this.payment.deletePaymentAsync(this.store.currentOrder.uuid, paymentUuid);
-      this.logInfo('Payment支付项删除完成', paymentItem);
-
-      // 🚀 清除计算缓存，确保获取最新数据
+      await this.payment.deletePaymentAsync(
+        this.store.currentOrder.uuid,
+        paymentUuid
+      );
+      this.logInfo("Payment支付项删除完成", paymentItem);
       this.clearCalculationCache();
-
-      // 重新从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);
+      const currentOrderId = this.store.currentOrder.order_id;
+      const isCurrentOrderReal = currentOrderId && !(0, import_utils.isVirtualOrderId)(currentOrderId);
+      const updatedOrder = await this.payment.getPaymentOrderByUuidAsync(
+        this.store.currentOrder.uuid
+      );
       if (updatedOrder) {
-        // 如果当前订单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
+        if (isCurrentOrderReal && (0, import_utils.isVirtualOrderId)(updatedOrder.order_id)) {
+          this.logWarning(
+            "[Checkout] deletePaymentItemAsync: 检测到订单ID回退，保护真实订单ID:",
+            {
+              currentRealId: currentOrderId,
+              retrievedVirtualId: updatedOrder.order_id
+            }
+          );
+          updatedOrder.order_id = currentOrderId;
         }
         this.store.currentOrder = updatedOrder;
       }
-
-      // 更新 stateAmount 为剩余未支付金额
       await this.updateStateAmountToRemaining(false);
-
-      // 触发支付项删除事件
       await this.core.effects.emit(`${this.name}:onPaymentStarted`, {
         orderUuid: this.store.currentOrder.uuid,
         paymentMethodCode: paymentItem.code,
@@ -1265,12 +1185,11 @@ class CheckoutImpl extends _BaseModule.BaseModule {
         timestamp: Date.now()
       });
     } catch (error) {
-      this.logError('删除支付项失败:', error);
-      await this.handleError(error, _types.CheckoutErrorType.PaymentFailed);
+      this.logError("删除支付项失败:", error);
+      await this.handleError(error, import_types.CheckoutErrorType.PaymentFailed);
       throw error;
     }
   }
-
   /**
    * 批量更新当前订单的代金券支付项（覆盖更新）
    *
@@ -1283,56 +1202,55 @@ class CheckoutImpl extends _BaseModule.BaseModule {
    */
   async updateVoucherPaymentItemsAsync(voucherPaymentItems) {
     try {
-      this.logInfo('updateVoucherPaymentItemsAsync called:', {
+      this.logInfo("updateVoucherPaymentItemsAsync called:", {
         voucherPaymentItems
       });
-      // 检查是否有当前订单
       if (!this.store.currentOrder) {
-        throw (0, _utils.createCheckoutError)(_types.CheckoutErrorType.ValidationFailed, '当前没有活跃订单，无法更新代金券支付项');
+        throw (0, import_utils.createCheckoutError)(
+          import_types.CheckoutErrorType.ValidationFailed,
+          "当前没有活跃订单，无法更新代金券支付项"
+        );
       }
-
-      // 🔒 防重复操作检查：只有订单已同步且支付完成且所有支付项都已经同步
-      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', {
+      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", {
           voucherPaymentItems,
           savedVoucherPaymentItems
         });
-        if (savedVoucherPaymentItems?.length === 0) {
+        if ((savedVoucherPaymentItems == null ? void 0 : 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 _decimal.default(remainingAmount);
+      const remainingValue = new import_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';
-
-      // 验证所有支付项都包含 voucher_id，并设置 order_payment_type 和 metadata
-      const voucherPaymentItemsWithType = voucherPaymentItems.map(item => {
+      const orderPaymentType = this.store.currentOrder.is_deposit === 1 ? "deposit" : "normal";
+      const voucherPaymentItemsWithType = voucherPaymentItems.map((item) => {
         if (!item.voucher_id) {
-          throw (0, _utils.createCheckoutError)(_types.CheckoutErrorType.ValidationFailed, `代金券支付项缺少 voucher_id: ${JSON.stringify(item)}`);
+          throw (0, import_utils.createCheckoutError)(
+            import_types.CheckoutErrorType.ValidationFailed,
+            `代金券支付项缺少 voucher_id: ${JSON.stringify(item)}`
+          );
         }
-
-        // 从 otherParams 获取 metadata 字段
         const metadata = {
           ...item.metadata,
           rounding_rule: this.otherParams.order_rounding_setting,
@@ -1344,49 +1262,43 @@ class CheckoutImpl extends _BaseModule.BaseModule {
           metadata
         };
       });
-
-      // 调用 Payment 模块的批量更新方法
-      await this.payment.updateVoucherPaymentItemsAsync(this.store.currentOrder.uuid, voucherPaymentItemsWithType);
-
-      // 🚀 清除计算缓存，确保获取最新数据
+      await this.payment.updateVoucherPaymentItemsAsync(
+        this.store.currentOrder.uuid,
+        voucherPaymentItemsWithType
+      );
       this.clearCalculationCache();
-
-      // 重新从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);
+      const currentOrderId = this.store.currentOrder.order_id;
+      const isCurrentOrderReal = currentOrderId && !(0, import_utils.isVirtualOrderId)(currentOrderId);
+      const updatedOrder = await this.payment.getPaymentOrderByUuidAsync(
+        this.store.currentOrder.uuid
+      );
       if (updatedOrder) {
-        // 如果当前订单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
+        if (isCurrentOrderReal && (0, import_utils.isVirtualOrderId)(updatedOrder.order_id)) {
+          this.logWarning(
+            "updateVoucherPaymentItemsAsync: 检测到订单ID回退，保护真实订单ID:",
+            {
+              currentRealId: currentOrderId,
+              retrievedVirtualId: updatedOrder.order_id
+            }
+          );
+          updatedOrder.order_id = currentOrderId;
         }
         this.store.currentOrder = updatedOrder;
       }
-
-      // 更新 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, _types.CheckoutErrorType.PaymentFailed);
+      this.logInfo("[Checkout] 批量更新代金券支付项失败:", { error });
+      await this.handleError(error, import_types.CheckoutErrorType.PaymentFailed);
       throw error;
     }
   }
-
   /**
    * 修改当前订单的定金状态
    *
@@ -1397,77 +1309,62 @@ class CheckoutImpl extends _BaseModule.BaseModule {
    */
   async updateOrderDepositStatusAsync(isDeposit) {
     try {
-      // 验证参数
       if (isDeposit !== 0 && isDeposit !== 1) {
-        throw (0, _utils.createCheckoutError)(_types.CheckoutErrorType.ValidationFailed, 'isDeposit 参数只能是 0（全款订单）或 1（定金订单）');
+        throw (0, import_utils.createCheckoutError)(
+          import_types.CheckoutErrorType.ValidationFailed,
+          "isDeposit 参数只能是 0（全款订单）或 1（定金订单）"
+        );
       }
-
-      // 检查是否有当前订单
       if (!this.store.currentOrder) {
-        throw (0, _utils.createCheckoutError)(_types.CheckoutErrorType.ValidationFailed, '未找到当前订单，无法修改定金状态');
+        throw (0, import_utils.createCheckoutError)(
+          import_types.CheckoutErrorType.ValidationFailed,
+          "未找到当前订单，无法修改定金状态"
+        );
       }
       const newDepositValue = isDeposit;
       const oldDepositValue = this.store.currentOrder.is_deposit;
-
-      // 如果状态没有变化，直接返回
       if (oldDepositValue === newDepositValue) {
+        console.log("[Checkout] 定金状态无变化，跳过更新");
         return;
       }
-      let deposit_amount = this.store.currentOrder.deposit_amount || '0.00';
-      // 如果原来没有 deposit_amount，则默认把待付金额置为 deposit_amount
+      let deposit_amount = this.store.currentOrder.deposit_amount || "0.00";
       if (!deposit_amount || Number(deposit_amount) === 0) {
         deposit_amount = this.store.currentOrder.expect_amount;
       }
-
-      // 准备更新参数
       const updateParams = {
         is_deposit: newDepositValue,
-        deposit_amount: deposit_amount
+        deposit_amount
       };
-
-      // 如果从定金改为全款，可以清空定金金额
-      // 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);
-
-      // 更新本地缓存的订单对象
+      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, _types.CheckoutErrorType.ValidationFailed);
+      this.logError("更新订单定金状态失败:", error);
+      await this.handleError(
+        error,
+        import_types.CheckoutErrorType.ValidationFailed
+      );
       throw error;
     }
   }
-
   /**
    * 手动设置当前订单的定金金额
    *
@@ -1478,89 +1375,76 @@ class CheckoutImpl extends _BaseModule.BaseModule {
    * @throws 定金金额格式无效或超过订单总额时抛出错误
    */
   async setDepositAmountAsync(depositAmount) {
-    this.logInfo('setDepositAmountAsync called', {
+    var _a, _b;
+    this.logInfo("setDepositAmountAsync called", {
       depositAmount,
       hasCurrentOrder: !!this.store.currentOrder,
-      currentOrderId: this.store.currentOrder?.order_id,
-      currentTotalAmount: this.store.currentOrder?.total_amount
+      currentOrderId: (_a = this.store.currentOrder) == null ? void 0 : _a.order_id,
+      currentTotalAmount: (_b = this.store.currentOrder) == null ? void 0 : _b.total_amount
     });
     try {
-      // 验证定金金额格式
-      const depositValue = new _decimal.default(depositAmount);
+      const depositValue = new import_decimal.default(depositAmount);
       if (depositValue.isNaN() || depositValue.lt(0)) {
-        throw (0, _utils.createCheckoutError)(_types.CheckoutErrorType.ValidationFailed, `无效的定金金额格式: ${depositAmount}`);
+        throw (0, import_utils.createCheckoutError)(
+          import_types.CheckoutErrorType.ValidationFailed,
+          `无效的定金金额格式: ${depositAmount}`
+        );
       }
-
-      // 检查是否有当前订单
       if (!this.store.currentOrder) {
-        throw (0, _utils.createCheckoutError)(_types.CheckoutErrorType.ValidationFailed, '未找到当前订单，无法设置定金金额');
+        throw (0, import_utils.createCheckoutError)(
+          import_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，自动设置为定金订单');
-      }
-      // 如果设置的定金金额为0，可以考虑将订单标记为全款订单
-      else if (depositValue.eq(0) && this.store.currentOrder.is_deposit === 1) {
+        this.logInfo("定金金额大于0，自动设置为定金订单");
+      } else if (depositValue.eq(0) && this.store.currentOrder.is_deposit === 1) {
         updateParams.is_deposit = 0;
-        this.logInfo('定金金额为0，自动设置为全款订单');
+        this.logInfo("定金金额为0，自动设置为全款订单");
       }
-
-      // 调用 Payment 模块更新订单
-      await this.payment.updateOrderAsync(this.store.currentOrder.uuid, updateParams);
-
-      // 更新本地缓存的订单对象
+      await this.payment.updateOrderAsync(
+        this.store.currentOrder.uuid,
+        updateParams
+      );
       this.store.currentOrder = {
         ...this.store.currentOrder,
         ...updateParams
       };
-
-      // 同时更新本地订单数据（如果存在）
       if (this.store.localOrderData) {
-        // 注意：本地订单数据中没有deposit_amount字段，但如果需要可以在这里添加
-        if ('deposit_amount' in this.store.localOrderData) {
+        if ("deposit_amount" in this.store.localOrderData) {
           this.store.localOrderData.deposit_amount = formattedDepositAmount;
         }
-        // 同步更新 is_deposit 状态（如果有变化）
-        if (updateParams.is_deposit !== undefined) {
+        if (updateParams.is_deposit !== void 0) {
           this.store.localOrderData.is_deposit = updateParams.is_deposit;
         }
       }
-
-      // 🚀 清除计算缓存，确保获取最新数据
       this.clearCalculationCache();
       this.updateStateAmountToRemaining(false);
-
-      // 触发订单更新事件
       await this.core.effects.emit(`${this.name}:onOrderCreated`, {
         order: this.store.currentOrder,
         timestamp: Date.now()
       });
-      this.logInfo('订单定金金额设置成功:', {
+      this.logInfo("订单定金金额设置成功:", {
         orderUuid: this.store.currentOrder.uuid,
         orderId: this.store.currentOrder.order_id,
         oldDepositAmount,
@@ -1569,83 +1453,84 @@ class CheckoutImpl extends _BaseModule.BaseModule {
         totalAmount: this.store.currentOrder.total_amount
       });
     } catch (error) {
-      this.logError('设置订单定金金额失败:', error);
-      await this.handleError(error, _types.CheckoutErrorType.ValidationFailed);
+      this.logError("设置订单定金金额失败:", error);
+      await this.handleError(
+        error,
+        import_types.CheckoutErrorType.ValidationFailed
+      );
       throw error;
     }
   }
-
   /**
    * 手动同步订单到后端
    *
    * 用于强制同步订单到后端，特别适用于纯代金券支付完成的订单
    */
   async manualSyncOrderAsync() {
-    this.logInfo('manualSyncOrderAsync called', {
+    var _a, _b, _c, _d, _e;
+    console.log("manualSyncOrderAsync called");
+    this.logInfo("manualSyncOrderAsync called", {
       hasCurrentOrder: !!this.store.currentOrder,
-      currentOrderId: this.store.currentOrder?.order_id,
-      orderUuid: this.store.currentOrder?.uuid,
-      totalAmount: this.store.currentOrder?.total_amount,
+      currentOrderId: (_a = this.store.currentOrder) == null ? void 0 : _a.order_id,
+      orderUuid: (_b = this.store.currentOrder) == null ? void 0 : _b.uuid,
+      totalAmount: (_c = this.store.currentOrder) == null ? void 0 : _c.total_amount,
       isOrderSynced: this.store.isOrderSynced,
-      isVirtualOrderId: this.store.currentOrder ? (0, _utils.isVirtualOrderId)(this.store.currentOrder.order_id) : false
+      isVirtualOrderId: this.store.currentOrder ? (0, import_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: orderUuid,
+      this.logInfo("开始手动同步订单到后端:", {
+        orderUuid,
         orderId: oldOrderId,
         totalAmount: this.store.currentOrder.total_amount,
         remainingAmount: await this.calculateRemainingAmountAsync()
       });
-      // 强制同步订单到后端，并获取完整响应数据
+      console.time("manualSyncOrderAsync");
       const syncResult = await this.syncOrderToBackendWithReturn(true);
-      this.logInfo('手动同步订单完成:', {
-        orderUuid: orderUuid,
-        syncResult: syncResult,
-        oldOrderId: oldOrderId,
+      console.timeEnd("manualSyncOrderAsync");
+      this.logInfo("手动同步订单完成:", {
+        orderUuid,
+        syncResult,
+        oldOrderId,
         realOrderId: syncResult.orderId,
         isOrderSynced: this.store.isOrderSynced
       });
-
-      // 🔍 关键验证：检查最终状态是否正确
       const finalOrderId = this.store.currentOrder.order_id;
-      const finalIsVirtual = (0, _utils.isVirtualOrderId)(finalOrderId);
+      const finalIsVirtual = (0, import_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: this.store.currentOrder?.is_deposit || 0
+        is_deposit: ((_d = this.store.currentOrder) == null ? void 0 : _d.is_deposit) || 0
       };
       await this.updateStateAmountToRemaining(false);
       return newRes;
     } catch (error) {
-      this.logError('手动同步订单失败:', error);
-      const errorMessage = error instanceof Error ? error.message : '同步失败';
+      this.logError("手动同步订单失败:", error);
+      const errorMessage = error instanceof Error ? error.message : "同步失败";
       return {
         success: false,
         message: `订单同步失败: ${errorMessage}`,
-        orderUuid: this.store.currentOrder?.uuid
+        orderUuid: (_e = this.store.currentOrder) == null ? void 0 : _e.uuid
       };
     }
   }
-
   /**
    * 获取当前订单备注
    *
@@ -1653,11 +1538,11 @@ class CheckoutImpl extends _BaseModule.BaseModule {
    */
   getOrderNote() {
     if (!this.store.localOrderData) {
-      return '';
+      console.log("[Checkout] 没有本地订单数据，无法获取备注");
+      return "";
     }
-    return this.store.localOrderData.shop_note || '';
+    return this.store.localOrderData.shop_note || "";
   }
-
   /**
    * 获取当前订单ID
    *
@@ -1669,21 +1554,24 @@ class CheckoutImpl extends _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;
   }
-
   /**
    * 取消当前本地订单
    *
@@ -1693,92 +1581,81 @@ class CheckoutImpl extends _BaseModule.BaseModule {
    * @returns 取消结果
    */
   async cancelCurrentOrderAsync(cancelReason) {
+    var _a, _b;
     try {
-      this.logInfo('开始取消当前本地订单:', {
+      this.logInfo("开始取消当前本地订单:", {
         hasCurrentOrder: !!this.store.currentOrder,
-        orderUuid: this.store.currentOrder?.uuid,
-        orderId: this.store.currentOrder?.order_id,
+        orderUuid: (_a = this.store.currentOrder) == null ? void 0 : _a.uuid,
+        orderId: (_b = this.store.currentOrder) == null ? void 0 : _b.order_id,
         isOrderSynced: this.store.isOrderSynced,
-        cancelReason: 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: _types2.PaymentStatus.Voided
+          payment_status: import_types2.PaymentStatus.Voided
         });
-        this.logInfo('本地订单删除标记成功');
+        this.logInfo("本地订单删除标记成功");
       } catch (error) {
-        this.logWarning('标记本地订单删除失败，但继续执行:', error);
+        this.logWarning("标记本地订单删除失败，但继续执行:", error);
       }
-
-      // 清理订单相关状态，确保正确释放 currentOrder
-      this.logInfo('清理订单相关状态');
-      this.store.currentOrder = undefined; // 释放 currentOrder
-      this.store.localOrderData = undefined;
-      this.store.stateAmount = '0.00';
-      this.store.balanceDueAmount = '0.00';
+      this.logInfo("清理订单相关状态");
+      this.store.currentOrder = void 0;
+      this.store.localOrderData = void 0;
+      this.store.stateAmount = "0.00";
+      this.store.balanceDueAmount = "0.00";
       this.store.isOrderSynced = false;
-      this.store.currentCustomer = undefined;
-
-      // 清理钱包缓存
+      this.store.currentCustomer = void 0;
       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}`
       };
     }
   }
-
   /**
    * 保存订单并稍后支付
    *
@@ -1786,149 +1663,163 @@ class CheckoutImpl extends _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: orderUuid,
+      this.logInfo("开始保存订单并稍后支付:", {
+        orderUuid,
         orderId: currentOrderId,
         totalAmount: this.store.currentOrder.total_amount
       });
-
-      // 获取当前订单的所有支付项
-      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,
+      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,
         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: this.store.currentOrder?.uuid
+        orderUuid: (_a = this.store.currentOrder) == null ? void 0 : _a.uuid
       };
     }
   }
-
   /**
    * 更新订单备注
    *
    * @param note 订单备注内容
    */
   async updateOrderNoteAsync(note) {
+    var _a, _b;
     try {
-      // 检查是否有本地订单数据
       if (!this.store.localOrderData) {
-        throw (0, _utils.createCheckoutError)(_types.CheckoutErrorType.ValidationFailed, '没有本地订单数据，无法更新备注');
+        throw (0, import_utils.createCheckoutError)(
+          import_types.CheckoutErrorType.ValidationFailed,
+          "没有本地订单数据，无法更新备注"
+        );
       }
-      // 更新备注
+      console.log("[Checkout] 更新订单备注:", {
+        orderUuid: (_a = this.store.currentOrder) == null ? void 0 : _a.uuid,
+        oldNote: this.store.localOrderData.shop_note,
+        newNote: note
+      });
       const oldNote = this.store.localOrderData.shop_note;
       this.store.localOrderData.shop_note = note;
-
-      // 如果有当前订单，也同步到Payment模块中的订单数据
       if (this.store.currentOrder) {
-        // 更新Payment模块中的订单数据（如果订单对象中有note字段）
         try {
-          const orderInPayment = await this.payment.getPaymentOrderByUuidAsync(this.store.currentOrder.uuid);
-          if (orderInPayment && orderInPayment.note !== undefined) {}
+          const orderInPayment = await this.payment.getPaymentOrderByUuidAsync(
+            this.store.currentOrder.uuid
+          );
+          if (orderInPayment && orderInPayment.note !== void 0) {
+            console.log("[Checkout] 同步备注到Payment模块的订单数据中");
+          }
         } catch (syncError) {
-          console.warn('[Checkout] 同步备注到Payment模块失败，但本地更新成功:', syncError);
+          console.warn(
+            "[Checkout] 同步备注到Payment模块失败，但本地更新成功:",
+            syncError
+          );
         }
       }
-
-      // 触发订单数据变更事件
       await this.core.effects.emit(`${this.name}:onOrderNoteChanged`, {
-        orderUuid: this.store.currentOrder?.uuid,
+        orderUuid: (_b = this.store.currentOrder) == null ? void 0 : _b.uuid,
         oldNote,
         newNote: note,
         timestamp: Date.now()
       });
+      console.log("[Checkout] 订单备注更新成功:", {
+        oldNote,
+        newNote: note
+      });
     } catch (error) {
-      console.error('[Checkout] 更新订单备注失败:', error);
-      await this.handleError(error, _types.CheckoutErrorType.ValidationFailed);
+      console.error("[Checkout] 更新订单备注失败:", error);
+      await this.handleError(
+        error,
+        import_types.CheckoutErrorType.ValidationFailed
+      );
       throw error;
     }
   }
-
   /**
    * 处理错误
    */
   async handleError(error, type) {
-    const checkoutError = error instanceof Error && 'type' in error ? error : (0, _utils.createCheckoutError)(type, error.message, error);
+    const checkoutError = error instanceof Error && "type" in error ? error : (0, import_utils.createCheckoutError)(type, error.message, error);
     this.store.lastError = checkoutError;
     await this.core.effects.emit(`${this.name}:onError`, {
       error: checkoutError,
       context: {},
       timestamp: Date.now()
     });
-    console.error('[Checkout] 错误:', checkoutError);
+    console.error("[Checkout] 错误:", checkoutError);
   }
-
   /**
    * 处理支付成功
    */
   async handlePaymentSuccess(data) {
-    // 支付状态变更后更新 stateAmount
+    var _a;
     await this.updateStateAmountToRemaining();
     await this.core.effects.emit(`${this.name}:onPaymentSuccess`, {
       orderUuid: data.orderUuid,
-      paymentMethodCode: '',
-      amount: this.store.currentOrder?.total_amount || '0',
+      paymentMethodCode: "",
+      amount: ((_a = this.store.currentOrder) == null ? void 0 : _a.total_amount) || "0",
       timestamp: data.timestamp
     });
-
-    // 自动完成结账
     await this.completeCheckoutAsync();
   }
-
   /**
    * 处理支付错误
    */
   async handlePaymentError(data) {
-    const error = (0, _utils.createCheckoutError)(_types.CheckoutErrorType.PaymentFailed, data.error || '支付同步失败');
-    await this.handleError(error instanceof Error ? error : new Error(String(error)), _types.CheckoutErrorType.PaymentFailed);
+    var _a;
+    const error = (0, import_utils.createCheckoutError)(
+      import_types.CheckoutErrorType.PaymentFailed,
+      data.error || "支付同步失败"
+    );
+    await this.handleError(
+      error instanceof Error ? error : new Error(String(error)),
+      import_types.CheckoutErrorType.PaymentFailed
+    );
     await this.core.effects.emit(`${this.name}:onPaymentFailed`, {
       orderUuid: data.orderUuid,
-      paymentMethodCode: '',
-      amount: this.store.currentOrder?.total_amount || '0',
+      paymentMethodCode: "",
+      amount: ((_a = this.store.currentOrder) == null ? void 0 : _a.total_amount) || "0",
       timestamp: data.timestamp
     });
   }
-
   /**
    * 验证结账参数
    */
   validateCheckoutParams(params) {
-    return (0, _utils.validateCheckoutData)(params);
+    return (0, import_utils.validateCheckoutData)(params);
   }
-
   /**
    * 处理现金支付项的找零逻辑
    *
@@ -1936,51 +1827,40 @@ class CheckoutImpl extends _BaseModule.BaseModule {
    * @returns 处理后的支付项（包含找零信息）
    */
   async processCashPaymentItem(paymentItem) {
-    // 检查是否是现金支付
-    const cashPayment = (0, _utils.isCashPayment)(paymentItem);
+    const cashPayment = (0, import_utils.isCashPayment)(paymentItem);
     if (!cashPayment) {
-      // 非现金支付，直接返回原始支付项
       return paymentItem;
     }
     try {
-      // 获取剩余待付金额
       const remainingAmountStr = await this.calculateRemainingAmountAsync();
-      let remainingAmount = new _decimal.default(remainingAmountStr);
-      const cashAmount = new _decimal.default(String(paymentItem.amount));
-
-      // 如果现金金额小于等于剩余待付金额，无需找零
+      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"));
       if (cashAmount.lte(remainingAmount)) {
         return paymentItem;
       }
-
-      // 使用 Decimal.js 安全计算找零金额
-      const changeAmount = cashAmount.sub(remainingAmount);
-
-      // 如果还有 rounding_amount 的配置，要判断是否和 changeAmount 相等
-      if (Number(paymentItem.rounding_amount) > 0) {
-        if (Number(paymentItem.rounding_amount) === changeAmount.toNumber()) {
-          return paymentItem;
-        } else {
-          // 如果不等于，则remainingAmount需要加上 rounding_amount，避免这里被改为未舍入金额
-          remainingAmount = remainingAmount.add(new _decimal.default(paymentItem.rounding_amount || '0'));
-        }
+      const chargeAmount = import_decimal.default.max(
+        remainingAmount.add(roundingAmount),
+        new import_decimal.default(0)
+      );
+      if (cashAmount.lte(chargeAmount)) {
+        return paymentItem;
       }
-
-      // 创建包含找零信息的支付项
+      const changeAmount = cashAmount.sub(chargeAmount);
       const processedPaymentItem = {
         ...paymentItem,
-        amount: remainingAmount.toFixed(2),
-        // 将 amount 设置为剩余待付金额，保留2位小数
+        amount: chargeAmount.toFixed(2),
         metadata: {
           ...paymentItem.metadata,
           actual_paid_amount: cashAmount.toNumber(),
-          // 实付金额
-          change_given_amount: changeAmount.toNumber() // 找零金额
+          change_given_amount: changeAmount.toNumber()
         }
       };
-      this.logInfo('Cash payment with change processed', {
+      this.logInfo("Cash payment with change processed", {
         originalAmount: cashAmount.toFixed(2),
-        chargedAmount: remainingAmount.toFixed(2),
+        remainingAmount: remainingAmount.toFixed(2),
+        roundingAmount: roundingAmount.toFixed(2),
+        chargedAmount: chargeAmount.toFixed(2),
         changeAmount: changeAmount.toFixed(2),
         paymentCode: paymentItem.code,
         paymentType: paymentItem.type,
@@ -1988,87 +1868,85 @@ class CheckoutImpl extends _BaseModule.BaseModule {
         decimalPrecisionCheck: {
           cashAmountPrecise: cashAmount.toString(),
           remainingAmountPrecise: remainingAmount.toString(),
+          roundingAmountPrecise: roundingAmount.toString(),
+          chargeAmountPrecise: chargeAmount.toString(),
           changeAmountPrecise: changeAmount.toString()
         }
       });
       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 = [];
     }
   }
-
   /**
    * 清理过期的已同步订单数据
    *
    * 删除本地 IndexDB 中超过指定天数且已同步到后端的订单数据
    */
+  /** @deprecated */
   async cleanupExpiredOrdersAsync() {
+    var _a, _b, _c;
     try {
-      // 检查是否启用了清理功能
       const cleanupConfig = this.otherParams.orderDataCleanup || {};
-      const isCleanupEnabled = cleanupConfig.enabled !== false; // 默认启用
-      const retentionDays = cleanupConfig.retentionDays || 7; // 默认保留7天
-      const maxOrdersToDelete = cleanupConfig.maxOrdersToDelete || 100; // 默认最多删除100个订单
-
+      const isCleanupEnabled = cleanupConfig.enabled !== false;
+      const retentionDays = cleanupConfig.retentionDays || 7;
+      const maxOrdersToDelete = cleanupConfig.maxOrdersToDelete || 100;
       if (!isCleanupEnabled) {
+        console.log("[Checkout] 订单数据清理功能已禁用");
         return;
       }
-      // 获取所有订单
+      console.log(
+        `[Checkout] 开始清理过期订单数据（保留 ${retentionDays} 天内的数据）...`
+      );
       const allOrders = await this.payment.getOrderListAsync();
       if (!allOrders || allOrders.length === 0) {
+        console.log("[Checkout] 没有找到需要清理的订单数据");
         return;
       }
-      const thresholdDate = new Date();
+      const thresholdDate = /* @__PURE__ */ new Date();
       thresholdDate.setDate(thresholdDate.getDate() - retentionDays);
       let deletedCount = 0;
       const ordersToDelete = [];
       for (const order of allOrders) {
         try {
-          // 检查订单是否已同步（订单ID不是虚拟ID）
-          const isSynced = order.order_id && !(0, _utils.isVirtualOrderId)(order.order_id);
+          const isSynced = order.order_id && !(0, import_utils.isVirtualOrderId)(order.order_id);
           if (!isSynced) {
-            continue; // 跳过未同步的订单
+            continue;
           }
-
-          // 检查创建时间
           let orderCreatedAt = null;
-
-          // 尝试从 order_info.created_at 获取创建时间
-          if (order.order_info?.created_at) {
+          if ((_a = order.order_info) == null ? void 0 : _a.created_at) {
             orderCreatedAt = new Date(order.order_info.created_at);
+          } else if ((_c = (_b = order.order_info) == null ? void 0 : _b.original_order_data) == null ? void 0 : _c.created_at) {
+            orderCreatedAt = new Date(
+              order.order_info.original_order_data.created_at
+            );
           }
-          // 如果没有，尝试从 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()) / (1000 * 60 * 60 * 24))
+              daysSinceCreated: Math.floor(
+                (Date.now() - orderCreatedAt.getTime()) / (1e3 * 60 * 60 * 24)
+              )
             });
           }
         } catch (error) {
@@ -2076,16 +1954,17 @@ class CheckoutImpl extends _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);
         }
@@ -2093,93 +1972,76 @@ class CheckoutImpl extends _BaseModule.BaseModule {
       const summary = {
         totalOrders: allOrders.length,
         expiredSyncedOrders: ordersToDelete.length,
-        maxOrdersToDelete: maxOrdersToDelete,
+        maxOrdersToDelete,
         actualDeletedOrders: deletedCount,
-        retentionDays: retentionDays,
-        cleanupDate: new Date().toISOString(),
+        retentionDays,
+        cleanupDate: (/* @__PURE__ */ new Date()).toISOString(),
         thresholdDate: thresholdDate.toISOString(),
         skippedOrders: Math.max(0, ordersToDelete.length - maxOrdersToDelete)
       };
-
-      // 记录清理结果
-      this.logInfo('Expired orders cleanup completed', summary);
-      if (ordersToDelete.length > maxOrdersToDelete) {} else {}
+      this.logInfo("Expired orders cleanup completed", summary);
+      if (ordersToDelete.length > maxOrdersToDelete) {
+        console.log(
+          `[Checkout] 过期订单清理完成: 总计 ${allOrders.length} 个订单，发现 ${ordersToDelete.length} 个过期已同步订单，删除了 ${deletedCount} 个（限制为 ${maxOrdersToDelete} 个）`
+        );
+      } else {
+        console.log(
+          `[Checkout] 过期订单清理完成: 总计 ${allOrders.length} 个订单，删除了 ${deletedCount} 个过期已同步订单`
+        );
+      }
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      console.error('[Checkout] 清理过期订单数据失败:', error);
-      this.logError('Expired orders cleanup failed', {
-        error: errorMessage
-      });
+      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 < 5000;
+    const cacheValid = this.calculationCache.orderUuid === orderUuid && this.calculationCache.timestamp && now - this.calculationCache.timestamp < 5e3;
     if (cacheValid && this.calculationCache.paymentItems && this.calculationCache.currentOrder) {
-      // 使用缓存
       return {
         paymentItems: this.calculationCache.paymentItems,
         currentOrder: this.calculationCache.currentOrder
       };
     }
-
-    // 并行获取数据，减少等待时间
-    const [paymentItems, currentOrder] = await Promise.all([this.payment.getPaymentItemsAsync(orderUuid, false), this.payment.getPaymentOrderByUuidAsync(orderUuid)]);
-
-    // 更新缓存
+    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) {
-    // 使用 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 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);
       const effectiveAmount = paymentAmount.minus(roundingAmount);
       return sum.add(effectiveAmount);
-    }, new _decimal.default(0));
+    }, new import_decimal.default(0));
     return paidAmount.toFixed(2);
   }
-
   /**
    * 计算已支付金额（从 Payment 模块获取最新数据）
    *
@@ -2188,63 +2050,50 @@ class CheckoutImpl extends _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 < 5000 && this.calculationCache.paidAmount;
+      const cacheValid = this.calculationCache.orderUuid === this.store.currentOrder.uuid && this.calculationCache.timestamp && now - this.calculationCache.timestamp < 5e3 && this.calculationCache.paidAmount;
       if (cacheValid && this.calculationCache.paidAmount) {
         return this.calculationCache.paidAmount;
       }
-
-      // 从 Payment 模块获取最新的支付项数据
-      const payments = await this.payment.getPaymentItemsAsync(this.store.currentOrder.uuid, false // 不包括已撤销的支付项
+      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) {
-    // 使用 Decimal.js 进行安全的金额计算
-    let totalAmount = new _decimal.default(currentOrder.total_amount || '0');
-
-    // 如果是定金订单，使用定金金额
+    let totalAmount = new import_decimal.default(currentOrder.total_amount || "0");
     if (currentOrder.is_deposit && currentOrder.deposit_amount && Number(currentOrder.deposit_amount) > 0) {
-      totalAmount = new _decimal.default(currentOrder.deposit_amount);
+      totalAmount = new import_decimal.default(currentOrder.deposit_amount);
     }
-    const paid = new _decimal.default(paidAmount);
+    const paid = new import_decimal.default(paidAmount);
     const remainingAmount = totalAmount.sub(paid);
-
-    // 确保剩余金额不为负数
-    return _decimal.default.max(0, remainingAmount).toFixed(2);
+    return import_decimal.default.max(0, remainingAmount).toFixed(2);
   }
-
   /**
    * 从订单和支付项计算剩余总金额（纯计算，排除定金）
    */
   calculateRemainingTotalAmountFromData(currentOrder, paidAmount) {
-    // 始终使用订单总金额，不进行定金相关的计算
-    const totalAmount = new _decimal.default(currentOrder.total_amount || '0');
-    const paid = new _decimal.default(paidAmount);
+    const totalAmount = new import_decimal.default(currentOrder.total_amount || "0");
+    const paid = new import_decimal.default(paidAmount);
     const remainingAmount = totalAmount.sub(paid);
-
-    // 确保剩余金额不为负数
-    return _decimal.default.max(0, remainingAmount).toFixed(2);
+    return import_decimal.default.max(0, remainingAmount).toFixed(2);
   }
-
   /**
    * 计算剩余未支付金额（从 Payment 模块获取最新数据）
    *
@@ -2253,23 +2102,18 @@ class CheckoutImpl extends _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;
   }
-
   /**
    * 计算剩余未支付金额（排除定金计算，始终使用订单总金额）
    *
@@ -2278,23 +2122,18 @@ class CheckoutImpl extends _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 为当前剩余未支付金额（系统内部计算）
    */
@@ -2303,33 +2142,28 @@ class CheckoutImpl extends _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 为当前剩余未支付金额
    *
@@ -2340,51 +2174,37 @@ class CheckoutImpl extends _BaseModule.BaseModule {
       if (!this.store.currentOrder) {
         return;
       }
-      // 🚀 性能优化：一次性批量获取所有需要的数据
-      const {
-        paymentItems,
-        currentOrder
-      } = await this.fetchOrderDataBatch();
+      console.time("updateStateAmountToRemaining");
+      const { paymentItems, currentOrder } = await this.fetchOrderDataBatch();
+      console.timeEnd("updateStateAmountToRemaining");
       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) => {
-          // 如果是 wallet，并且还没同步到后端，且此时还没有其他类型的支付项（现金，eftpos，标记支付）,不计入已付金额
-          // 如果有其他支付项了，代表此时处于马上要同步的状态，所以计入
-          if (item.voucher_id && !item.isSynced && paymentItems.filter(item => !item.voucher_id).length === 0) {
+        const depositPaidAmount = paymentItems.filter(
+          (item) => item.order_payment_type === "deposit" && item.status !== "voided"
+        ).reduce((sum, item) => {
+          if (item.voucher_id && !item.isSynced && paymentItems.filter((item2) => !item2.voucher_id).length === 0) {
             return sum;
           }
-          const amount = new _decimal.default(item.amount || '0');
-          const roundingAmount = new _decimal.default(item.rounding_amount || '0');
+          const amount = new import_decimal.default(item.amount || "0");
+          const roundingAmount = new import_decimal.default(item.rounding_amount || "0");
           return sum.add(amount.add(roundingAmount.isNegative() ? roundingAmount.abs() : 0));
-        }, new _decimal.default(0));
-        if (depositPaidAmount.gte(currentOrder.deposit_amount || '0')) {
+        }, new import_decimal.default(0));
+        if (depositPaidAmount.gte(currentOrder.deposit_amount || "0")) {
           needUpdateDepositStatus = true;
-          // 更新缓存中的订单状态
           currentOrder.is_deposit = 0;
         }
       }
-
-      // 计算剩余金额（使用缓存的数据）
       const remainingAmount = this.calculateRemainingAmountFromData(currentOrder, paidAmount);
       const remainingTotalAmount = this.calculateRemainingTotalAmountFromData(currentOrder, paidAmount);
       const currentStateAmount = this.store.stateAmount;
       const currentBalanceDueAmount = this.store.balanceDueAmount;
-
-      // 批量更新状态，减少操作次数
       let hasStateChanged = false;
-
-      // 如果需要更新定金状态
       if (needUpdateDepositStatus) {
         this.store.currentOrder = {
           ...this.store.currentOrder,
@@ -2395,12 +2215,11 @@ class CheckoutImpl extends _BaseModule.BaseModule {
         });
         hasStateChanged = true;
       }
-      // 更新 stateAmount
+      console.time("updateStateAmountToRemaining: remainingAmount");
       if (remainingAmount !== currentStateAmount) {
         this.store.stateAmount = remainingAmount;
         hasStateChanged = true;
         setTimeout(() => {
-          // 发出 stateAmount 变更事件
           this.core.effects.emit(`${this.name}:onStateAmountChanged`, {
             oldAmount: currentStateAmount,
             newAmount: remainingAmount,
@@ -2408,17 +2227,16 @@ class CheckoutImpl extends _BaseModule.BaseModule {
             totalAmount: remainingTotalAmount
           });
         }, 0);
-        this.logInfo('stateAmount 已自动更新为剩余金额:', {
+        this.logInfo("stateAmount 已自动更新为剩余金额:", {
           oldAmount: currentStateAmount,
           newAmount: remainingAmount
         });
       }
-      // 更新 balanceDueAmount
+      console.timeEnd("updateStateAmountToRemaining: remainingAmount");
+      console.time("updateStateAmountToRemaining: updateStateAmountToRemaining");
       if (remainingAmount !== currentBalanceDueAmount) {
         this.store.balanceDueAmount = remainingAmount;
         hasStateChanged = true;
-
-        // 发出 balanceDueAmount 变更事件
         setTimeout(() => {
           this.core.effects.emit(`${this.name}:onBalanceDueAmountChanged`, {
             oldAmount: currentBalanceDueAmount,
@@ -2427,29 +2245,27 @@ class CheckoutImpl extends _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);
     }
   }
-
   /**
    * 检查订单支付是否完成（优化版，复用已获取的数据）
    *
@@ -2461,13 +2277,11 @@ class CheckoutImpl extends _BaseModule.BaseModule {
       if (!this.store.currentOrder) {
         return;
       }
-      const remainingValue = new _decimal.default(remainingAmount);
-
-      // 当剩余金额小于等于0时，认为订单已完成支付
+      const remainingValue = new import_decimal.default(remainingAmount);
       if (remainingValue.lte(0)) {
         const totalAmount = this.store.currentOrder.total_amount;
-        const paidAmount = this.calculationCache.paidAmount || '0.00';
-        this.logInfo('检测到订单支付完成:', {
+        const paidAmount = this.calculationCache.paidAmount || "0.00";
+        this.logInfo("检测到订单支付完成:", {
           orderUuid: this.store.currentOrder.uuid,
           orderId: this.store.currentOrder.order_id,
           totalAmount,
@@ -2475,40 +2289,38 @@ class CheckoutImpl extends _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,
@@ -2519,10 +2331,9 @@ class CheckoutImpl extends _BaseModule.BaseModule {
         });
       }
     } catch (error) {
-      this.logError('检查订单支付完成状态失败:', error);
+      this.logError("检查订单支付完成状态失败:", error);
     }
   }
-
   /**
    * 检查订单支付是否完成
    *
@@ -2537,13 +2348,11 @@ class CheckoutImpl extends _BaseModule.BaseModule {
         return;
       }
       const remainingAmount = await this.calculateRemainingAmountAsync();
-      const remainingValue = new _decimal.default(remainingAmount);
-
-      // 当剩余金额小于等于0时，认为订单已完成支付
+      const remainingValue = new import_decimal.default(remainingAmount);
       if (remainingValue.lte(0)) {
         const totalAmount = this.store.currentOrder.total_amount;
         const paidAmount = await this.calculatePaidAmountAsync();
-        this.logInfo('检测到订单支付完成:', {
+        this.logInfo("检测到订单支付完成:", {
           orderUuid: this.store.currentOrder.uuid,
           orderId: this.store.currentOrder.order_id,
           totalAmount,
@@ -2551,53 +2360,43 @@ class CheckoutImpl extends _BaseModule.BaseModule {
           remainingAmount,
           isOrderSynced: this.store.isOrderSynced
         });
-
-        // 从 Payment 模块获取最新支付项，检查自动同步条件
-        const currentPayments = await this.payment.getPaymentItemsAsync(this.store.currentOrder.uuid, false // 不包括已撤销的支付项
+        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);
-
-        // 判断是否需要自动同步订单
-        // 条件：
-        // 1. 有支付项
-        // 2. 不全是代金券支付
-        // 3. 订单未同步 OR (订单已同步但支付刚完成，需要同步最终支付状态)
+        const allPaymentsHaveVoucherId = hasPaymentItems && currentPayments.every(
+          (item) => item.status !== "voided" && item.voucher_id
+        );
         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,
@@ -2608,23 +2407,20 @@ class CheckoutImpl extends _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,
@@ -2637,79 +2433,81 @@ class CheckoutImpl extends _BaseModule.BaseModule {
       metadata
     };
     await this.payment.addPaymentItemAsync(orderUuid, paymentItemWithType);
-    await this.syncOrderToBackendFromIndexDbAsync({
-      orderUuid
-    });
+    await this.syncOrderToBackendFromIndexDbAsync({ orderUuid });
   }
   async syncOrderToBackendFromIndexDbAsync(params) {
-    const {
-      orderUuid
-    } = params;
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    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 = paymentOrder.order_info?.original_order_data || paymentOrder.order_info?.order_data;
+    const localOrderData = ((_a = paymentOrder.order_info) == null ? void 0 : _a.original_order_data) || ((_b = paymentOrder.order_info) == null ? void 0 : _b.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
-      };
+      return { 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
-      }
-    }));
+    const processedPaymentItems = paymentItems.map((item) => {
+      var _a2, _b2;
+      return {
+        ...item,
+        metadata: {
+          ...item.metadata,
+          rounding_rule: ((_a2 = item.metadata) == null ? void 0 : _a2.rounding_rule) || this.otherParams.order_rounding_setting,
+          shop_wallet_pass_id: ((_b2 = item.metadata) == null ? void 0 : _b2.shop_wallet_pass_id) || this.otherParams.shop_wallet_pass_id
+        }
+      };
+    });
     let finalDepositAmount;
-    const manualDepositAmount = paymentOrder.deposit_amount || '0.00';
-    const manualDepositValue = new _decimal.default(manualDepositAmount);
+    const manualDepositAmount = paymentOrder.deposit_amount || "0.00";
+    const manualDepositValue = new import_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 _decimal.default(item.amount || '0');
-        const roundingValue = new _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 import_decimal.default(item.amount || "0");
+        const roundingValue = new import_decimal.default(item.rounding_amount || "0");
         return sum.plus(amountValue).sub(roundingValue);
-      }, 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');
+      }, 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");
         return sum.plus(amountValue).sub(roundingValue);
-      }, new _decimal.default(0)).toFixed(2);
+      }, new import_decimal.default(0)).toFixed(2);
     }
     let orderPaymentStatus;
-    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');
+    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");
       return sum.plus(amountValue).sub(roundingValue);
-    }, new _decimal.default(0));
-    if (totalPaidAmount.gte(new _decimal.default(paymentOrder.total_amount))) {
-      orderPaymentStatus = 'paid';
+    }, new import_decimal.default(0));
+    if (totalPaidAmount.gte(new import_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,
@@ -2725,46 +2523,44 @@ class CheckoutImpl extends _BaseModule.BaseModule {
       currency_code: this.otherParams.currency_code,
       currency_symbol: this.otherParams.currency_symbol,
       currency_format: this.otherParams.currency_format,
-      business_code: this.otherParams?.business_code || undefined,
+      business_code: ((_c = this.otherParams) == null ? void 0 : _c.business_code) || void 0,
       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: localOrderData.bookings?.map(item => {
+      bookings: (_d = localOrderData.bookings) == null ? void 0 : _d.map((item) => {
         return {
           ...item,
           product: {
             ...item.product,
-            custom_deposit_data: undefined
+            custom_deposit_data: void 0
           },
-          deposit: undefined
+          deposit: void 0
         };
       }),
-      relation_products: localOrderData.relation_products?.map(item => {
+      relation_products: (_e = localOrderData.relation_products) == null ? void 0 : _e.map((item) => {
         return {
           ...item,
-          custom_deposit_data: undefined,
-          deposit: undefined
+          custom_deposit_data: void 0,
+          deposit: void 0
         };
       })
     };
     const currentOrderId = paymentOrder.order_id;
-    const isUpdateOperation = currentOrderId && !(0, _utils.isVirtualOrderId)(currentOrderId);
+    const isUpdateOperation = currentOrderId && !(0, import_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: orderUuid,
-      operation: isUpdateOperation ? 'update' : 'create',
+      orderUuid,
+      operation: isUpdateOperation ? "update" : "create",
       isManual: false,
       paymentItemCount: processedPaymentItems.length,
       timestamp: startTime
@@ -2773,85 +2569,80 @@ class CheckoutImpl extends _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?.status
+        responseStatus: checkoutResponse == null ? void 0 : checkoutResponse.status
       });
       this.core.effects.emit(`${this.name}:onOrderSubmitEnd`, {
         success: submitSuccess,
-        orderUuid: orderUuid,
-        operation: isUpdateOperation ? 'update' : 'create',
+        orderUuid,
+        operation: isUpdateOperation ? "update" : "create",
         isManual: false,
-        orderId: submitSuccess ? checkoutResponse?.data?.order_id || checkoutResponse?.order_id : undefined,
+        orderId: submitSuccess ? ((_f = checkoutResponse == null ? void 0 : checkoutResponse.data) == null ? void 0 : _f.order_id) || (checkoutResponse == null ? void 0 : checkoutResponse.order_id) : void 0,
         error: submitError,
         duration: Date.now() - startTime,
         timestamp: Date.now()
       });
     }
-    const responseStatus = checkoutResponse?.status;
-    const isSuccessResponse = responseStatus === true || responseStatus === 200 || responseStatus === 'success' || responseStatus === 1 && checkoutResponse?.code === 200;
+    const responseStatus = checkoutResponse == null ? void 0 : checkoutResponse.status;
+    const isSuccessResponse = responseStatus === true || responseStatus === 200 || responseStatus === "success" || responseStatus === 1 && (checkoutResponse == null ? void 0 : checkoutResponse.code) === 200;
     if (!isSuccessResponse) {
-      const errorMessage = checkoutResponse?.message || '订单同步失败，后端返回非成功状态';
-      this.logError('EFTPOS repair sync failed: api error', {
+      const errorMessage = (checkoutResponse == null ? void 0 : 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 = checkoutResponse?.data?.order_id;
+      let extractedOrderId = (_g = checkoutResponse == null ? void 0 : checkoutResponse.data) == null ? void 0 : _g.order_id;
       if (!extractedOrderId) {
-        extractedOrderId = checkoutResponse?.order_id;
+        extractedOrderId = checkoutResponse == null ? void 0 : checkoutResponse.order_id;
       }
-      if (extractedOrderId !== undefined && extractedOrderId !== null) {
+      if (extractedOrderId !== void 0 && 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: undefined
+        syncError: void 0
       });
     }
-    const latestPaymentStatus = checkoutResponse?.data?.payment_status || orderPaymentStatus;
+    const latestPaymentStatus = ((_h = checkoutResponse == null ? void 0 : checkoutResponse.data) == null ? void 0 : _h.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(),
@@ -2865,7 +2656,6 @@ class CheckoutImpl extends _BaseModule.BaseModule {
       response: checkoutResponse
     };
   }
-
   /**
    * 同步订单到后端并返回真实订单ID
    *
@@ -2874,22 +2664,26 @@ class CheckoutImpl extends _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;
@@ -2900,77 +2694,65 @@ class CheckoutImpl extends _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, _utils.isVirtualOrderId)(currentOrderId);
+      const isUpdateOperation = this.store.isOrderSynced || !(0, import_utils.isVirtualOrderId)(currentOrderId);
       this.logInfo(`开始同步订单到后端...`, {
         currentOrderId,
-        isVirtualId: (0, _utils.isVirtualOrderId)(currentOrderId || ''),
+        isVirtualId: (0, import_utils.isVirtualOrderId)(currentOrderId || ""),
         orderUuid: this.store.currentOrder.uuid,
         isOrderSynced: this.store.isOrderSynced,
         isManual
       });
-
-      // 获取当前订单的支付项
-      const paymentItems = customPaymentItems || (await this.payment.getPaymentItemsAsync(this.store.currentOrder.uuid));
-
-      // 处理支付项数据，确保包含完整的 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
-        }
-      }));
-
-      // 确定最终的定金金额：优先使用手动设置的值，否则从支付项中计算
+      const paymentItems = customPaymentItems || await this.payment.getPaymentItemsAsync(this.store.currentOrder.uuid);
+      const processedPaymentItems = paymentItems.map((item) => {
+        var _a2, _b2;
+        return {
+          ...item,
+          metadata: {
+            ...item.metadata,
+            rounding_rule: ((_a2 = item.metadata) == null ? void 0 : _a2.rounding_rule) || this.otherParams.order_rounding_setting,
+            shop_wallet_pass_id: ((_b2 = item.metadata) == null ? void 0 : _b2.shop_wallet_pass_id) || this.otherParams.shop_wallet_pass_id
+          }
+        };
+      });
       let finalDepositAmount;
-      const manualDepositAmount = this.store.currentOrder?.deposit_amount || '0.00';
-
-      // 优先级逻辑：手动设置的定金金额 > 从支付项计算的金额
-      const manualDepositValue = new _decimal.default(manualDepositAmount);
+      const manualDepositAmount = ((_a = this.store.currentOrder) == null ? void 0 : _a.deposit_amount) || "0.00";
+      const manualDepositValue = new import_decimal.default(manualDepositAmount);
       if (manualDepositValue.gt(0)) {
-        // 如果手动设置了定金金额且大于0，使用手动设置的值
         finalDepositAmount = manualDepositAmount;
-        this.logInfo('使用手动设置的定金金额', {
+        this.logInfo("使用手动设置的定金金额", {
           manualDepositAmount,
-          reason: '用户通过setDepositAmountAsync手动设置了定金金额'
+          reason: "用户通过setDepositAmountAsync手动设置了定金金额"
         });
       } else {
-        // 都为0，使用0
-        finalDepositAmount = '0.00';
-        this.logInfo('定金金额为0', {
+        finalDepositAmount = "0.00";
+        this.logInfo("定金金额为0", {
           manualDepositAmount,
-          reason: '手动设置和计算值均为0'
+          reason: "手动设置和计算值均为0"
         });
       }
-      // 如果此时是普通支付状态，并且要同步的支付项里一个定金支付的都没有，则 is_deposit 和 deposit_amount 都置为 0
-      if (this.store.currentOrder.is_deposit === 0 && processedPaymentItems.every(item => item.order_payment_type !== 'deposit')) {
-        finalDepositAmount = '0.00';
+      if (this.store.currentOrder.is_deposit === 0 && processedPaymentItems.every((item) => item.order_payment_type !== "deposit")) {
+        finalDepositAmount = "0.00";
         this.store.currentOrder.is_deposit = 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');
+      if (this.store.currentOrder.is_deposit === 0 && processedPaymentItems.some((item) => item.order_payment_type === "deposit")) {
+        finalDepositAmount = processedPaymentItems.filter((item) => item.status !== "voided" && item.order_payment_type === "deposit").reduce((sum, item) => {
+          const amt = new import_decimal.default(item.amount || "0");
+          const rounding = new import_decimal.default(item.rounding_amount || "0");
           return sum.plus(amt).sub(rounding);
-        }, new _decimal.default(0)).toFixed(2);
+        }, new import_decimal.default(0)).toFixed(2);
       }
-      // 如果当前是定金支付，并且定金额度已经大于等于了订单总计，则 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');
+      if (this.store.currentOrder.is_deposit === 1 && new import_decimal.default(finalDepositAmount).gte(new import_decimal.default(this.store.currentOrder.total_amount))) {
+        finalDepositAmount = processedPaymentItems.filter((item) => item.status !== "voided" && item.order_payment_type === "deposit").reduce((sum, item) => {
+          const amt = new import_decimal.default(item.amount || "0");
+          const rounding = new import_decimal.default(item.rounding_amount || "0");
           return sum.plus(amt).sub(rounding);
-        }, new _decimal.default(0)).toFixed(2);
+        }, new import_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,
@@ -2980,32 +2762,23 @@ class CheckoutImpl extends _BaseModule.BaseModule {
         })),
         manualDepositAmount,
         finalDepositAmount,
-        isDeposit: this.store.currentOrder?.is_deposit || 0
+        isDeposit: ((_b = this.store.currentOrder) == null ? void 0 : _b.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 _decimal.default(item.amount || '0');
-          const rounding = new _decimal.default(item.rounding_amount || '0');
+        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");
           return sum.plus(amt).sub(rounding);
-        }, new _decimal.default(0));
-        if (totalPaidAmount.gte(new _decimal.default(this.store.currentOrder.total_amount))) {
-          orderPaymentStatus = 'paid';
+        }, new import_decimal.default(0));
+        if (totalPaidAmount.gte(new import_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,
@@ -3013,7 +2786,7 @@ class CheckoutImpl extends _BaseModule.BaseModule {
         platform: this.store.localOrderData.platform,
         payments: processedPaymentItems,
         // 使用处理过的支付项数据
-        customer_id: this.store.currentCustomer?.customer_id,
+        customer_id: (_c = this.store.currentCustomer) == null ? void 0 : _c.customer_id,
         // 添加客户ID
         is_price_include_tax: this.otherParams.is_price_include_tax,
         // core 有
@@ -3026,46 +2799,45 @@ class CheckoutImpl extends _BaseModule.BaseModule {
         currency_code: this.otherParams.currency_code,
         currency_symbol: this.otherParams.currency_symbol,
         currency_format: this.otherParams.currency_format,
-        business_code: this.otherParams?.business_code || undefined,
-        is_deposit: (this.store.currentOrder?.is_deposit || Number(finalDepositAmount) > 0 ? 1 : 0) || 0,
+        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,
         deposit_amount: finalDepositAmount,
         // 使用最终确定的定金金额（手动设置优先）
         product_tax_fee: this.store.localOrderData.tax_fee,
         note: this.store.localOrderData.shop_note,
-        bookings: this.store.localOrderData.bookings?.map(item => {
+        bookings: (_f = this.store.localOrderData.bookings) == null ? void 0 : _f.map((item) => {
           return {
             ...item,
             product: {
               ...item.product,
-              custom_deposit_data: undefined
+              custom_deposit_data: void 0
             },
-            deposit: undefined
+            deposit: void 0
           };
         }),
-        relation_products: this.store.localOrderData.relation_products?.map(item => {
-          return {
-            ...item,
-            custom_deposit_data: undefined,
-            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
+            };
+          }
+        )
       };
-
-      // 如果是更新操作，需要在参数中包含真实的订单ID
       if (isUpdateOperation) {
-        // 如果当前订单ID是虚拟ID，但订单已同步过，可能存在数据不一致的问题
-        if ((0, _utils.isVirtualOrderId)(currentOrderId)) {
-          this.logWarning('尝试数据修复：暂时不包含order_id，注意：这次调用将作为创建操作处理，但后续会修复数据一致性');
+        if ((0, import_utils.isVirtualOrderId)(currentOrderId)) {
+          this.logWarning(
+            "尝试数据修复：暂时不包含order_id，注意：这次调用将作为创建操作处理，但后续会修复数据一致性"
+          );
         } else {
           orderParams.order_id = currentOrderId;
         }
       }
-
-      // 发送下单接口请求开始事件
       const startTime = Date.now();
       await this.core.effects.emit(`${this.name}:onOrderSubmitStart`, {
         orderUuid: this.store.currentOrder.uuid,
-        operation: isUpdateOperation ? 'update' : 'create',
+        operation: isUpdateOperation ? "update" : "create",
         isManual,
         paymentItemCount: paymentItems.length,
         timestamp: startTime
@@ -3074,93 +2846,73 @@ class CheckoutImpl extends _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 ? checkoutResponse?.data?.order_id || checkoutResponse?.order_id : undefined,
+          orderId: submitSuccess ? ((_h = checkoutResponse == null ? void 0 : checkoutResponse.data) == null ? void 0 : _h.order_id) || (checkoutResponse == null ? void 0 : checkoutResponse.order_id) : void 0,
           error: submitError,
           duration: Date.now() - startTime,
           timestamp: Date.now()
         });
       }
-
-      // 检查响应状态是否为成功状态
-      const responseStatus = checkoutResponse?.status;
-      const isSuccessResponse = responseStatus === true || responseStatus === 200 || responseStatus === 'success' || responseStatus === 1 && checkoutResponse?.code === 200;
+      const responseStatus = checkoutResponse == null ? void 0 : checkoutResponse.status;
+      const isSuccessResponse = responseStatus === true || responseStatus === 200 || responseStatus === "success" || responseStatus === 1 && (checkoutResponse == null ? void 0 : checkoutResponse.code) === 200;
       if (!isSuccessResponse) {
-        const errorMessage = checkoutResponse?.message || '订单同步失败，后端返回非成功状态';
-
-        // 发送订单同步失败事件
+        const errorMessage = (checkoutResponse == null ? void 0 : checkoutResponse.message) || "订单同步失败，后端返回非成功状态";
         await this.core.effects.emit(`${this.name}:onOrderSyncFailed`, {
           orderUuid: this.store.currentOrder.uuid,
-          operation: isUpdateOperation ? 'update' : 'create',
+          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 {
-        // 创建操作：从响应中提取新的订单ID
-        let extractedOrderId = checkoutResponse?.data?.order_id;
-
-        // 如果data.order_id不存在，尝试直接从根级获取
+        let extractedOrderId = (_i = checkoutResponse == null ? void 0 : checkoutResponse.data) == null ? void 0 : _i.order_id;
         if (!extractedOrderId) {
-          extractedOrderId = checkoutResponse?.order_id;
+          extractedOrderId = checkoutResponse == null ? void 0 : checkoutResponse.order_id;
         }
-
-        // 确保转换为字符串类型
-        if (extractedOrderId !== undefined && extractedOrderId !== null) {
+        if (extractedOrderId !== void 0 && extractedOrderId !== null) {
           extractedOrderId = String(extractedOrderId);
         }
         if (!extractedOrderId) {
-          this.logError('后端返回的订单信息中未包含订单ID');
+          this.logError("后端返回的订单信息中未包含订单ID");
         }
         realOrderId = extractedOrderId;
-
-        // 替换虚拟订单ID为真实订单ID
-        this.logInfo('准备替换订单ID:', {
+        this.logInfo("准备替换订单ID:", {
           orderUuid: this.store.currentOrder.uuid,
           oldOrderId: this.store.currentOrder.order_id,
           newOrderId: realOrderId
@@ -3168,84 +2920,74 @@ class CheckoutImpl extends _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?.order_id,
+            returnedOrderId: updatedOrder == null ? void 0 : 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
             };
-
-            // 同步更新 Payment 模块 DB，避免后续读取 DB 时又拿回旧状态
-            if (latestPaymentStatus) await this.payment.updateOrderAsync(previousOrder.uuid, {
-              payment_status: latestPaymentStatus
-            });
-            this.logInfo('[Checkout] 订单ID替换成功，当前订单ID:', this.store.currentOrder.order_id);
+            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替换失败，开始手动替换');
-
-            // 如果替换失败，手动更新订单ID
+            this.logError(
+              "[Checkout] Payment模块返回空订单，订单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: undefined
-          });
+          await this.payment.updatePaymentAsync(
+            this.store.currentOrder.uuid,
+            paymentUuid,
+            { isSynced: true, syncError: void 0 }
+          );
         }
       } 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,
@@ -3264,10 +3006,8 @@ class CheckoutImpl extends _BaseModule.BaseModule {
       }
     }
   }
-  async setOtherParams(params, {
-    cover = false
-  } = {}) {
-    this.logInfo('setOtherParams called', {
+  async setOtherParams(params, { cover = false } = {}) {
+    this.logInfo("setOtherParams called", {
       metadata: {
         params,
         cover
@@ -3276,13 +3016,9 @@ class CheckoutImpl extends _BaseModule.BaseModule {
     if (cover) {
       this.otherParams = params;
     } else {
-      this.otherParams = {
-        ...this.otherParams,
-        ...params
-      };
+      this.otherParams = { ...this.otherParams, ...params };
     }
   }
-
   /**
    * 通过订单ID编辑订单备注
    *
@@ -3293,54 +3029,41 @@ class CheckoutImpl extends _BaseModule.BaseModule {
    * @returns 修改结果
    */
   async editOrderNoteByOrderIdAsync(orderId, note) {
-    this.logInfo('editOrderNoteByOrderIdAsync called', {
-      orderId: orderId,
-      note: note,
+    this.logInfo("editOrderNoteByOrderIdAsync called", {
+      orderId,
+      note,
       noteLength: note.length
     });
     try {
-      // 参数验证
       if (!orderId) {
         return {
           success: false,
-          message: '订单ID不能为空',
-          orderId: orderId
+          message: "订单ID不能为空",
+          orderId
         };
       }
-
-      // 记录接口调用
-      this.logInfo('Calling order note edit API', {
+      this.logInfo("Calling order note edit API", {
         url: `/order/order/${orderId}/note`,
-        method: 'PUT',
-        orderId: orderId,
-        note: note,
+        method: "PUT",
+        orderId,
+        note,
         noteLength: note.length
       });
-
-      // 调用后端API修改订单备注
       const response = await this.request.put(`/order/order/${orderId}/note`, {
-        note: note
+        note
       });
-      this.logInfo('订单备注编辑响应:', {
-        orderId: orderId,
+      this.logInfo("订单备注编辑响应:", {
+        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,
@@ -3350,30 +3073,28 @@ class CheckoutImpl extends _BaseModule.BaseModule {
         }
         return {
           success: true,
-          message: response.message || '订单备注修改成功',
-          orderId: orderId
+          message: response.message || "订单备注修改成功",
+          orderId
         };
       } else {
-        // API返回失败状态
-        const errorMessage = response.message || '订单备注修改失败';
+        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
       };
     }
   }
-
   /**
    * 发送客户支付链接邮件
    *
@@ -3383,85 +3104,78 @@ class CheckoutImpl extends _BaseModule.BaseModule {
    * @returns 发送结果
    */
   async sendCustomerPayLinkAsync(params) {
-    this.logInfo('sendCustomerPayLinkAsync called', {
+    var _a, _b;
+    this.logInfo("sendCustomerPayLinkAsync called", {
       orderIds: params.order_ids,
-      orderIdsCount: params.order_ids?.length || 0,
+      orderIdsCount: ((_a = params.order_ids) == null ? void 0 : _a.length) || 0,
       emails: params.emails,
-      emailsCount: params.emails?.length || 0,
-      notifyAction: params.notify_action || 'order_payment_reminder'
+      emailsCount: ((_b = params.emails) == null ? void 0 : _b.length) || 0,
+      notifyAction: params.notify_action || "order_payment_reminder"
     });
     try {
-      // 参数验证
       if (!params.order_ids || params.order_ids.length === 0) {
         return {
           success: false,
-          message: '订单ID列表不能为空'
+          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
       });
-
-      // 调用后端API发送邮件
-      const response = await this.request.post('/order/batch-email', requestBody);
-      this.logInfo('支付链接邮件发送响应:', {
+      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 {
-        // API返回失败状态
-        const errorMessage = response.message || '支付链接邮件发送失败';
-        console.error('[Checkout] 支付链接邮件发送失败:', errorMessage);
+        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}`
       };
     }
   }
-
   /**
    * 金额舍入
    *
@@ -3469,33 +3183,31 @@ class CheckoutImpl extends _BaseModule.BaseModule {
    * @returns 舍入结果详情，包含原始金额、舍入后金额和舍入差额
    */
   async roundAmountAsync(amount) {
-    // 检查 CASHMANUAL 的支付项是否开启了舍入，如果没开直接返回 amount
-    const cashManualPayment = this.store.paymentMethods.find(p => p.code === 'CASHMANUAL');
-    if (!cashManualPayment?.metadata?.order_rounding_switch) {
+    var _a, _b, _c;
+    const cashManualPayment = this.store.paymentMethods.find((p) => p.code === "CASHMANUAL");
+    if (!((_a = cashManualPayment == null ? void 0 : cashManualPayment.metadata) == null ? void 0 : _a.order_rounding_switch)) {
       return {
         originalAmount: amount.toString(),
         roundedAmount: amount.toString(),
-        roundingDifference: '0.00'
+        roundingDifference: "0.00"
       };
     }
-    const result = await this.payment.roundAmountAsync(amount, this.otherParams.order_rounding_setting?.interval, this.otherParams.order_rounding_setting?.type);
+    const result = await this.payment.roundAmountAsync(
+      amount,
+      (_b = this.otherParams.order_rounding_setting) == null ? void 0 : _b.interval,
+      (_c = this.otherParams.order_rounding_setting) == null ? void 0 : _c.type
+    );
     return result;
   }
   async destroy() {
-    // 清理钱包模块的所有缓存数据
+    var _a, _b, _c, _d;
     this.payment.wallet.clearAllCache();
-
-    // 清理事件监听
     this.core.effects.offByModuleDestroy(this.name);
-
-    // 销毁子模块
-    await this.order?.destroy?.();
-    await this.payment?.destroy?.();
-
-    // 取消注册模块
+    await ((_b = (_a = this.order) == null ? void 0 : _a.destroy) == null ? void 0 : _b.call(_a));
+    await ((_d = (_c = this.payment) == null ? void 0 : _c.destroy) == null ? void 0 : _d.call(_c));
     this.core.unregisterModule(this);
+    console.log("[Checkout] 已销毁");
   }
-
   /**
    * 重置 store 状态
    *
@@ -3509,29 +3221,19 @@ class CheckoutImpl extends _BaseModule.BaseModule {
         uuid: this.store.currentOrder.uuid,
         orderId: this.store.currentOrder.order_id
       } : null;
-      // 重置订单相关的 store 状态（保留 paymentMethods，因为支付方式数据变更不频繁）
-      this.store.currentOrder = undefined;
-      this.store.localOrderData = undefined;
-      this.store.cartSummary = undefined;
-      this.store.stateAmount = '0.00';
-      this.store.balanceDueAmount = '0.00';
+      console.log("[Checkout] 重置 store 状态，准备创建新订单", prevOrderInfo);
+      this.store.currentOrder = void 0;
+      this.store.localOrderData = void 0;
+      this.store.cartSummary = void 0;
+      this.store.stateAmount = "0.00";
+      this.store.balanceDueAmount = "0.00";
       this.store.isOrderSynced = false;
-      this.store.currentCustomer = undefined;
-      this.store.lastError = undefined;
-
-      // 清空购物车项目
+      this.store.currentCustomer = void 0;
+      this.store.lastError = void 0;
       this.store.cartItems = [];
-
-      // 清理钱包缓存（同步操作）
       this.payment.wallet.clearAllCache();
-
-      // 🚀 清除计算缓存
       this.clearCalculationCache();
-
-      // 注意：故意保留 this.store.paymentMethods，因为支付方式数据不易变更，保留在内存中提高性能
-
-      // 🚀 性能优化：异步触发订单清理事件（不阻塞主流程）
-      // 使用 setTimeout 确保事件处理不会阻塞状态重置
+      console.log("[Checkout] Store 状态重置完成");
       if (prevOrderInfo) {
         setTimeout(() => {
           this.core.effects.emit(`${this.name}:onOrderCleared`, {
@@ -3541,8 +3243,12 @@ class CheckoutImpl extends _BaseModule.BaseModule {
         }, 0);
       }
     } catch (error) {
-      console.error('[Checkout] 重置 store 状态失败:', error);
+      console.error("[Checkout] 重置 store 状态失败:", error);
     }
   }
-}
-exports.CheckoutImpl = CheckoutImpl;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CheckoutImpl,
+  ...require("./types")
+});