@pisell/pisellos 0.0.569 → 0.10.2

package/lib/modules/Payment/index.js

@@ -1,116 +1,89 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-var _exportNames = {
-  generateRequestUniqueId: true,
-  PaymentModule: true
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-exports.PaymentModule = void 0;
-exports.generateRequestUniqueId = generateRequestUniqueId;
-var _BaseModule = require("../BaseModule");
-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 __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/modules/Payment/index.ts
+var Payment_exports = {};
+__export(Payment_exports, {
+  PaymentModule: () => PaymentModule,
+  generateRequestUniqueId: () => generateRequestUniqueId
 });
-var _utils = require("../Cart/utils");
-var _cash = require("./cash");
-var _eftpos = require("./eftpos");
-var _walletpass = require("./walletpass");
-var _decimal = require("decimal.js");
-/**
- * 格式化金额为保留两位小数的字符串
- */
+module.exports = __toCommonJS(Payment_exports);
+var import_BaseModule = require("../BaseModule");
+var import_types = require("./types");
+var import_utils = require("../Cart/utils");
+var import_cash = require("./cash");
+var import_eftpos = require("./eftpos");
+var import_walletpass = require("./walletpass");
+var import_decimal = require("decimal.js");
+__reExport(Payment_exports, require("./types"), module.exports);
 function formatAmount(amount) {
   try {
-    const decimal = new _decimal.Decimal(amount);
+    const decimal = new import_decimal.Decimal(amount);
     return decimal.toFixed(2);
   } catch (error) {
     console.warn(`[PaymentModule] 金额格式化失败: ${amount}，使用默认值 0.00`);
-    return '0.00';
+    return "0.00";
   }
 }
-
-/**
- * 格式化日期时间为字符串
- * 格式: YYYY-MM-DD HH:mm:ss
- * 示例: 2025-12-10 16:14:50
- */
 function formatDateTime(date) {
   const year = date.getFullYear();
-  const month = String(date.getMonth() + 1).padStart(2, '0');
-  const day = String(date.getDate()).padStart(2, '0');
-  const hours = String(date.getHours()).padStart(2, '0');
-  const minutes = String(date.getMinutes()).padStart(2, '0');
-  const seconds = String(date.getSeconds()).padStart(2, '0');
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  const hours = String(date.getHours()).padStart(2, "0");
+  const minutes = String(date.getMinutes()).padStart(2, "0");
+  const seconds = String(date.getSeconds()).padStart(2, "0");
   return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
 }
-
-/**
- * 生成请求唯一ID
- * 格式: 年月日时分秒毫秒+4位随机数
- * 示例: 20241201143025123456
- */
 function generateRequestUniqueId() {
-  const now = new Date();
+  const now = /* @__PURE__ */ new Date();
   const year = now.getFullYear();
-  const month = String(now.getMonth() + 1).padStart(2, '0');
-  const day = String(now.getDate()).padStart(2, '0');
-  const hour = String(now.getHours()).padStart(2, '0');
-  const minute = String(now.getMinutes()).padStart(2, '0');
-  const second = String(now.getSeconds()).padStart(2, '0');
-  const millisecond = String(now.getMilliseconds()).padStart(3, '0');
-  const randomDigits = Math.floor(Math.random() * 9000) + 1000; // 1000-9999的4位随机数
-
+  const month = String(now.getMonth() + 1).padStart(2, "0");
+  const day = String(now.getDate()).padStart(2, "0");
+  const hour = String(now.getHours()).padStart(2, "0");
+  const minute = String(now.getMinutes()).padStart(2, "0");
+  const second = String(now.getSeconds()).padStart(2, "0");
+  const millisecond = String(now.getMilliseconds()).padStart(3, "0");
+  const randomDigits = Math.floor(Math.random() * 9e3) + 1e3;
   return `${year}${month}${day}${hour}${minute}${second}${millisecond}${randomDigits}`;
 }
 function normalizeCustomPaymentId(paymentItem) {
   const rawId = paymentItem.custom_payment_id ?? paymentItem.id ?? 0;
   const parsedId = Number(rawId);
-  if (!Number.isFinite(parsedId)) return 0;
+  if (!Number.isFinite(parsedId))
+    return 0;
   return parsedId;
 }
-
-/**
- * 支付模块实现
- *
- * 负责处理支付相关的数据管理和本地存储
- */
-class PaymentModule extends _BaseModule.BaseModule {
-  defaultName = 'pay';
-  defaultVersion = '1.0.0';
-  request;
-  app; // App instance
-  store;
-  window; // WindowPlugin 实例
-  dbManager; // IndexDBManager 实例
-  logger; // LoggerManager 实例
-  voucherUpdateLockByOrderUuid = new Map();
-  otherParams = {};
-
-  // 支付方式实例
-  cash;
-  eftpos;
-  wallet;
+var PaymentModule = class extends import_BaseModule.BaseModule {
   constructor(name, version) {
     super(name || "payment", version);
-    // 初始化支付方式实例
-    this.cash = new _cash.CashPaymentImpl(this);
-    this.eftpos = new _eftpos.EftposPaymentImpl(this);
-    this.wallet = new _walletpass.WalletPassPaymentImpl(this);
+    this.defaultName = "pay";
+    this.defaultVersion = "1.0.0";
+    // LoggerManager 实例
+    this.voucherUpdateLockByOrderUuid = /* @__PURE__ */ new Map();
+    this.otherParams = {};
+    this.cash = new import_cash.CashPaymentImpl(this);
+    this.eftpos = new import_eftpos.EftposPaymentImpl(this);
+    this.wallet = new import_walletpass.WalletPassPaymentImpl(this);
   }
   runVoucherUpdateLocked(orderUuid, task) {
     const previous = this.voucherUpdateLockByOrderUuid.get(orderUuid) || Promise.resolve();
-    const next = previous.catch(() => undefined).then(task).finally(() => {
+    const next = previous.catch(() => void 0).then(task).finally(() => {
       if (this.voucherUpdateLockByOrderUuid.get(orderUuid) === next) {
         this.voucherUpdateLockByOrderUuid.delete(orderUuid);
       }
@@ -119,21 +92,18 @@ class PaymentModule extends _BaseModule.BaseModule {
     return next;
   }
   normalizeVoucherPaymentItems(voucherPaymentItems) {
-    const normalized = new Map();
+    const normalized = /* @__PURE__ */ new Map();
     for (const item of voucherPaymentItems || []) {
-      if (!item?.voucher_id) {
+      if (!(item == null ? void 0 : item.voucher_id)) {
         throw new Error(`代金券支付项缺少 voucher_id: ${JSON.stringify(item)}`);
       }
-      const orderPaymentType = item.order_payment_type || 'normal';
+      const orderPaymentType = item.order_payment_type || "normal";
       const key = `${item.voucher_id}|${orderPaymentType}`;
-      normalized.set(key, {
-        ...item,
-        order_payment_type: orderPaymentType
-      });
+      normalized.set(key, { ...item, order_payment_type: orderPaymentType });
     }
     return {
       items: Array.from(normalized.values()),
-      originalCount: voucherPaymentItems?.length || 0,
+      originalCount: (voucherPaymentItems == null ? void 0 : voucherPaymentItems.length) || 0,
       normalizedCount: normalized.size
     };
   }
@@ -141,32 +111,22 @@ class PaymentModule extends _BaseModule.BaseModule {
     this.core = core;
     this.store = options.store;
     this.otherParams = options.otherParams || {};
-
-    // 获取依赖的插件
-    this.request = core.getPlugin('request');
-    const appPlugin = core.getPlugin('app');
-    this.window = core.getPlugin('window');
+    this.request = core.getPlugin("request");
+    const appPlugin = core.getPlugin("app");
+    this.window = core.getPlugin("window");
     if (!this.request) {
-      throw new Error('支付模块需要 request 插件支持');
+      throw new Error("支付模块需要 request 插件支持");
     }
     if (!appPlugin) {
-      throw new Error('支付模块需要 app 插件支持');
+      throw new Error("支付模块需要 app 插件支持");
     }
     this.app = appPlugin.getApp();
     this.dbManager = this.app.dbManager;
     this.logger = this.app.logger;
-
-    // 确保支付模块所需的对象存储已创建
-    // await this.ensurePaymentTables();
-
     this.registerNetworkHandlers();
-
-    // // 预连接数据库
-    // this.dbManager.connect()
-
-    this.logInfo('PaymentModule initialized successfully');
+    console.log("[PaymentModule] 初始化完成");
+    this.logInfo("PaymentModule initialized successfully");
   }
-
   /**
    * 更新父级解决方案透传的运行态参数，主要用于日志父模块等上下文。
    *
@@ -176,13 +136,13 @@ class PaymentModule extends _BaseModule.BaseModule {
   updateOtherParams(params) {
     this.otherParams = params || {};
   }
-
   /**
    * 记录信息日志
    */
   logInfo(title, metadata) {
-    if (this.otherParams?.fatherModule) {
-      const fatherModule = this.core.getModule(this.otherParams?.fatherModule);
+    var _a, _b;
+    if ((_a = this.otherParams) == null ? void 0 : _a.fatherModule) {
+      const fatherModule = this.core.getModule((_b = this.otherParams) == null ? void 0 : _b.fatherModule);
       if (fatherModule) {
         fatherModule.logInfo(`${title}`, metadata);
         return;
@@ -190,33 +150,31 @@ class PaymentModule extends _BaseModule.BaseModule {
     }
     if (this.logger) {
       this.logger.addLog({
-        type: 'info',
+        type: "info",
         title: `[PaymentModule] ${title}`,
         metadata: metadata || {}
       });
     }
   }
-
   /**
    * 记录警告日志
    */
   logWarning(title, metadata) {
     if (this.logger) {
       this.logger.addLog({
-        type: 'warning',
+        type: "warning",
         title: `[PaymentModule] ${title}`,
         metadata: metadata || {}
       });
     }
   }
-
   /**
    * 记录错误日志
    */
   logError(title, error, metadata) {
     if (this.logger) {
       this.logger.addLog({
-        type: 'error',
+        type: "error",
         title: `[PaymentModule] ${title}`,
         metadata: {
           error: error ? {
@@ -224,182 +182,128 @@ class PaymentModule extends _BaseModule.BaseModule {
             stack: error.stack,
             code: error.code,
             ...error
-          } : undefined,
-          ...(metadata || {})
+          } : void 0,
+          ...metadata || {}
         }
       });
     }
   }
-
   /**
    * 记录调试日志
    */
   logDebug(title, metadata) {
     if (this.logger) {
       this.logger.addLog({
-        type: 'debug',
+        type: "debug",
         title: `[PaymentModule] ${title}`,
         metadata: metadata || {}
       });
     }
   }
-
   /**
    * 网络恢复以后，尝试执行队列
    *
    */
   registerNetworkHandlers() {
-    const network = this.app.plugins.get('network');
-    this.logInfo('Registering network status listener');
-    network?.addListener('networkStatusChange', async status => {
-      this.logInfo('Network status changed', {
+    const network = this.app.plugins.get("network");
+    this.logInfo("Registering network status listener");
+    network == null ? void 0 : network.addListener("networkStatusChange", async (status) => {
+      console.log("网络状态:", status.connected);
+      this.logInfo("Network status changed", {
         connected: status.connected,
         previousStatus: status.previousStatus
       });
       if (status.connected) {
-        this.logInfo('Network reconnected');
-        // 网络恢复时的处理逻辑可以在这里添加
+        this.logInfo("Network reconnected");
       }
     });
   }
-
   /**
    * 获取支付方式列表
    */
   async getPayMethodListAsync() {
-    this.logInfo('Starting getPayMethodListAsync');
+    this.logInfo("Starting getPayMethodListAsync");
     try {
-      const response = await this.request.get('/pay/custom-payment/all', {
+      const response = await this.request.get("/pay/custom-payment/all", {
         filterPaymentMethods: true
       }, {
         osServer: true
       });
-      const payMethods = response?.data || response || [];
-      this.logInfo('getPayMethodListAsync completed successfully', {
+      const payMethods = (response == null ? void 0 : response.data) || response || [];
+      this.logInfo("getPayMethodListAsync completed successfully", {
         payMethods
       });
       return payMethods;
     } catch (error) {
-      console.error('[PaymentModule] 获取支付方式列表失败', error);
-      this.logError('getPayMethodListAsync failed', error);
-      // 如果所有操作都失败，返回空数组
+      console.error("[PaymentModule] 获取支付方式列表失败", error);
+      this.logError("getPayMethodListAsync failed", error);
       return [];
     }
   }
-
   /**
    * 获取订单列表
    */
   /** @deprecated */
   async getOrderListAsync() {
     try {
-      return await this.dbManager.getAll('order');
+      return await this.dbManager.getAll("order");
     } catch (error) {
-      console.error('[PaymentModule] 获取订单列表失败', error);
+      console.error("[PaymentModule] 获取订单列表失败", error);
       return [];
     }
   }
-
   /**
    * 根据订单UUID获取支付订单（新方法）
    */
   async getPaymentOrderByUuidAsync(orderUuid) {
     try {
-      return await this.dbManager.get('order', orderUuid, true);
+      return await this.dbManager.get("order", orderUuid, true);
     } catch (error) {
-      console.error('[PaymentModule] 获取支付订单失败', error);
+      console.error("[PaymentModule] 获取支付订单失败", error);
       return null;
     }
   }
-
   /**
    * 创建支付订单（新方法，专注支付数据）
    */
   async createPaymentOrderAsync(params) {
-    this.logInfo('Starting createPaymentOrderAsync', {
+    this.logInfo("Starting createPaymentOrderAsync", {
       orderId: params.order_id,
       totalAmount: params.total_amount
     });
     try {
-      // 检测是否有重复的 order_id
-      // console.time('createLocalOrderAsync: getExistingOrder')
-      // const existingOrder = await this.dbManager.get('order', params.order_id);
-      // const existingOrders = await this.dbManager.getAll('order');
-      // const existingOrder = existingOrders.find(
-      //   (order: PaymentOrder) => String(order.id) === String(params.order_id),
-      // );
-
-      // this.logInfo('createPaymentOrderAsync existingOrder', {
-      //   existingOrder
-      // });
-      // console.timeEnd('createLocalOrderAsync: getExistingOrder')
-      // const existingOrder = existingOrders.find(
-      //   (order: PaymentOrder) => String(order.id) === String(params.order_id),
-      // );
-
-      // if (existingOrder) {
-      //   // 如果存在相同 order_id 的订单，更新该订单信息
-      //   this.logInfo(
-      //     `createPaymentOrderAsync found duplicate order ID: ${params.order_id}, updating existing payment order`,
-      //   );
-
-      //   // const originalOrder = { ...existingOrder };
-      //   existingOrder.order_info = params.order_info;
-      //   existingOrder.total_amount = params.total_amount;
-      //   existingOrder.is_deposit = params.is_deposit || 0;
-      //   existingOrder.deposit_amount = params.deposit_amount || '0.00';
-
-      //   // 重新计算待付金额
-      //   this.recalculateOrderAmount(existingOrder);
-
-      //   // 更新到数据库
-      //   await this.dbManager.update('order', existingOrder);
-
-      //   // 触发更新事件
-      //   this.core.effects.emit(
-      //     `${this.name}:onOrderUpdated`,
-      //     existingOrder,
-      //   );
-
-      //   return existingOrder;
-      // } else {
-      // 创建新的支付订单
       const newOrder = {
-        uuid: (0, _utils.getUniqueId)('pay_order_'),
+        uuid: (0, import_utils.getUniqueId)("pay_order_"),
         id: params.order_id,
         order_id: params.order_id,
         order_info: params.order_info,
-        payment_status: _types.PaymentStatus.Processing,
+        payment_status: import_types.PaymentStatus.Processing,
         payment: [],
         adjust_offline_payments: [],
         total_amount: params.total_amount,
         expect_amount: params.total_amount,
-        tax_fee: '0.00',
+        tax_fee: "0.00",
         is_deposit: params.is_deposit || 0,
-        deposit_amount: params.deposit_amount || '0.00'
+        deposit_amount: params.deposit_amount || "0.00"
       };
-
-      // 🔧 新增: 处理云端已存在的支付项
       if (params.existPayment && params.existPayment.length > 0) {
-        const currentTime = formatDateTime(new Date());
-        newOrder.payment = params.existPayment.map(payment => ({
+        const currentTime = formatDateTime(/* @__PURE__ */ new Date());
+        newOrder.payment = 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
         }));
-
-        // 重新计算待付金额
         this.recalculateOrderAmount(newOrder);
-        this.logInfo('创建订单时包含云端支付项', {
+        this.logInfo("创建订单时包含云端支付项", {
           orderId: params.order_id,
           existPaymentCount: params.existPayment.length,
           totalAmount: newOrder.total_amount,
           expectAmount: newOrder.expect_amount,
-          paymentDetails: params.existPayment.map(p => ({
+          paymentDetails: params.existPayment.map((p) => ({
             uuid: p.uuid,
             code: p.code,
             amount: p.amount,
@@ -409,75 +313,67 @@ class PaymentModule extends _BaseModule.BaseModule {
           }))
         });
       }
-
-      // 🚀 性能监控：记录数据库添加操作耗时
       const dbAddStartTime = Date.now();
-      await this.dbManager.add('order', newOrder, true);
+      await this.dbManager.add("order", newOrder, true);
       const dbAddDuration = Date.now() - dbAddStartTime;
-      this.logInfo('Database add operation completed', {
-        operation: 'dbManager.add',
-        table: 'order',
+      this.logInfo("Database add operation completed", {
+        operation: "dbManager.add",
+        table: "order",
         orderUuid: newOrder.uuid,
         orderId: newOrder.order_id,
         duration: `${dbAddDuration}ms`,
-        performance: dbAddDuration > 100 ? 'slow' : dbAddDuration > 50 ? 'medium' : 'fast'
+        performance: dbAddDuration > 100 ? "slow" : dbAddDuration > 50 ? "medium" : "fast"
       });
       setTimeout(() => {
         this.core.effects.emit(`${this.name}:onOrderAdded`, newOrder);
       }, 0);
       return newOrder;
-      // }
     } catch (error) {
-      console.error('[PaymentModule] 创建支付订单失败', error);
-      this.logError('createPaymentOrderAsync failed', error, {
+      console.error("[PaymentModule] 创建支付订单失败", error);
+      this.logError("createPaymentOrderAsync failed", error, {
         orderId: params.order_id
       });
       throw error;
     }
   }
-
   /**
    * 删除支付订单（新方法）
    */
   async deletePaymentOrderAsync(orderUuid) {
     try {
-      const order = await this.dbManager.get('order', orderUuid);
+      const order = await this.dbManager.get("order", orderUuid);
       if (order) {
-        await this.dbManager.delete('order', orderUuid);
+        await this.dbManager.delete("order", orderUuid);
         await this.core.effects.emit(`${this.name}:onOrderDeleted`, order);
+        console.log("[PaymentModule] 支付订单删除成功:", orderUuid);
       }
     } catch (error) {
-      console.error('[PaymentModule] 删除支付订单失败', error);
+      console.error("[PaymentModule] 删除支付订单失败", error);
       throw error;
     }
   }
-
   /**
    * 更新订单
    */
   async updateOrderAsync(orderUuid, params) {
     try {
-      const order = await this.dbManager.get('order', orderUuid);
+      const order = await this.dbManager.get("order", orderUuid);
       if (order) {
-        const updatedOrder = {
-          ...order,
-          ...params
-        };
+        const updatedOrder = { ...order, ...params };
         this.recalculateOrderAmount(updatedOrder);
-        await this.dbManager.update('order', updatedOrder);
+        await this.dbManager.update("order", updatedOrder);
         await this.core.effects.emit(`${this.name}:onOrderUpdated`, updatedOrder);
         await this.core.effects.emit(`${this.name}:onOrderChanged`, {
-          action: 'update',
+          action: "update",
           order: updatedOrder,
           originalOrder: order
         });
       }
     } catch (error) {
-      console.error('[PaymentModule] 更新订单失败', error);
+      console.error("[PaymentModule] 更新订单失败", error);
       throw error;
     }
   }
-
   /**
    * 基于UUID替换订单ID
    * 
@@ -489,35 +385,28 @@ class PaymentModule extends _BaseModule.BaseModule {
    * @returns 更新后的订单对象，如果订单不存在则返回null
    */
   async replaceOrderIdByUuidAsync(orderUuid, newOrderId) {
-    this.logInfo('Starting replaceOrderIdByUuidAsync', {
+    this.logInfo("Starting replaceOrderIdByUuidAsync", {
       orderUuid,
       newOrderId
     });
     try {
-      // 获取现有订单
-      const existingOrder = await this.dbManager.get('order', orderUuid);
+      const existingOrder = await this.dbManager.get("order", orderUuid);
       if (!existingOrder) {
-        this.logWarning('Order not found for UUID replacement', {
-          orderUuid
-        });
+        this.logWarning("Order not found for UUID replacement", { orderUuid });
         return null;
       }
-
-      // 检查新的订单ID是否已经存在
-      const allOrders = await this.dbManager.getAll('order');
-      const duplicateOrder = allOrders.find(order => String(order.order_id) === String(newOrderId) && order.uuid !== orderUuid);
+      const allOrders = await this.dbManager.getAll("order");
+      const duplicateOrder = allOrders.find(
+        (order) => String(order.order_id) === String(newOrderId) && order.uuid !== orderUuid
+      );
       if (duplicateOrder) {
-        this.logWarning('New order ID already exists', {
+        this.logWarning("New order ID already exists", {
           newOrderId,
           existingOrderUuid: duplicateOrder.uuid
         });
         throw new Error(`订单ID ${newOrderId} 已存在`);
       }
-
-      // 保存原始订单ID用于日志
       const originalOrderId = existingOrder.id;
-
-      // 更新订单ID
       const updatedOrder = {
         ...existingOrder,
         id: newOrderId,
@@ -528,17 +417,13 @@ class PaymentModule extends _BaseModule.BaseModule {
           order_id: newOrderId,
           // 保留原始本地订单ID作为参考
           original_local_order_id: originalOrderId,
-          updated_at: new Date().toISOString()
+          updated_at: (/* @__PURE__ */ new Date()).toISOString()
         }
       };
-
-      // 更新到数据库
-      await this.dbManager.update('order', updatedOrder);
-
-      // 触发事件
+      await this.dbManager.update("order", updatedOrder);
       await this.core.effects.emit(`${this.name}:onOrderUpdated`, updatedOrder);
       await this.core.effects.emit(`${this.name}:onOrderChanged`, {
-        action: 'order_id_replaced',
+        action: "order_id_replaced",
         order: updatedOrder,
         originalOrder: existingOrder,
         metadata: {
@@ -546,22 +431,22 @@ class PaymentModule extends _BaseModule.BaseModule {
           newOrderId
         }
       });
-      this.logInfo('Order ID replacement completed successfully', {
+      this.logInfo("Order ID replacement completed successfully", {
         orderUuid,
         originalOrderId,
         newOrderId
       });
+      console.log(`[PaymentModule] 订单ID替换成功: ${originalOrderId} → ${newOrderId}`);
       return updatedOrder;
     } catch (error) {
-      console.error('[PaymentModule] 替换订单ID失败', error);
-      this.logError('replaceOrderIdByUuidAsync failed', error, {
+      console.error("[PaymentModule] 替换订单ID失败", error);
+      this.logError("replaceOrderIdByUuidAsync failed", error, {
         orderUuid,
         newOrderId
       });
       throw error;
     }
   }
-
   /**
    * 获取支付项（新方法）
    * 
@@ -571,18 +456,15 @@ class PaymentModule extends _BaseModule.BaseModule {
    */
   async getPaymentItemsAsync(orderUuid, includeVoided = false) {
     if (!orderUuid) {
-      throw new Error('orderUuid is required');
+      throw new Error("orderUuid is required");
     }
     const order = await this.getPaymentOrderByUuidAsync(orderUuid);
-    const allPayments = order?.payment || [];
+    const allPayments = (order == null ? void 0 : order.payment) || [];
     if (includeVoided) {
       return allPayments;
     }
-
-    // 默认只返回活跃的支付项
-    return allPayments.filter(payment => payment.status !== 'voided');
+    return allPayments.filter((payment) => payment.status !== "voided");
   }
-
   /**
    * 获取所有支付项（包括已撤销的）
    * 
@@ -592,51 +474,47 @@ class PaymentModule extends _BaseModule.BaseModule {
   async getAllPaymentItemsAsync(orderUuid) {
     return this.getPaymentItemsAsync(orderUuid, true);
   }
-
   /**
    * 为某个订单添加支付项（新方法）
    */
   async addPaymentItemAsync(orderUuid, paymentItem) {
-    this.logInfo('Starting addPaymentItemAsync', {
+    var _a, _b, _c, _d;
+    this.logInfo("Starting addPaymentItemAsync", {
       orderUuid,
       paymentAmount: paymentItem.amount,
       paymentCode: paymentItem.code,
       orderPaymentType: paymentItem.order_payment_type
     });
     try {
-      this.logInfo('准备获取订单', {
+      this.logInfo("准备获取订单", {
         orderUuid
       });
       const order = await this.getPaymentOrderByUuidAsync(orderUuid);
-      this.logInfo('获取订单信息成功', {
+      this.logInfo("获取订单信息成功", {
         orderUuid,
         order
       });
       if (!order) {
         throw new Error(`Order not found: ${orderUuid}`);
       }
-
-      // 🔒 支付锁检查：如果订单待付金额已经为0，不允许继续添加支付项
-      const expectAmount = new _decimal.Decimal(order.expect_amount);
+      const expectAmount = new import_decimal.Decimal(order.expect_amount);
       const paidDepositAmount = order.payment.reduce((sum, payment) => {
-        if (payment.order_payment_type === 'deposit' && payment.status !== 'voided') {
-          return sum.plus(new _decimal.Decimal(payment.amount));
+        if (payment.order_payment_type === "deposit" && payment.status !== "voided") {
+          return sum.plus(new import_decimal.Decimal(payment.amount));
         }
         return sum;
-      }, new _decimal.Decimal(0));
-      const expectedDepositAmount = new _decimal.Decimal(order.deposit_amount || '0').sub(paidDepositAmount);
-
-      // 有一种特殊情况,订单金额为 0，但是定金金额>0，且此时是定金状态的，允许添加支付项
+      }, new import_decimal.Decimal(0));
+      const expectedDepositAmount = new import_decimal.Decimal(order.deposit_amount || "0").sub(paidDepositAmount);
       if (expectAmount.lte(0) && expectedDepositAmount.eq(0)) {
         const warningMessage = `订单 ${orderUuid} 待付金额已为0，不允许添加新的支付项`;
-        console.warn('[PaymentModule] Payment lock triggered:', {
+        console.warn("[PaymentModule] Payment lock triggered:", {
           orderUuid,
           expectAmount: order.expect_amount,
           attemptedPaymentAmount: paymentItem.amount,
           attemptedPaymentCode: paymentItem.code,
-          reason: 'Order already fully paid'
+          reason: "Order already fully paid"
         });
-        this.logError('addPaymentItemAsync blocked by payment lock', new Error(warningMessage), {
+        this.logError("addPaymentItemAsync blocked by payment lock", new Error(warningMessage), {
           orderUuid,
           expectAmount: order.expect_amount,
           paymentItem
@@ -644,12 +522,12 @@ class PaymentModule extends _BaseModule.BaseModule {
         throw new Error(warningMessage);
       }
       let paymentUuid;
-      if (paymentItem.metadata?.unique_payment_number) {
+      if ((_a = paymentItem.metadata) == null ? void 0 : _a.unique_payment_number) {
         paymentUuid = paymentItem.metadata.unique_payment_number;
       } else {
-        paymentUuid = (0, _utils.getUniqueId)('payment_');
+        paymentUuid = (0, import_utils.getUniqueId)("payment_");
       }
-      const currentTime = formatDateTime(new Date());
+      const currentTime = formatDateTime(/* @__PURE__ */ new Date());
       const newPaymentItem = {
         uuid: paymentUuid,
         custom_payment_id: normalizeCustomPaymentId(paymentItem),
@@ -657,14 +535,14 @@ class PaymentModule extends _BaseModule.BaseModule {
         code: paymentItem.code,
         type: paymentItem.type,
         amount: formatAmount(paymentItem.amount),
-        voucher_id: paymentItem.voucher_id || '',
+        voucher_id: paymentItem.voucher_id || "",
         wallet_pass_usage_unit: paymentItem.wallet_pass_usage_unit,
         wallet_pass_use_value: paymentItem.wallet_pass_use_value,
-        rounding_amount: paymentItem.rounding_amount || '0.00',
+        rounding_amount: paymentItem.rounding_amount || "0.00",
         service_charge: paymentItem.service_charge,
-        status: 'active',
+        status: "active",
         // 新支付项默认为活跃状态
-        order_payment_type: paymentItem.order_payment_type || 'normal',
+        order_payment_type: paymentItem.order_payment_type || "normal",
         // 默认为正常支付
         created_at: currentTime,
         // 创建时间
@@ -673,105 +551,100 @@ class PaymentModule extends _BaseModule.BaseModule {
         metadata: {
           ...paymentItem.metadata,
           // 保留传入的所有 metadata 字段
-          unique_payment_number: paymentUuid // 设置唯一支付号为支付项的 uuid
+          unique_payment_number: paymentUuid
+          // 设置唯一支付号为支付项的 uuid
         }
       };
       order.payment.push(newPaymentItem);
       this.recalculateOrderAmount(order);
-      this.logInfo('开始更新订单支付项', {
+      this.logInfo("开始更新订单支付项", {
         orderUuid,
         order
       });
-      await this.dbManager.update('order', order, true);
-      this.logInfo('更新订单支付项完成', {
+      await this.dbManager.update("order", order, true);
+      this.logInfo("更新订单支付项完成", {
         orderUuid
       });
       this.core.effects.emit(`${this.name}:onPaymentAdded`, {
         orderUuid,
         payment: newPaymentItem
       });
-      this.logInfo('addPaymentItemAsync completed successfully', {
+      this.logInfo("addPaymentItemAsync completed successfully", {
         orderUuid,
         paymentUuid: newPaymentItem.uuid,
-        uniquePaymentNumber: newPaymentItem.metadata?.unique_payment_number,
+        uniquePaymentNumber: (_b = newPaymentItem.metadata) == null ? void 0 : _b.unique_payment_number,
         newExpectAmount: order.expect_amount,
         paymentAmount: newPaymentItem.amount,
         paymentCode: newPaymentItem.code,
         orderPaymentType: newPaymentItem.order_payment_type,
         metadataFields: Object.keys(newPaymentItem.metadata || {}),
         // 现金支付找零信息
-        actualPaidAmount: newPaymentItem.metadata?.actual_paid_amount,
-        changeGivenAmount: newPaymentItem.metadata?.change_given_amount
+        actualPaidAmount: (_c = newPaymentItem.metadata) == null ? void 0 : _c.actual_paid_amount,
+        changeGivenAmount: (_d = newPaymentItem.metadata) == null ? void 0 : _d.change_given_amount
       });
     } catch (error) {
-      console.error('[PaymentModule] 添加支付项失败', error);
-      this.logError('addPaymentItemAsync failed', error, {
+      console.error("[PaymentModule] 添加支付项失败", error);
+      this.logError("addPaymentItemAsync failed", error, {
         orderUuid,
         paymentItem
       });
       throw error;
     }
   }
-
   /**
    * 删除一个支付项 - 标记删除而非物理删除
    */
   async deletePaymentAsync(orderUuid, paymentUuid) {
-    this.logInfo('Starting deletePaymentAsync (mark as voided)', {
-      orderUuid,
-      paymentUuid
-    });
+    this.logInfo("Starting deletePaymentAsync (mark as voided)", { orderUuid, paymentUuid });
     try {
-      const order = await this.dbManager.get('order', orderUuid);
+      const order = await this.dbManager.get("order", orderUuid);
       if (!order) {
-        throw new Error('订单不存在');
+        throw new Error("订单不存在");
       }
-      const paymentItem = order.payment.find(payment => payment.uuid === paymentUuid);
+      const paymentItem = order.payment.find(
+        (payment) => payment.uuid === paymentUuid
+      );
       if (!paymentItem) {
         throw new Error(`支付项不存在: ${paymentUuid}`);
       }
-
-      // 检查是否已经被删除（撤销）
-      if (paymentItem.status === 'voided') {
+      if (paymentItem.status === "voided") {
         console.warn(`[PaymentModule] 支付项 ${paymentUuid} 已经被删除，跳过操作`);
         return;
       }
-
-      // 标记删除而不是物理删除
-      paymentItem.status = 'voided';
-      paymentItem.origin_amount = paymentItem.amount; // 保存原始金额
-      paymentItem.amount = '0.00'; // 将金额设为0，不参与订单金额计算
-
-      // 重新计算待付金额
+      paymentItem.status = "voided";
+      paymentItem.origin_amount = paymentItem.amount;
+      paymentItem.amount = "0.00";
+      console.log(`[PaymentModule] 支付项标记为删除:`, {
+        uuid: paymentItem.uuid,
+        originalAmount: paymentItem.origin_amount,
+        status: paymentItem.status
+      });
       this.recalculateOrderAmount(order);
-
-      // 更新到 IndexDB
-      await this.dbManager.update('order', order);
+      await this.dbManager.update("order", order);
       await this.core.effects.emit(`${this.name}:onPaymentDeleted`, {
         order,
-        paymentItem: paymentItem
+        paymentItem
       });
       await this.core.effects.emit(`${this.name}:onOrderChanged`, {
-        action: 'payment_delete',
+        action: "payment_delete",
         order,
-        paymentItem: paymentItem
+        paymentItem
       });
-      this.logInfo('deletePaymentAsync completed successfully (marked as voided)', {
+      this.logInfo("deletePaymentAsync completed successfully (marked as voided)", {
         orderUuid,
         paymentUuid,
         originalAmount: paymentItem.origin_amount,
         newExpectAmount: order.expect_amount
       });
     } catch (error) {
-      console.error('[PaymentModule] 删除支付项失败', error);
-      this.logError('deletePaymentAsync failed', error, {
+      console.error("[PaymentModule] 删除支付项失败", error);
+      this.logError("deletePaymentAsync failed", error, {
         orderUuid,
         paymentUuid
       });
       throw error;
     }
   }
-
   /**
    * 批量更新代金券类支付项（覆盖更新）
    * 
@@ -780,16 +653,12 @@ class PaymentModule extends _BaseModule.BaseModule {
    */
   async updateVoucherPaymentItemsAsync(orderUuid, voucherPaymentItems) {
     return this.runVoucherUpdateLocked(orderUuid, async () => {
-      const {
-        items: normalizedVoucherItems,
-        originalCount,
-        normalizedCount
-      } = this.normalizeVoucherPaymentItems(voucherPaymentItems);
-      this.logInfo('Starting updateVoucherPaymentItemsAsync', {
+      const { items: normalizedVoucherItems, originalCount, normalizedCount } = this.normalizeVoucherPaymentItems(voucherPaymentItems);
+      this.logInfo("Starting updateVoucherPaymentItemsAsync", {
         orderUuid,
         originalVoucherCount: originalCount,
         normalizedVoucherCount: normalizedCount,
-        voucherItems: normalizedVoucherItems.map(item => ({
+        voucherItems: normalizedVoucherItems.map((item) => ({
           code: item.code,
           amount: item.amount,
           voucher_id: item.voucher_id,
@@ -797,7 +666,7 @@ class PaymentModule extends _BaseModule.BaseModule {
         }))
       });
       if (originalCount !== normalizedCount) {
-        console.warn('[PaymentModule] voucherPaymentItems detected duplicates (deduped by voucher_id + order_payment_type)', {
+        console.warn("[PaymentModule] voucherPaymentItems detected duplicates (deduped by voucher_id + order_payment_type)", {
           orderUuid,
           originalCount,
           normalizedCount
@@ -808,52 +677,72 @@ class PaymentModule extends _BaseModule.BaseModule {
         if (!order) {
           throw new Error(`订单不存在: ${orderUuid}`);
         }
-
-        // 1. 查找所有现有的代金券类支付项（带 voucher_id 且状态不是 voided)并且还没有同步给后端
-        // 如果同步给了后端的voucher 不允许删除
-        const existingVoucherItems = order.payment.filter(payment => payment.voucher_id && payment.status !== 'voided' && !payment.isSynced);
-        // 2. 删除所有现有的代金券支付项（仅删除未同步的）
+        const existingVoucherItems = order.payment.filter(
+          (payment) => payment.voucher_id && payment.status !== "voided" && !payment.isSynced
+        );
+        console.log("[PaymentModule] 发现现有代金券支付项:", {
+          orderUuid,
+          existingVoucherCount: existingVoucherItems.length,
+          existingItems: existingVoucherItems.map((item) => ({
+            uuid: item.uuid,
+            code: item.code,
+            amount: item.amount,
+            voucher_id: item.voucher_id,
+            isSynced: item.isSynced
+          }))
+        });
         for (const voucherItem of existingVoucherItems) {
+          console.log(`[PaymentModule] 删除现有代金券支付项: ${voucherItem.uuid}`);
           await this.deletePaymentAsync(orderUuid, voucherItem.uuid);
         }
-
-        // 3. 添加新的代金券支付项（幂等：如果已存在同 voucher_id + order_payment_type 的 active 项则跳过）
         const orderAfterDelete = await this.getPaymentOrderByUuidAsync(orderUuid);
         if (!orderAfterDelete) {
           throw new Error(`订单不存在: ${orderUuid}`);
         }
-        const existingActiveVoucherKeys = new Set(orderAfterDelete.payment.filter(p => p.voucher_id && p.status !== 'voided' && !p.isSynced).map(p => `${p.voucher_id}|${p.order_payment_type || 'normal'}`));
+        const existingActiveVoucherKeys = new Set(
+          orderAfterDelete.payment.filter((p) => p.voucher_id && p.status !== "voided" && !p.isSynced).map((p) => `${p.voucher_id}|${p.order_payment_type || "normal"}`)
+        );
+        console.log("[PaymentModule] 添加新的代金券支付项:", {
+          orderUuid,
+          newItemCount: normalizedVoucherItems.length
+        });
         for (const voucherItem of normalizedVoucherItems) {
-          const orderPaymentType = voucherItem.order_payment_type || 'normal';
+          const orderPaymentType = voucherItem.order_payment_type || "normal";
           const key = `${voucherItem.voucher_id}|${orderPaymentType}`;
           if (existingActiveVoucherKeys.has(key)) {
-            console.warn('[PaymentModule] Skip adding voucher payment item because it already exists (active)', {
+            console.warn("[PaymentModule] Skip adding voucher payment item because it already exists (active)", {
               orderUuid,
               voucher_id: voucherItem.voucher_id,
               order_payment_type: orderPaymentType
             });
             continue;
           }
+          console.log(`[PaymentModule] 添加代金券支付项:`, {
+            ...voucherItem,
+            code: voucherItem.code,
+            amount: voucherItem.amount,
+            voucher_id: voucherItem.voucher_id,
+            order_payment_type: orderPaymentType
+          });
           await this.addPaymentItemAsync(orderUuid, voucherItem);
           existingActiveVoucherKeys.add(key);
         }
-
-        // 4. 触发支付项更新事件
         const updatedOrder = await this.getPaymentOrderByUuidAsync(orderUuid);
         await this.core.effects.emit(`${this.name}:onPaymentAdded`, {
           orderUuid,
           order: updatedOrder,
-          payment: null // 批量操作不提供单个支付项
+          payment: null
+          // 批量操作不提供单个支付项
         });
-        this.logInfo('updateVoucherPaymentItemsAsync completed successfully', {
+        this.logInfo("updateVoucherPaymentItemsAsync completed successfully", {
           orderUuid,
           removedVoucherCount: existingVoucherItems.length,
           addedVoucherCount: normalizedVoucherItems.length,
-          finalExpectAmount: updatedOrder?.expect_amount
+          finalExpectAmount: updatedOrder == null ? void 0 : updatedOrder.expect_amount
         });
       } catch (error) {
-        console.error('[PaymentModule] 批量更新代金券支付项失败:', error);
-        this.logError('updateVoucherPaymentItemsAsync failed', error, {
+        console.error("[PaymentModule] 批量更新代金券支付项失败:", error);
+        this.logError("updateVoucherPaymentItemsAsync failed", error, {
           orderUuid,
           voucherPaymentItems
         });
@@ -861,94 +750,79 @@ class PaymentModule extends _BaseModule.BaseModule {
       }
     });
   }
-
   /**
    * 更新一个支付项
    */
   async updatePaymentAsync(orderUuid, paymentUuid, params) {
     try {
-      const order = await this.dbManager.get('order', orderUuid);
+      const order = await this.dbManager.get("order", orderUuid);
       if (!order) {
-        throw new Error('订单不存在');
+        throw new Error("订单不存在");
       }
-      const paymentItem = order.payment.find(payment => payment.uuid === paymentUuid);
+      const paymentItem = order.payment.find(
+        (payment) => payment.uuid === paymentUuid
+      );
       if (paymentItem) {
-        // 如果更新参数中包含 amount，先格式化
-        const formattedParams = {
-          ...params
-        };
-        if ('amount' in formattedParams && formattedParams.amount !== undefined) {
+        const formattedParams = { ...params };
+        if ("amount" in formattedParams && formattedParams.amount !== void 0) {
           formattedParams.amount = formatAmount(formattedParams.amount);
         }
         Object.assign(paymentItem, formattedParams);
-
-        // 重新计算待付金额
         this.recalculateOrderAmount(order);
-
-        // 更新到 IndexDB
-        await this.dbManager.update('order', order);
+        await this.dbManager.update("order", order);
         await this.core.effects.emit(`${this.name}:onPaymentUpdated`, {
           order,
           paymentItem
         });
         await this.core.effects.emit(`${this.name}:onOrderChanged`, {
-          action: 'payment_update',
+          action: "payment_update",
           order,
           paymentItem
         });
       }
     } catch (error) {
-      console.error('[PaymentModule] 更新支付项失败', error);
+      console.error("[PaymentModule] 更新支付项失败", error);
       throw error;
     }
   }
-
   /**
    * 提交支付
    */
   async submitPayAsync(orderUuid) {
-    this.logInfo('Starting submitPayAsync', {
-      orderUuid
-    });
+    this.logInfo("Starting submitPayAsync", { orderUuid });
     try {
       let orderToSubmit;
       if (orderUuid) {
-        const order = await this.dbManager.get('order', orderUuid);
+        const order = await this.dbManager.get("order", orderUuid);
         orderToSubmit = order ? [order] : [];
       } else {
-        const allOrders = await this.dbManager.getAll('order');
-        // 包括正在处理中的订单和部分支付的订单（可能添加了新的支付项）
-        orderToSubmit = allOrders.filter(order => order.payment_status === _types.PaymentStatus.Processing || order.payment_status === _types.PaymentStatus.PartiallyPaid);
+        const allOrders = await this.dbManager.getAll("order");
+        orderToSubmit = allOrders.filter(
+          (order) => order.payment_status === import_types.PaymentStatus.Processing || order.payment_status === import_types.PaymentStatus.PartiallyPaid
+        );
       }
       for (const order of orderToSubmit) {
         await this.submitSingleOrderPayment(order);
       }
-      const result = {
-        status: 'success'
-      };
-      this.logInfo('submitPayAsync completed', {
+      const result = { status: "success" };
+      this.logInfo("submitPayAsync completed", {
         result: result.status,
         processedOrdersCount: orderToSubmit.length
       });
       return result;
     } catch (error) {
-      console.error('[PaymentModule] 提交支付失败', error);
-      this.logError('submitPayAsync failed', error, {
-        orderUuid
-      });
-      return {
-        status: 'failed'
-      };
+      console.error("[PaymentModule] 提交支付失败", error);
+      this.logError("submitPayAsync failed", error, { orderUuid });
+      return { status: "failed" };
     }
   }
-
   /**
    * 提交单个订单的支付（推送到任务队列）
    */
   async submitSingleOrderPayment(order) {
     try {
       const paymentData = {
-        payments: order.payment.map(payment => ({
+        payments: order.payment.map((payment) => ({
           uuid: payment.uuid,
           amount: payment.amount,
           code: payment.code,
@@ -960,41 +834,37 @@ class PaymentModule extends _BaseModule.BaseModule {
           rounding_amount: payment.rounding_amount,
           service_charge: payment.service_charge
         })),
-        payment_status: 'pending'
+        payment_status: "pending"
       };
-
-      // 计算总支付金额
-      const totalPaidAmount = paymentData.payments.reduce((sum, payment) => sum.plus(payment.amount), new _decimal.Decimal(0));
-      const orderTotalAmount = new _decimal.Decimal(order.total_amount);
-
-      // 根据支付金额判断订单状态
+      const totalPaidAmount = paymentData.payments.reduce(
+        (sum, payment) => sum.plus(payment.amount),
+        new import_decimal.Decimal(0)
+      );
+      const orderTotalAmount = new import_decimal.Decimal(order.total_amount);
       if (totalPaidAmount.gte(orderTotalAmount)) {
-        // 支付金额足够，标记为已完成
-        order.payment_status = _types.PaymentStatus.Finished;
+        order.payment_status = import_types.PaymentStatus.Finished;
+        console.log(
+          `[PaymentModule] 订单 ${order.uuid} 支付完成，金额: ${totalPaidAmount.toString()}/${orderTotalAmount.toString()}`
+        );
       } else {
-        // 支付金额不足，标记为部分支付
-        order.payment_status = _types.PaymentStatus.PartiallyPaid;
+        order.payment_status = import_types.PaymentStatus.PartiallyPaid;
+        console.log(
+          `[PaymentModule] 订单 ${order.uuid} 部分支付，金额: ${totalPaidAmount.toString()}/${orderTotalAmount.toString()}`
+        );
       }
-
-      // 给后端标记一下是全部支付（paid）还是部分支付
-      paymentData.payment_status = order.payment_status === _types.PaymentStatus.Finished ? 'paid' : 'partially_paid';
-
-      // 更新订单状态到数据库
-      await this.dbManager.update('order', order);
-
-      // 检查支付列表是否为空
+      paymentData.payment_status = order.payment_status === import_types.PaymentStatus.Finished ? "paid" : "partially_paid";
+      await this.dbManager.update("order", order);
       if (paymentData.payments.length === 0) {
-        this.logWarning('Empty payment list', {
+        console.log(`[PaymentModule] 订单 ${order.uuid} 支付列表为空，跳过支付处理`);
+        this.logWarning("Empty payment list", {
           orderUuid: order.uuid,
           orderId: order.order_id
         });
         return;
       }
-
-      // 触发支付提交事件
       await this.core.effects.emit(`${this.name}:onPaymentSubmitted`, order);
       await this.core.effects.emit(`${this.name}:onOrderChanged`, {
-        action: 'submit',
+        action: "submit",
         order
       });
     } catch (error) {
@@ -1002,165 +872,170 @@ class PaymentModule extends _BaseModule.BaseModule {
       throw error;
     }
   }
-
   /**
    * 获取订单剩余待付金额
    */
   async getRemainingOrderAmountAsync(orderUuid) {
     const order = await this.getPaymentOrderByUuidAsync(orderUuid);
     if (!order) {
-      throw new Error('订单不存在');
+      throw new Error("订单不存在");
     }
-    return new _decimal.Decimal(order.expect_amount).toNumber();
+    return new import_decimal.Decimal(order.expect_amount).toNumber();
   }
-
   /**
    * 在比如现金支付界面的地方，用户输入了一个金额，在下方显示剩余多少金额，通过此方法获取
    */
   async getRemainingOrderAmountWithInputAsync(inputAmount, orderUuid) {
     const order = await this.getPaymentOrderByUuidAsync(orderUuid);
     if (!order) {
-      throw new Error('订单不存在');
+      throw new Error("订单不存在");
     }
-
-    // 对输入金额做保护，确保是有效的数字
-    if (inputAmount === null || inputAmount === undefined) {
-      // 如果输入为空，返回原始的待付金额
-      return new _decimal.Decimal(order.expect_amount).toNumber();
+    if (inputAmount === null || inputAmount === void 0) {
+      return new import_decimal.Decimal(order.expect_amount).toNumber();
     }
-
-    // 处理字符串类型的输入
-    if (typeof inputAmount === 'string') {
-      if (inputAmount.trim() === '') {
-        // 如果输入为空字符串，返回原始的待付金额
-        return new _decimal.Decimal(order.expect_amount).toNumber();
+    if (typeof inputAmount === "string") {
+      if (inputAmount.trim() === "") {
+        return new import_decimal.Decimal(order.expect_amount).toNumber();
       }
     }
-
-    // 处理数字类型的输入
-    if (typeof inputAmount === 'number') {
+    if (typeof inputAmount === "number") {
       if (isNaN(inputAmount) || !isFinite(inputAmount)) {
-        // 如果输入是 NaN 或无穷大，返回原始的待付金额
-        console.warn(`[PaymentModule] 输入金额不是有效数字: ${inputAmount}，返回原始待付金额`);
-        return new _decimal.Decimal(order.expect_amount).toNumber();
+        console.warn(
+          `[PaymentModule] 输入金额不是有效数字: ${inputAmount}，返回原始待付金额`
+        );
+        return new import_decimal.Decimal(order.expect_amount).toNumber();
       }
     }
     try {
-      const inputDecimal = new _decimal.Decimal(inputAmount);
-      return new _decimal.Decimal(order.expect_amount).minus(inputDecimal).toNumber();
+      const inputDecimal = new import_decimal.Decimal(inputAmount);
+      return new import_decimal.Decimal(order.expect_amount).minus(inputDecimal).toNumber();
     } catch (error) {
-      // 如果输入不是有效的数字，返回原始的待付金额
-      console.warn(`[PaymentModule] 输入金额格式无效: ${inputAmount}，返回原始待付金额`);
-      return new _decimal.Decimal(order.expect_amount).toNumber();
+      console.warn(
+        `[PaymentModule] 输入金额格式无效: ${inputAmount}，返回原始待付金额`
+      );
+      return new import_decimal.Decimal(order.expect_amount).toNumber();
     }
   }
-
   /**
    * 重新计算订单金额
    */
   recalculateOrderAmount(order) {
-    const totalAmount = new _decimal.Decimal(order.total_amount);
-    const paidAmount = order.payment.reduce((sum, payment) => {
-      try {
-        // 忽略已撤销的支付项
-        if (payment.status === 'voided') {
+    const totalAmount = new import_decimal.Decimal(order.total_amount);
+    const paidAmount = order.payment.reduce(
+      (sum, payment) => {
+        try {
+          if (payment.status === "voided") {
+            return sum;
+          }
+          const paymentAmount = new import_decimal.Decimal(payment.amount || 0);
+          const roundingAmount = new import_decimal.Decimal(payment.rounding_amount || 0);
+          const effectiveAmount = paymentAmount.minus(roundingAmount);
+          return sum.plus(effectiveAmount);
+        } catch (error) {
+          console.warn(`[PaymentModule] 无效的支付金额: amount=${payment.amount}, rounding_amount=${payment.rounding_amount}，跳过计算`);
           return sum;
         }
-
-        // 计算有效支付金额：支付金额 + 抹零金额的绝对值
-        // 当 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.Decimal(payment.amount || 0);
-        const roundingAmount = new _decimal.Decimal(payment.rounding_amount || 0);
-        const effectiveAmount = paymentAmount.minus(roundingAmount);
-        return sum.plus(effectiveAmount);
-      } catch (error) {
-        console.warn(`[PaymentModule] 无效的支付金额: amount=${payment.amount}, rounding_amount=${payment.rounding_amount}，跳过计算`);
-        return sum;
-      }
-    }, new _decimal.Decimal(0));
-    // 如果是定金模式，则使用deposit_amount 去减已付款金额
-    const remainingAmount = order.is_deposit === 1 ? new _decimal.Decimal(order.deposit_amount).minus(paidAmount) : totalAmount.minus(paidAmount);
-    order.expect_amount = _decimal.Decimal.max(0, remainingAmount).toFixed(2);
+      },
+      new import_decimal.Decimal(0)
+    );
+    const remainingAmount = order.is_deposit === 1 ? new import_decimal.Decimal(order.deposit_amount).minus(paidAmount) : totalAmount.minus(paidAmount);
+    order.expect_amount = import_decimal.Decimal.max(0, remainingAmount).toFixed(2);
+    console.log(`[PaymentModule] 重新计算订单金额:`, {
+      orderUuid: order.uuid,
+      totalAmount: order.total_amount,
+      effectivePaidAmount: paidAmount.toFixed(2),
+      remainingAmount: order.expect_amount,
+      activePayments: order.payment.filter((p) => p.status !== "voided").length,
+      voidedPayments: order.payment.filter((p) => p.status === "voided").length,
+      paymentDetails: order.payment.filter((p) => p.status !== "voided").map((p) => ({
+        code: p.code,
+        amount: p.amount,
+        rounding_amount: p.rounding_amount || "0.00",
+        effective_amount: new import_decimal.Decimal(p.amount || 0).minus(new import_decimal.Decimal(p.rounding_amount || 0)).toFixed(2)
+      })),
+      说明: "有效支付金额包含抹零计算（amount + |rounding_amount|）"
+    });
   }
-
   /**
    * 获取现金支付方式
    */
   async getCashPaymentMethod() {
     try {
-      const payMethods = await this.dbManager.getAll('pay_method');
-      return payMethods.find(method => method.code === _types.PaymentMethodType.Cash) || null;
+      const payMethods = await this.dbManager.getAll("pay_method");
+      return payMethods.find(
+        (method) => method.code === import_types.PaymentMethodType.Cash
+      ) || null;
     } catch (error) {
-      console.error('[PaymentModule] 获取现金支付方式失败', error);
+      console.error("[PaymentModule] 获取现金支付方式失败", error);
       return null;
     }
   }
-
   /**
    * 获取Eftpos支付方式
    */
   async getEftposPaymentMethod() {
     try {
-      const payMethods = await this.dbManager.getAll('pay_method');
-      return payMethods.find(method => method.code === _types.PaymentMethodType.Eftpos) || null;
+      const payMethods = await this.dbManager.getAll("pay_method");
+      return payMethods.find(
+        (method) => method.code === import_types.PaymentMethodType.Eftpos
+      ) || null;
     } catch (error) {
-      console.error('[PaymentModule] 获取Eftpos支付方式失败', error);
+      console.error("[PaymentModule] 获取Eftpos支付方式失败", error);
       return null;
     }
   }
-
   /**
    * 获取钱包支付方式
    */
   async getWalletPaymentMethod() {
     try {
-      const payMethods = await this.dbManager.getAll('pay_method');
-      return payMethods.find(method => method.code === _types.PaymentMethodType.Wallet) || null;
+      const payMethods = await this.dbManager.getAll("pay_method");
+      return payMethods.find(
+        (method) => method.code === import_types.PaymentMethodType.Wallet
+      ) || null;
     } catch (error) {
-      console.error('[PaymentModule] 获取钱包支付方式失败', error);
+      console.error("[PaymentModule] 获取钱包支付方式失败", error);
       return null;
     }
   }
-
   /**
    * 确保支付模块所需的数据库表已创建
    */
   /** @deprecated */
   async ensurePaymentTables() {
     try {
-      // 尝试访问 pay_method 表，如果不存在会抛出错误
-      await this.dbManager.getAll('pay_method');
+      await this.dbManager.getAll("pay_method");
     } catch (error) {
-      console.warn('[PaymentModule] pay_method 表不存在，请在数据库配置中添加以下配置：');
+      console.warn(
+        "[PaymentModule] pay_method 表不存在，请在数据库配置中添加以下配置："
+      );
       console.warn('{ name: "pay_method", keyPath: "id" }');
     }
     try {
-      // 尝试访问 order 表，如果不存在会抛出错误
-      await this.dbManager.getAll('order');
+      await this.dbManager.getAll("order");
     } catch (error) {
-      console.warn('[PaymentModule] order 表不存在，请在数据库配置中添加以下配置：');
+      console.warn(
+        "[PaymentModule] order 表不存在，请在数据库配置中添加以下配置："
+      );
       console.warn('{ name: "order", keyPath: "uuid" }');
     }
   }
-
   /**
    * 获取部分支付的订单
    */
   /** @deprecated */
   async getPartiallyPaidOrdersAsync() {
     try {
-      const allOrders = await this.dbManager.getAll('order');
-      return allOrders.filter(order => order.payment_status === _types.PaymentStatus.PartiallyPaid);
+      const allOrders = await this.dbManager.getAll("order");
+      return allOrders.filter(
+        (order) => order.payment_status === import_types.PaymentStatus.PartiallyPaid
+      );
     } catch (error) {
-      console.error('[PaymentModule] 获取部分支付订单失败', error);
+      console.error("[PaymentModule] 获取部分支付订单失败", error);
       return [];
     }
   }
-
   // === 新的 API 方法实现 ===
-
   /**
    * 智能金额舍入
    * 
@@ -1173,78 +1048,63 @@ class PaymentModule extends _BaseModule.BaseModule {
    */
   async roundAmountAsync(originalAmount, interval, rule) {
     try {
-      // 参数验证
-      const amount = new _decimal.Decimal(originalAmount);
-      const roundingInterval = new _decimal.Decimal(interval);
+      const amount = new import_decimal.Decimal(originalAmount);
+      const roundingInterval = new import_decimal.Decimal(interval);
       if (roundingInterval.lte(0)) {
-        throw new Error('舍入间隔必须大于 0');
+        throw new Error("舍入间隔必须大于 0");
       }
-
-      // 支持的舍入间隔
       const supportedIntervals = [0.05, 0.1, 0.5, 1];
       const intervalValue = roundingInterval.toNumber();
       if (!supportedIntervals.includes(intervalValue)) {
-        console.warn(`[PaymentModule] 不支持的舍入间隔: ${intervalValue}, 支持的间隔: ${supportedIntervals.join(', ')}`);
+        console.warn(`[PaymentModule] 不支持的舍入间隔: ${intervalValue}, 支持的间隔: ${supportedIntervals.join(", ")}`);
       }
-
-      // 计算基础值：x / interval
       const baseValue = amount.div(roundingInterval);
+      console.log(`[PaymentModule] 舍入计算 - 原始金额: ${amount.toString()}, 间隔: ${intervalValue}, 基础值: ${baseValue.toString()}, 规则: ${rule}`);
       let roundedValue;
-
-      // 根据舍入规则处理
       switch (rule) {
-        case _types.RoundingRule.Standard:
-        case 'standard':
-          // 标准舍入（中点向上）
+        case import_types.RoundingRule.Standard:
+        case "standard":
           roundedValue = this.standardRound(baseValue, true);
           break;
-        case _types.RoundingRule.StandardDown:
-        case 'standard_down':
-          // 标准舍入（中点向下）
+        case import_types.RoundingRule.StandardDown:
+        case "standard_down":
           roundedValue = this.standardRound(baseValue, false);
           break;
-        case _types.RoundingRule.AlwaysUp:
-        case 'always_up':
-          // 总是向上舍入
+        case import_types.RoundingRule.AlwaysUp:
+        case "always_up":
           roundedValue = baseValue.ceil();
           break;
-        case _types.RoundingRule.AlwaysDown:
-        case 'always_down':
-          // 总是向下舍入
+        case import_types.RoundingRule.AlwaysDown:
+        case "always_down":
           roundedValue = baseValue.floor();
           break;
         default:
           throw new Error(`不支持的舍入规则: ${rule}`);
       }
-
-      // 计算最终金额：roundedValue * interval
       const finalAmount = roundedValue.mul(roundingInterval);
       const originalAmountStr = amount.toFixed(2);
-
-      // 如果最终金额是 0 元，则不采用舍入金额，返回原始金额
       if (finalAmount.eq(0)) {
+        console.log(`[PaymentModule] 最终金额为0，返回原始金额: ${originalAmountStr}`);
         return {
           originalAmount: originalAmountStr,
           roundedAmount: originalAmountStr,
-          roundingDifference: '0.00'
+          roundingDifference: "0.00"
         };
       }
       const roundedAmountStr = finalAmount.toFixed(2);
-
-      // 计算舍入差额
       const roundingDifference = finalAmount.sub(amount);
       const roundingDifferenceStr = roundingDifference.toFixed(2);
+      console.log(`[PaymentModule] 舍入结果 - 原始金额: ${originalAmountStr}, 舍入后金额: ${roundedAmountStr}, 舍入差额: ${roundingDifferenceStr}`);
       return {
         originalAmount: originalAmountStr,
         roundedAmount: roundedAmountStr,
         roundingDifference: roundingDifferenceStr
       };
     } catch (error) {
-      console.error('[PaymentModule] 金额舍入失败:', error);
+      console.error("[PaymentModule] 金额舍入失败:", error);
       throw new Error(`金额舍入失败: ${error instanceof Error ? error.message : String(error)}`);
     }
   }
-
   /**
    * 标准舍入处理（处理中点情况）
    * 
@@ -1255,18 +1115,18 @@ class PaymentModule extends _BaseModule.BaseModule {
   standardRound(value, midpointUp) {
     const floorValue = value.floor();
     const fractionalPart = value.minus(floorValue);
-
-    // 检查是否是中点（小数部分 = 0.5）
     if (fractionalPart.eq(0.5)) {
-      // 中点情况，根据规则决定
       return midpointUp ? floorValue.plus(1) : floorValue;
     } else if (fractionalPart.gt(0.5)) {
-      // 大于中点，向上舍入
       return floorValue.plus(1);
     } else {
-      // 小于中点，向下舍入
       return floorValue;
     }
   }
-}
-exports.PaymentModule = PaymentModule;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PaymentModule,
+  generateRequestUniqueId,
+  ...require("./types")
+});