@pisell/pisellos 0.0.569 → 0.10.2

package/lib/modules/Payment/cash.js

@@ -1,21 +1,36 @@
-"use strict";
+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);
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
+// src/modules/Payment/cash.ts
+var cash_exports = {};
+__export(cash_exports, {
+  CashPaymentImpl: () => CashPaymentImpl
 });
-exports.CashPaymentImpl = void 0;
-var _cashRecommendationAlgorithm = require("./cashRecommendationAlgorithm");
-/**
- * 现金支付实现
- */
-class CashPaymentImpl {
+module.exports = __toCommonJS(cash_exports);
+var import_cashRecommendationAlgorithm = require("./cashRecommendationAlgorithm");
+var CashPaymentImpl = class {
   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(),
@@ -23,15 +38,13 @@ class CashPaymentImpl {
       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;
   }
-
   /**
    * 获取推荐支付金额
    * 基于目标金额和货币类型，返回最优支付金额建议
@@ -40,12 +53,12 @@ class CashPaymentImpl {
    * @returns 推荐支付金额数组
    */
   getRecommendedAmount(money, currency) {
-    // 获取对应货币的面额配置
     const upperCurrency = currency.toUpperCase();
-    const denominations = _cashRecommendationAlgorithm.CURRENCY_DENOMINATIONS[upperCurrency] || _cashRecommendationAlgorithm.CURRENCY_DENOMINATIONS['DEFAULT'];
-
-    // 直接调用算法，所有验证和容错处理都在算法内部
-    return (0, _cashRecommendationAlgorithm.recommendOptimalPayments)(money, denominations);
+    const denominations = import_cashRecommendationAlgorithm.CURRENCY_DENOMINATIONS[upperCurrency] || import_cashRecommendationAlgorithm.CURRENCY_DENOMINATIONS["DEFAULT"];
+    return (0, import_cashRecommendationAlgorithm.recommendOptimalPayments)(money, denominations);
   }
-}
-exports.CashPaymentImpl = CashPaymentImpl;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CashPaymentImpl
+});

package/lib/modules/Payment/cashRecommendationAlgorithm.js

@@ -1,105 +1,83 @@
-"use strict";
+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);
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
+// src/modules/Payment/cashRecommendationAlgorithm.ts
+var cashRecommendationAlgorithm_exports = {};
+__export(cashRecommendationAlgorithm_exports, {
+  CURRENCY_DENOMINATIONS: () => CURRENCY_DENOMINATIONS,
+  recommendOptimalPayments: () => recommendOptimalPayments
 });
-exports.CURRENCY_DENOMINATIONS = void 0;
-exports.recommendOptimalPayments = recommendOptimalPayments;
-/**
- * 现金支付推荐算法
- * 
- * 核心原理：
- * 1. 每个推荐金额都应该是独立的最优组合
- * 2. 不推荐在已有最优解基础上添加额外面额的组合
- * 3. 优先推荐使用不同数量币种的组合
- * 4. 根据组合判断去重，避免扩展组合
- */
-
-/**
- * 常见国家货币面额配置
- */
-const CURRENCY_DENOMINATIONS = exports.CURRENCY_DENOMINATIONS = {
+module.exports = __toCommonJS(cashRecommendationAlgorithm_exports);
+var 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': [10000, 5000, 2000, 1000, 500, 100, 50, 10, 5, 1],
+  "JPY": [1e4, 5e3, 2e3, 1e3, 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': [1000, 500, 100, 50, 20, 10, 5, 2, 1, 0.5, 0.2, 0.1],
+  "HKD": [1e3, 500, 100, 50, 20, 10, 5, 2, 1, 0.5, 0.2, 0.1],
   // 新台币
-  'TWD': [2000, 1000, 500, 200, 100, 50, 10, 5, 1],
+  "TWD": [2e3, 1e3, 500, 200, 100, 50, 10, 5, 1],
   // 韩元
-  'KRW': [50000, 10000, 5000, 1000, 500, 100, 50, 10, 5, 1],
+  "KRW": [5e4, 1e4, 5e3, 1e3, 500, 100, 50, 10, 5, 1],
   // 新加坡元
-  'SGD': [10000, 1000, 100, 50, 10, 5, 2, 1, 0.5, 0.2, 0.1, 0.05, 0.01],
+  "SGD": [1e4, 1e3, 100, 50, 10, 5, 2, 1, 0.5, 0.2, 0.1, 0.05, 0.01],
   // 瑞士法郎
-  'CHF': [1000, 200, 100, 50, 20, 10, 5, 2, 1, 0.5, 0.2, 0.1, 0.05],
+  "CHF": [1e3, 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; // 假设最小单位是0.01
+    const precision = 100;
     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,
@@ -108,23 +86,22 @@ 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
@@ -134,16 +111,12 @@ 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);
@@ -152,9 +125,13 @@ 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
@@ -166,8 +143,6 @@ 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++) {
@@ -176,8 +151,6 @@ 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);
@@ -188,9 +161,14 @@ 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
@@ -204,25 +182,17 @@ 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;
@@ -232,12 +202,10 @@ function recommendOptimalPayments(targetAmount, denominations) {
       }
       return a.sum - b.sum;
     });
-
-    // 按金额去重并返回推荐的支付金额
-    const uniqueAmounts = new Set();
+    const uniqueAmounts = /* @__PURE__ */ 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);
@@ -245,19 +213,12 @@ 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;
@@ -266,8 +227,6 @@ 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)];
@@ -282,23 +241,16 @@ 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;
@@ -311,27 +263,18 @@ 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);
@@ -342,34 +285,23 @@ 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)) {
@@ -379,24 +311,18 @@ 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;
@@ -408,4 +334,9 @@ 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,37 +1,51 @@
-"use strict";
+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);
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
+// src/modules/Payment/eftpos.ts
+var eftpos_exports = {};
+__export(eftpos_exports, {
+  EftposPaymentImpl: () => EftposPaymentImpl
 });
-exports.EftposPaymentImpl = void 0;
-/**
- * Eftpos支付实现
- */
-class EftposPaymentImpl {
+module.exports = __toCommonJS(eftpos_exports);
+var EftposPaymentImpl = class {
   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;
   }
-}
-exports.EftposPaymentImpl = EftposPaymentImpl;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EftposPaymentImpl
+});