@pisell/pisellos 0.0.327 → 0.0.329

package/dist/effects/index.d.ts

@@ -6,6 +6,7 @@ type UnsubscribeFunction = () => void;
 declare class EffectsManager {
     private listeners;
     on(event: string, callback: EffectCallback): UnsubscribeFunction;
+    only(event: string, callback: EffectCallback): UnsubscribeFunction;
     off(event: string, callback: EffectCallback): void;
     offByModuleDestroy(module: string): void;
     once(event: string, callback: EffectCallback): UnsubscribeFunction;

package/dist/effects/index.js

@@ -30,28 +30,51 @@ var EffectsManager = /*#__PURE__*/function () {
         _this.off(event, callback);
       };
     }
+
+    // 设置单例监听器，只能存在一个，新的会替换旧的
+  }, {
+    key: "only",
+    value: function only(event, callback) {
+      var _this$listeners$get3,
+        _this2 = this;
+      // 清除该事件的所有现有监听器
+      if (this.listeners.has(event)) {
+        var _this$listeners$get2;
+        (_this$listeners$get2 = this.listeners.get(event)) === null || _this$listeners$get2 === void 0 || _this$listeners$get2.clear();
+      } else {
+        this.listeners.set(event, new Set());
+      }
+
+      // 添加新的监听器
+      (_this$listeners$get3 = this.listeners.get(event)) === null || _this$listeners$get3 === void 0 || _this$listeners$get3.add(callback);
+
+      // 返回取消函数
+      return function () {
+        _this2.off(event, callback);
+      };
+    }
   }, {
     key: "off",
     value: function off(event, callback) {
-      var _this$listeners$get2;
-      (_this$listeners$get2 = this.listeners.get(event)) === null || _this$listeners$get2 === void 0 || _this$listeners$get2.delete(callback);
+      var _this$listeners$get4;
+      (_this$listeners$get4 = this.listeners.get(event)) === null || _this$listeners$get4 === void 0 || _this$listeners$get4.delete(callback);
     }
 
     // 模块销毁时，删除所有以模块名开头的监听
   }, {
     key: "offByModuleDestroy",
     value: function offByModuleDestroy(module) {
-      var _this2 = this;
+      var _this3 = this;
       Array.from(this.listeners.keys()).forEach(function (item) {
         if (item.startsWith(module)) {
-          _this2.listeners.delete(item);
+          _this3.listeners.delete(item);
         }
       });
     }
   }, {
     key: "once",
     value: function once(event, callback) {
-      var _this3 = this;
+      var _this4 = this;
       var wrapper = /*#__PURE__*/function () {
         var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(payload) {
           return _regeneratorRuntime().wrap(function _callee$(_context) {
@@ -60,7 +83,7 @@ var EffectsManager = /*#__PURE__*/function () {
                 _context.next = 2;
                 return callback(payload);
               case 2:
-                _this3.off(event, wrapper);
+                _this4.off(event, wrapper);
               case 3:
               case "end":
                 return _context.stop();

package/dist/modules/Payment/index.js

@@ -131,6 +131,10 @@ export var PaymentModule = /*#__PURE__*/function (_BaseModule) {
               return this.ensurePaymentTables();
             case 14:
               this.registerNetworkHandlers();
+
+              // // 预连接数据库
+              // this.dbManager.connect()
+
               console.log('[PaymentModule] 初始化完成');
               this.logInfo('PaymentModule initialized successfully');
             case 17:
@@ -657,7 +661,8 @@ export var PaymentModule = /*#__PURE__*/function (_BaseModule) {
     key: "createPaymentOrderAsync",
     value: (function () {
       var _createPaymentOrderAsync = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee7(params) {
-        var existingOrder, newOrder;
+        var _this3 = this;
+        var newOrder, dbAddStartTime, dbAddDuration;
         return _regeneratorRuntime().wrap(function _callee7$(_context7) {
           while (1) switch (_context7.prev = _context7.next) {
             case 0:
@@ -666,41 +671,41 @@ export var PaymentModule = /*#__PURE__*/function (_BaseModule) {
                 totalAmount: params.total_amount
               });
               _context7.prev = 1;
-              _context7.next = 4;
-              return this.dbManager.get('order', params.order_id);
-            case 4:
-              existingOrder = _context7.sent;
-              this.logInfo('createPaymentOrderAsync existingOrder', {
-                existingOrder: existingOrder
-              });
+              // 检测是否有重复的 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),
               // );
-              if (!existingOrder) {
-                _context7.next = 20;
-                break;
-              }
-              // 如果存在相同 order_id 的订单，更新该订单信息
-              this.logInfo("createPaymentOrderAsync found duplicate order ID: ".concat(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);
-
-              // 更新到数据库
-              _context7.next = 15;
-              return this.dbManager.update('order', existingOrder);
-            case 15:
-              _context7.next = 17;
-              return this.core.effects.emit("".concat(this.name, ":onOrderUpdated"), existingOrder);
-            case 17:
-              return _context7.abrupt("return", existingOrder);
-            case 20:
+              // 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 {
               // 创建新的支付订单
               newOrder = {
                 uuid: getUniqueId('pay_order_'),
@@ -715,32 +720,37 @@ export var PaymentModule = /*#__PURE__*/function (_BaseModule) {
                 tax_fee: '0.00',
                 is_deposit: params.is_deposit || 0,
                 deposit_amount: params.deposit_amount || '0.00'
-              };
-              _context7.next = 23;
+              }; // 🚀 性能监控：记录数据库添加操作耗时
+              dbAddStartTime = Date.now();
+              _context7.next = 6;
               return this.dbManager.add('order', newOrder);
-            case 23:
-              this.core.effects.emit("".concat(this.name, ":onOrderAdded"), newOrder);
-              this.logInfo('createPaymentOrderAsync completed - new payment order created', {
+            case 6:
+              dbAddDuration = Date.now() - dbAddStartTime;
+              this.logInfo('Database add operation completed', {
+                operation: 'dbManager.add',
+                table: 'order',
                 orderUuid: newOrder.uuid,
-                orderId: newOrder.id
+                orderId: newOrder.order_id,
+                duration: "".concat(dbAddDuration, "ms"),
+                performance: dbAddDuration > 100 ? 'slow' : dbAddDuration > 50 ? 'medium' : 'fast'
               });
+              setTimeout(function () {
+                _this3.core.effects.emit("".concat(_this3.name, ":onOrderAdded"), newOrder);
+              }, 0);
               return _context7.abrupt("return", newOrder);
-            case 26:
-              _context7.next = 33;
-              break;
-            case 28:
-              _context7.prev = 28;
+            case 12:
+              _context7.prev = 12;
               _context7.t0 = _context7["catch"](1);
               console.error('[PaymentModule] 创建支付订单失败', _context7.t0);
               this.logError('createPaymentOrderAsync failed', _context7.t0, {
                 orderId: params.order_id
               });
               throw _context7.t0;
-            case 33:
+            case 17:
             case "end":
               return _context7.stop();
           }
-        }, _callee7, this, [[1, 28]]);
+        }, _callee7, this, [[1, 12]]);
       }));
       function createPaymentOrderAsync(_x6) {
         return _createPaymentOrderAsync.apply(this, arguments);

package/dist/solution/BookingTicket/index.d.ts

@@ -22,6 +22,10 @@ export declare class BookingTicketImpl extends BaseModule implements Module {
      * @returns 商品列表
      */
     loadProducts(params?: ILoadProductsParams): Promise<any>;
+    /**
+     * 初始化外设扫码结果监听
+     */
+    initPeripheralsListener(): void;
     /**
      * 获取商品列表（不加载到模块中）
      * @returns 商品列表

package/dist/solution/BookingTicket/index.js

@@ -170,11 +170,20 @@ export var BookingTicketImpl = /*#__PURE__*/function (_BaseModule) {
       }
       return loadProducts;
     }()
+    /**
+     * 初始化外设扫码结果监听
+     */
+    )
+  }, {
+    key: "initPeripheralsListener",
+    value: function initPeripheralsListener() {
+      this.scan.initPeripheralsListener();
+    }
+
     /**
      * 获取商品列表（不加载到模块中）
      * @returns 商品列表
      */
-    )
   }, {
     key: "getProducts",
     value: (function () {

package/dist/solution/BookingTicket/utils/scan/index.d.ts

@@ -18,6 +18,10 @@ export default class Scan {
     private watchKey;
     private listenerConfig;
     constructor(solution: BookingTicketImpl, watchKey: string);
+    /**
+     * 初始化外设扫码结果监听
+     */
+    initPeripheralsListener(): void;
     /**
      * 处理扫码事件
      * @param eventKey 事件key

package/dist/solution/BookingTicket/utils/scan/index.js

@@ -18,9 +18,6 @@ var ScanResultType = /*#__PURE__*/function (ScanResultType) {
 }(ScanResultType || {});
 var Scan = /*#__PURE__*/function () {
   function Scan(solution, watchKey) {
-    var _this$solution,
-      _this$solution$mountF,
-      _this = this;
     _classCallCheck(this, Scan);
     _defineProperty(this, "solution", void 0);
     _defineProperty(this, "watchKey", void 0);
@@ -28,24 +25,36 @@ var Scan = /*#__PURE__*/function () {
     this.solution = solution;
     this.watchKey = watchKey;
 
-    // 监听扫码结果
-    (_this$solution = this.solution) === null || _this$solution === void 0 || (_this$solution = _this$solution.window) === null || _this$solution === void 0 || (_this$solution = _this$solution.interaction) === null || _this$solution === void 0 || (_this$solution = _this$solution.utils) === null || _this$solution === void 0 || (_this$solution$mountF = _this$solution.mountFunction) === null || _this$solution$mountF === void 0 || _this$solution$mountF.call(_this$solution, 'global', 'peripheralsResult', function (strVal) {
-      try {
-        var _result = JSON.parse(strVal);
-        console.log('nativeScannerResult>>>>>>>', _result);
-        _this.handleScan(_result);
-      } catch (err) {
-        console.error(err);
-      }
-    });
+    // 初始化扫码监听
+    this.initPeripheralsListener();
   }
 
   /**
-   * 处理扫码事件
-   * @param eventKey 事件key
-   * @param value 扫码结果
+   * 初始化外设扫码结果监听
    */
   _createClass(Scan, [{
+    key: "initPeripheralsListener",
+    value: function initPeripheralsListener() {
+      var _this$solution,
+        _this$solution$mountF,
+        _this = this;
+      (_this$solution = this.solution) === null || _this$solution === void 0 || (_this$solution = _this$solution.window) === null || _this$solution === void 0 || (_this$solution = _this$solution.interaction) === null || _this$solution === void 0 || (_this$solution = _this$solution.utils) === null || _this$solution === void 0 || (_this$solution$mountF = _this$solution.mountFunction) === null || _this$solution$mountF === void 0 || _this$solution$mountF.call(_this$solution, 'global', 'peripheralsResult', function (strVal) {
+        try {
+          var _result = JSON.parse(strVal);
+          console.log('nativeScannerResult>>>>>>>', _result);
+          _this.handleScan(_result);
+        } catch (err) {
+          console.error(err);
+        }
+      });
+    }
+
+    /**
+     * 处理扫码事件
+     * @param eventKey 事件key
+     * @param value 扫码结果
+     */
+  }, {
     key: "handleScan",
     value: function handleScan(result) {
       var lastEnableEventKey = watch.getLastEnableEventKey(this.watchKey);

package/dist/solution/Checkout/index.d.ts

@@ -19,6 +19,7 @@ export declare class CheckoutImpl extends BaseModule implements Module, Checkout
     private store;
     private otherParams;
     private logger;
+    private calculationCache;
     order: OrderModule;
     payment: PaymentModule;
     constructor(name?: string, version?: string);
@@ -302,16 +303,46 @@ export declare class CheckoutImpl extends BaseModule implements Module, Checkout
      * 删除本地 IndexDB 中超过指定天数且已同步到后端的订单数据
      */
     private cleanupExpiredOrdersAsync;
+    /**
+     * 清除计算缓存
+     */
+    private clearCalculationCache;
+    /**
+     * 批量获取订单数据（用于性能优化）
+     * 一次性获取所有需要的数据，避免重复查询
+     */
+    private fetchOrderDataBatch;
+    /**
+     * 从支付项数组计算已支付金额（纯计算，不查询数据库）
+     */
+    private calculatePaidAmountFromItems;
     /**
      * 计算已支付金额（从 Payment 模块获取最新数据）
+     *
+     * 注意：此方法保持独立性，可以单独调用。
+     * 在 updateStateAmountToRemaining 等批量操作中会使用缓存优化。
      */
     private calculatePaidAmountAsync;
+    /**
+     * 从订单和支付项计算剩余金额（纯计算，不查询数据库）
+     */
+    private calculateRemainingAmountFromData;
+    /**
+     * 从订单和支付项计算剩余总金额（纯计算，排除定金）
+     */
+    private calculateRemainingTotalAmountFromData;
     /**
      * 计算剩余未支付金额（从 Payment 模块获取最新数据）
+     *
+     * 注意：此方法保持独立性，可以单独调用。
+     * 在 updateStateAmountToRemaining 等批量操作中会使用缓存优化。
      */
     private calculateRemainingAmountAsync;
     /**
      * 计算剩余未支付金额（排除定金计算，始终使用订单总金额）
+     *
+     * 注意：此方法保持独立性，可以单独调用。
+     * 在 updateStateAmountToRemaining 等批量操作中会使用缓存优化。
      */
     private calculateRemainingTotalAmountAsync;
     /**
@@ -320,12 +351,24 @@ export declare class CheckoutImpl extends BaseModule implements Module, Checkout
     private updateBalanceDueAmount;
     /**
      * 更新 stateAmount 为当前剩余未支付金额
+     *
+     * 优化版本：批量获取数据，避免重复查询数据库
      */
     private updateStateAmountToRemaining;
+    /**
+     * 检查订单支付是否完成（优化版，复用已获取的数据）
+     *
+     * @param paymentItems 已获取的支付项数据
+     * @param remainingAmount 已计算的剩余金额
+     */
+    private checkOrderPaymentCompletionOptimized;
     /**
      * 检查订单支付是否完成
      *
      * 当剩余待付款金额 <= 0 时，触发订单支付完成事件
+     *
+     * 注意：此方法保持独立性，可以单独调用。
+     * 在 updateStateAmountToRemaining 中会使用优化版本。
      */
     private checkOrderPaymentCompletion;
     /**
@@ -381,6 +424,8 @@ export declare class CheckoutImpl extends BaseModule implements Module, Checkout
      * 重置 store 状态
      *
      * 在创建新订单前调用，确保状态完全干净
+     *
+     * 🚀 性能优化：改为同步方法，事件发射不阻塞主流程
      */
-    private resetStoreStateAsync;
+    private resetStoreState;
 }