@pisell/pisellos 2.3.74 → 2.3.76

package/lib/modules/Payment/cash.js

@@ -1,36 +1,21 @@
-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 });
-};
-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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+"use strict";
 
-// src/modules/Payment/cash.ts
-var cash_exports = {};
-__export(cash_exports, {
-  CashPaymentImpl: () => CashPaymentImpl
+Object.defineProperty(exports, "__esModule", {
+  value: true
 });
-module.exports = __toCommonJS(cash_exports);
-var import_cashRecommendationAlgorithm = require("./cashRecommendationAlgorithm");
-var CashPaymentImpl = class {
+exports.CashPaymentImpl = void 0;
+var _cashRecommendationAlgorithm = require("./cashRecommendationAlgorithm");
+/**
+ * 现金支付实现
+ */
+class CashPaymentImpl {
   constructor(paymentModule) {
     this.paymentModule = paymentModule;
   }
   async processCashPayment(amount, orderUuid) {
     const cashMethod = await this.paymentModule.getCashPaymentMethod();
     if (!cashMethod) {
-      throw new Error("现金支付方式未找到");
+      throw new Error('现金支付方式未找到');
     }
     const paymentItem = {
       amount: amount.toString(),
@@ -38,13 +23,15 @@ var CashPaymentImpl = class {
       custom_payment_id: cashMethod.id,
       name: cashMethod.name,
       type: cashMethod.type,
-      voucher_id: ""
+      voucher_id: ''
     };
     await this.paymentModule.addPaymentItemAsync(orderUuid, paymentItem);
   }
   async getCashBalance() {
+    // 现金余额逻辑可以根据实际业务需求实现
     return 0;
   }
+
   /**
    * 获取推荐支付金额
    * 基于目标金额和货币类型，返回最优支付金额建议
@@ -53,12 +40,12 @@ var CashPaymentImpl = class {
    * @returns 推荐支付金额数组
    */
   getRecommendedAmount(money, currency) {
+    // 获取对应货币的面额配置
     const upperCurrency = currency.toUpperCase();
-    const denominations = import_cashRecommendationAlgorithm.CURRENCY_DENOMINATIONS[upperCurrency] || import_cashRecommendationAlgorithm.CURRENCY_DENOMINATIONS["DEFAULT"];
-    return (0, import_cashRecommendationAlgorithm.recommendOptimalPayments)(money, denominations);
+    const denominations = _cashRecommendationAlgorithm.CURRENCY_DENOMINATIONS[upperCurrency] || _cashRecommendationAlgorithm.CURRENCY_DENOMINATIONS['DEFAULT'];
+
+    // 直接调用算法，所有验证和容错处理都在算法内部
+    return (0, _cashRecommendationAlgorithm.recommendOptimalPayments)(money, denominations);
   }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  CashPaymentImpl
-});
+}
+exports.CashPaymentImpl = CashPaymentImpl;

package/lib/modules/Payment/cashRecommendationAlgorithm.js

@@ -1,83 +1,105 @@
-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 });
-};
-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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+"use strict";
 
-// src/modules/Payment/cashRecommendationAlgorithm.ts
-var cashRecommendationAlgorithm_exports = {};
-__export(cashRecommendationAlgorithm_exports, {
-  CURRENCY_DENOMINATIONS: () => CURRENCY_DENOMINATIONS,
-  recommendOptimalPayments: () => recommendOptimalPayments
+Object.defineProperty(exports, "__esModule", {
+  value: true
 });
-module.exports = __toCommonJS(cashRecommendationAlgorithm_exports);
-var CURRENCY_DENOMINATIONS = {
+exports.CURRENCY_DENOMINATIONS = void 0;
+exports.recommendOptimalPayments = recommendOptimalPayments;
+/**
+ * 现金支付推荐算法
+ * 
+ * 核心原理：
+ * 1. 每个推荐金额都应该是独立的最优组合
+ * 2. 不推荐在已有最优解基础上添加额外面额的组合
+ * 3. 优先推荐使用不同数量币种的组合
+ * 4. 根据组合判断去重，避免扩展组合
+ */
+
+/**
+ * 常见国家货币面额配置
+ */
+const CURRENCY_DENOMINATIONS = exports.CURRENCY_DENOMINATIONS = {
   // 美元
-  "USD": [100, 50, 20, 10, 5, 1, 0.5, 0.25, 0.1, 0.05, 0.01],
+  'USD': [100, 50, 20, 10, 5, 1, 0.5, 0.25, 0.1, 0.05, 0.01],
   // 人民币
-  "CNY": [100, 50, 20, 10, 5, 1, 0.5, 0.1, 0.05, 0.01],
-  "RMB": [100, 50, 20, 10, 5, 1, 0.5, 0.1, 0.05, 0.01],
+  'CNY': [100, 50, 20, 10, 5, 1, 0.5, 0.1, 0.05, 0.01],
+  'RMB': [100, 50, 20, 10, 5, 1, 0.5, 0.1, 0.05, 0.01],
   // 欧元
-  "EUR": [500, 200, 100, 50, 20, 10, 5, 2, 1, 0.5, 0.2, 0.1, 0.05, 0.02, 0.01],
+  'EUR': [500, 200, 100, 50, 20, 10, 5, 2, 1, 0.5, 0.2, 0.1, 0.05, 0.02, 0.01],
   // 日元
-  "JPY": [1e4, 5e3, 2e3, 1e3, 500, 100, 50, 10, 5, 1],
+  'JPY': [10000, 5000, 2000, 1000, 500, 100, 50, 10, 5, 1],
   // 英镑
-  "GBP": [50, 20, 10, 5, 2, 1, 0.5, 0.2, 0.1, 0.05, 0.02, 0.01],
+  'GBP': [50, 20, 10, 5, 2, 1, 0.5, 0.2, 0.1, 0.05, 0.02, 0.01],
   // 澳元
-  "AUD": [100, 50, 20, 10, 5, 2, 1, 0.5, 0.2, 0.1],
+  'AUD': [100, 50, 20, 10, 5, 2, 1, 0.5, 0.2, 0.1],
   // 加元
-  "CAD": [100, 50, 20, 10, 5, 2, 1, 0.25, 0.1, 0.05],
+  'CAD': [100, 50, 20, 10, 5, 2, 1, 0.25, 0.1, 0.05],
   // 港元
-  "HKD": [1e3, 500, 100, 50, 20, 10, 5, 2, 1, 0.5, 0.2, 0.1],
+  'HKD': [1000, 500, 100, 50, 20, 10, 5, 2, 1, 0.5, 0.2, 0.1],
   // 新台币
-  "TWD": [2e3, 1e3, 500, 200, 100, 50, 10, 5, 1],
+  'TWD': [2000, 1000, 500, 200, 100, 50, 10, 5, 1],
   // 韩元
-  "KRW": [5e4, 1e4, 5e3, 1e3, 500, 100, 50, 10, 5, 1],
+  'KRW': [50000, 10000, 5000, 1000, 500, 100, 50, 10, 5, 1],
   // 新加坡元
-  "SGD": [1e4, 1e3, 100, 50, 10, 5, 2, 1, 0.5, 0.2, 0.1, 0.05, 0.01],
+  'SGD': [10000, 1000, 100, 50, 10, 5, 2, 1, 0.5, 0.2, 0.1, 0.05, 0.01],
   // 瑞士法郎
-  "CHF": [1e3, 200, 100, 50, 20, 10, 5, 2, 1, 0.5, 0.2, 0.1, 0.05],
+  'CHF': [1000, 200, 100, 50, 20, 10, 5, 2, 1, 0.5, 0.2, 0.1, 0.05],
   // 默认通用面额（如果币种不在列表中）
-  "DEFAULT": [100, 50, 20, 10, 5, 1, 0.5, 0.25, 0.1, 0.05, 0.01]
+  'DEFAULT': [100, 50, 20, 10, 5, 1, 0.5, 0.25, 0.1, 0.05, 0.01]
 };
+
+/**
+ * 支付组合类型定义
+ */
+
+/**
+ * 最优支付金额推荐算法
+ * 推荐通过不同数量面额组合刚好足够支付的最小金额
+ * 
+ * @param targetAmount 目标金额
+ * @param denominations 币种面值数组
+ * @returns 推荐支付金额数组
+ */
 function recommendOptimalPayments(targetAmount, denominations) {
+  // 参数验证
   if (targetAmount <= 0 || !isFinite(targetAmount) || isNaN(targetAmount)) {
     return [];
   }
   if (!denominations || !Array.isArray(denominations) || denominations.length === 0) {
     return [Math.ceil(targetAmount)];
   }
-  const maxReasonableDenom = targetAmount * 5;
-  const validDenoms = denominations.filter((denom) => denom > 0 && isFinite(denom) && !isNaN(denom) && denom <= maxReasonableDenom).slice(0, 8);
+
+  // 过滤有效面额并限制搜索空间以提高性能
+  const maxReasonableDenom = targetAmount * 5; // 适度限制搜索空间
+  const validDenoms = denominations.filter(denom => denom > 0 && isFinite(denom) && !isNaN(denom) && denom <= maxReasonableDenom).slice(0, 8); // 限制面额数量以提高性能
+
   if (validDenoms.length === 0) {
+    // 如果没有合适的面额，返回最接近的整数金额
     return [Math.ceil(targetAmount)];
   }
   try {
-    const precision = 100;
+    // 处理精度问题，将金额转换为整数计算
+    const precision = 100; // 假设最小单位是0.01
     const target = Math.round(targetAmount * precision);
-    const denoms = validDenoms.map((d) => Math.round(d * precision)).sort((a, b) => b - a);
+    const denoms = validDenoms.map(d => Math.round(d * precision)).sort((a, b) => b - a);
+
+    // 存储不同的支付组合方案
     const paymentOptions = [];
+
+    // 首先尝试找到精确匹配的组合
     const exactCombination = findExactCombination(target, denoms, precision);
     if (exactCombination) {
       paymentOptions.push(exactCombination);
     }
+
+    // 为了提高效率，我们将按币种数量来生成组合
+    // 1币种组合：只用一种面额
     for (let i = 0; i < Math.min(denoms.length, 6); i++) {
       const denom = denoms[i];
       const count = Math.ceil(target / denom);
       const sum = count * denom;
       if (sum >= target && count <= 12) {
+        // 限制硬币数量以提高性能
         paymentOptions.push({
           combination: Array(count).fill(denom / precision),
           sum: sum / precision,
@@ -86,22 +108,23 @@ function recommendOptimalPayments(targetAmount, denominations) {
         });
       }
     }
+
+    // 2币种组合：使用两种面额（大幅限制搜索范围以提高性能）
     for (let i = 0; i < Math.min(denoms.length - 1, 5); i++) {
       for (let j = i + 1; j < Math.min(denoms.length, 6); j++) {
         const denom1 = denoms[i];
         const denom2 = denoms[j];
+
+        // 大幅限制搜索范围，基于目标金额动态调整
         const maxCount1 = Math.min(Math.ceil(target / denom1) + 1, 8);
         const maxCount2 = Math.min(Math.ceil(target / denom2) + 1, 10);
         for (let count1 = 1; count1 <= maxCount1; count1++) {
           for (let count2 = 1; count2 <= maxCount2; count2++) {
             const sum = count1 * denom1 + count2 * denom2;
             if (sum >= target) {
-              const combination = [
-                ...Array(count1).fill(denom1 / precision),
-                ...Array(count2).fill(denom2 / precision)
-              ];
+              const combination = [...Array(count1).fill(denom1 / precision), ...Array(count2).fill(denom2 / precision)];
               paymentOptions.push({
-                combination,
+                combination: combination,
                 sum: sum / precision,
                 coinCount: count1 + count2,
                 denomTypes: 2
@@ -111,12 +134,16 @@ function recommendOptimalPayments(targetAmount, denominations) {
         }
       }
     }
+
+    // 3币种组合：使用三种面额（大幅限制搜索以提高效率）
     for (let i = 0; i < Math.min(denoms.length - 2, 3); i++) {
       for (let j = i + 1; j < Math.min(denoms.length - 1, 4); j++) {
         for (let k = j + 1; k < Math.min(denoms.length, 5); k++) {
           const denom1 = denoms[i];
           const denom2 = denoms[j];
           const denom3 = denoms[k];
+
+          // 大幅限制搜索范围
           const maxCount1 = Math.min(Math.ceil(target / denom1) + 1, 5);
           const maxCount2 = Math.min(Math.ceil(target / denom2) + 1, 6);
           const maxCount3 = Math.min(Math.ceil(target / denom3) + 1, 8);
@@ -125,13 +152,9 @@ function recommendOptimalPayments(targetAmount, denominations) {
               for (let count3 = 1; count3 <= maxCount3; count3++) {
                 const sum = count1 * denom1 + count2 * denom2 + count3 * denom3;
                 if (sum >= target) {
-                  const combination = [
-                    ...Array(count1).fill(denom1 / precision),
-                    ...Array(count2).fill(denom2 / precision),
-                    ...Array(count3).fill(denom3 / precision)
-                  ];
+                  const combination = [...Array(count1).fill(denom1 / precision), ...Array(count2).fill(denom2 / precision), ...Array(count3).fill(denom3 / precision)];
                   paymentOptions.push({
-                    combination,
+                    combination: combination,
                     sum: sum / precision,
                     coinCount: count1 + count2 + count3,
                     denomTypes: 3
@@ -143,6 +166,8 @@ function recommendOptimalPayments(targetAmount, denominations) {
         }
       }
     }
+
+    // 4币种组合：使用四种面额（极度限制搜索以提高性能）
     for (let i = 0; i < Math.min(denoms.length - 3, 2); i++) {
       for (let j = i + 1; j < Math.min(denoms.length - 2, 3); j++) {
         for (let k = j + 1; k < Math.min(denoms.length - 1, 4); k++) {
@@ -151,6 +176,8 @@ function recommendOptimalPayments(targetAmount, denominations) {
             const denom2 = denoms[j];
             const denom3 = denoms[k];
             const denom4 = denoms[l];
+
+            // 极度限制搜索范围
             const maxCount1 = Math.min(Math.ceil(target / denom1) + 1, 3);
             const maxCount2 = Math.min(Math.ceil(target / denom2) + 1, 4);
             const maxCount3 = Math.min(Math.ceil(target / denom3) + 1, 5);
@@ -161,14 +188,9 @@ function recommendOptimalPayments(targetAmount, denominations) {
                   for (let count4 = 1; count4 <= maxCount4; count4++) {
                     const sum = count1 * denom1 + count2 * denom2 + count3 * denom3 + count4 * denom4;
                     if (sum >= target) {
-                      const combination = [
-                        ...Array(count1).fill(denom1 / precision),
-                        ...Array(count2).fill(denom2 / precision),
-                        ...Array(count3).fill(denom3 / precision),
-                        ...Array(count4).fill(denom4 / precision)
-                      ];
+                      const combination = [...Array(count1).fill(denom1 / precision), ...Array(count2).fill(denom2 / precision), ...Array(count3).fill(denom3 / precision), ...Array(count4).fill(denom4 / precision)];
                       paymentOptions.push({
-                        combination,
+                        combination: combination,
                         sum: sum / precision,
                         coinCount: count1 + count2 + count3 + count4,
                         denomTypes: 4
@@ -182,17 +204,25 @@ function recommendOptimalPayments(targetAmount, denominations) {
         }
       }
     }
+
+    // 如果没有找到任何组合，提供默认建议
     if (paymentOptions.length === 0) {
-      const minValidDenom = validDenoms.find((denom) => denom >= targetAmount);
+      // 找到大于等于目标金额的最小面额
+      const minValidDenom = validDenoms.find(denom => denom >= targetAmount);
       if (minValidDenom) {
         return [minValidDenom];
       } else {
+        // 使用最大面额的组合
         const maxDenom = Math.max(...validDenoms);
         const count = Math.ceil(targetAmount / maxDenom);
         return [count * maxDenom];
       }
     }
+
+    // 移除重复和扩展组合
     const uniqueCombinations = removeDuplicateAndExtendedCombinations(paymentOptions, targetAmount);
+
+    // 按币种类型数量排序，然后按总硬币数量排序，最后按金额排序
     uniqueCombinations.sort((a, b) => {
       if (a.denomTypes !== b.denomTypes) {
         return a.denomTypes - b.denomTypes;
@@ -202,10 +232,12 @@ function recommendOptimalPayments(targetAmount, denominations) {
       }
       return a.sum - b.sum;
     });
-    const uniqueAmounts = /* @__PURE__ */ new Set();
+
+    // 按金额去重并返回推荐的支付金额
+    const uniqueAmounts = new Set();
     const finalResults = [];
     for (const item of uniqueCombinations) {
-      const roundedAmount = Math.round(item.sum * 100) / 100;
+      const roundedAmount = Math.round(item.sum * 100) / 100; // 处理浮点数精度
       if (!uniqueAmounts.has(roundedAmount) && finalResults.length < 10) {
         uniqueAmounts.add(roundedAmount);
         finalResults.push(roundedAmount);
@@ -213,12 +245,19 @@ function recommendOptimalPayments(targetAmount, denominations) {
     }
     return finalResults.sort((a, b) => a - b);
   } catch (error) {
-    console.warn("推荐支付金额计算出错:", error);
+    // 发生错误时返回安全的默认值
+    console.warn('推荐支付金额计算出错:', error);
+    // 返回最接近的整数金额作为兜底
     const safeAmount = Math.ceil(targetAmount);
     return [targetAmount, safeAmount];
   }
 }
+
+/**
+ * 尝试找到精确匹配目标金额的组合
+ */
 function findExactCombination(target, denoms, precision) {
+  // 简单的深度优先搜索，限制搜索深度
   function dfs(remaining, denomIndex, currentCombination) {
     if (remaining === 0) {
       return currentCombination;
@@ -227,6 +266,8 @@ function findExactCombination(target, denoms, precision) {
       return null;
     }
     const denom = denoms[denomIndex];
+
+    // 尝试使用当前面额 0 到 maxCount 次
     const maxCount = Math.min(Math.floor(remaining / denom), 8);
     for (let count = maxCount; count >= 0; count--) {
       const newCombination = [...currentCombination, ...Array(count).fill(denom)];
@@ -241,16 +282,23 @@ function findExactCombination(target, denoms, precision) {
   if (exactMatch && exactMatch.length > 0) {
     const denomTypes = new Set(exactMatch).size;
     return {
-      combination: exactMatch.map((d) => d / precision),
+      combination: exactMatch.map(d => d / precision),
       sum: target / precision,
       coinCount: exactMatch.length,
-      denomTypes
+      denomTypes: denomTypes
     };
   }
   return null;
 }
+
+/**
+ * 移除重复和扩展组合
+ * 核心原理：如果组合A包含组合B的所有硬币，并且还有额外硬币，则A是B的扩展，应该被移除
+ */
 function removeDuplicateAndExtendedCombinations(combinations, targetAmount) {
   const result = [];
+
+  // 按币种类型数量、硬币数量、金额排序，确保较简单的组合在前面
   combinations.sort((a, b) => {
     if (a.denomTypes !== b.denomTypes) {
       return a.denomTypes - b.denomTypes;
@@ -263,18 +311,27 @@ function removeDuplicateAndExtendedCombinations(combinations, targetAmount) {
   for (let i = 0; i < combinations.length; i++) {
     const current = combinations[i];
     let shouldSkip = false;
+
+    // 检查当前组合是否与已添加的组合重复或者是扩展
     for (let j = 0; j < result.length; j++) {
       const existing = result[j];
+
+      // 如果完全相同，跳过
       if (isSameCombination(current.combination, existing.combination)) {
         shouldSkip = true;
         break;
       }
+
+      // 如果当前组合是已存在组合的扩展，跳过
       if (isExtensionOf(current.combination, existing.combination)) {
         shouldSkip = true;
         break;
       }
     }
+
+    // 检查是否有其他组合是当前组合的扩展，如果有，移除那些扩展
     if (!shouldSkip) {
+      // 移除所有当前组合的扩展
       for (let j = result.length - 1; j >= 0; j--) {
         if (isExtensionOf(result[j].combination, current.combination)) {
           result.splice(j, 1);
@@ -285,23 +342,34 @@ function removeDuplicateAndExtendedCombinations(combinations, targetAmount) {
   }
   return result;
 }
+
+/**
+ * 检查组合A是否是组合B的扩展（即A包含B的所有硬币，并且还有额外的硬币）
+ */
 function isExtensionOf(combinationA, combinationB) {
+  // 如果A的硬币数量少于等于B，A不可能是B的扩展
   if (combinationA.length <= combinationB.length) {
     return false;
   }
+
+  // 统计每个面额的数量
   const countA = {};
   const countB = {};
-  combinationA.forEach((coin) => {
+  combinationA.forEach(coin => {
     countA[coin] = (countA[coin] || 0) + 1;
   });
-  combinationB.forEach((coin) => {
+  combinationB.forEach(coin => {
     countB[coin] = (countB[coin] || 0) + 1;
   });
+
+  // 检查B的所有面额在A中是否都有足够的数量
   for (const coin in countB) {
     if (!countA[coin] || countA[coin] < countB[coin]) {
       return false;
     }
   }
+
+  // 检查A是否有B没有的额外硬币
   let hasExtra = false;
   for (const coin in countA) {
     if (countA[coin] > (countB[coin] || 0)) {
@@ -311,18 +379,24 @@ function isExtensionOf(combinationA, combinationB) {
   }
   return hasExtra;
 }
+
+/**
+ * 检查两个组合是否本质相同（相同的面额组合）
+ */
 function isSameCombination(combinationA, combinationB) {
   if (combinationA.length !== combinationB.length) {
     return false;
   }
   const countA = {};
   const countB = {};
-  combinationA.forEach((coin) => {
+  combinationA.forEach(coin => {
     countA[coin] = (countA[coin] || 0) + 1;
   });
-  combinationB.forEach((coin) => {
+  combinationB.forEach(coin => {
     countB[coin] = (countB[coin] || 0) + 1;
   });
+
+  // 检查两个组合是否有相同的面额和数量
   for (const coin in countA) {
     if (countA[coin] !== (countB[coin] || 0)) {
       return false;
@@ -334,9 +408,4 @@ function isSameCombination(combinationA, combinationB) {
     }
   }
   return true;
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  CURRENCY_DENOMINATIONS,
-  recommendOptimalPayments
-});
+}

package/lib/modules/Payment/eftpos.js

@@ -1,51 +1,37 @@
-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 });
-};
-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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+"use strict";
 
-// src/modules/Payment/eftpos.ts
-var eftpos_exports = {};
-__export(eftpos_exports, {
-  EftposPaymentImpl: () => EftposPaymentImpl
+Object.defineProperty(exports, "__esModule", {
+  value: true
 });
-module.exports = __toCommonJS(eftpos_exports);
-var EftposPaymentImpl = class {
+exports.EftposPaymentImpl = void 0;
+/**
+ * Eftpos支付实现
+ */
+class EftposPaymentImpl {
   constructor(paymentModule) {
     this.paymentModule = paymentModule;
   }
   async processEftposPayment(amount, orderUuid) {
     const eftposMethod = await this.paymentModule.getEftposPaymentMethod();
     if (!eftposMethod) {
-      throw new Error("Eftpos支付方式未找到");
+      throw new Error('Eftpos支付方式未找到');
     }
+
+    // 这里应该调用实际的Eftpos组件
+    // 假设Eftpos支付成功，创建支付项
     const paymentItem = {
       amount: amount.toString(),
       code: eftposMethod.code,
       custom_payment_id: eftposMethod.id,
       name: eftposMethod.name,
       type: eftposMethod.type,
-      voucher_id: ""
+      voucher_id: ''
     };
     await this.paymentModule.addPaymentItemAsync(orderUuid, paymentItem);
   }
   async checkDeviceStatus() {
+    // 检查Eftpos设备状态的逻辑
     return true;
   }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  EftposPaymentImpl
-});
+}
+exports.EftposPaymentImpl = EftposPaymentImpl;