@pisell/pisellos 0.0.327 → 0.0.329

package/dist/solution/ShopDiscount/index.js

@@ -195,7 +195,7 @@ export var ShopDiscountImpl = /*#__PURE__*/function (_BaseModule) {
     key: "registerEventListeners",
     value: function registerEventListeners() {
       var _this2 = this;
-      this.core.effects.on(ShopDiscountHooks.onCustomerChange, function (customer) {
+      this.core.effects.only("".concat(this.name, ":onCustomerChange"), function (customer) {
         var _this2$options$otherP;
         if ((_this2$options$otherP = _this2.options.otherParams) !== null && _this2$options$otherP !== void 0 && _this2$options$otherP.cacheId && _this2.getDiscountList().length) {
           return;
@@ -306,7 +306,7 @@ export var ShopDiscountImpl = /*#__PURE__*/function (_BaseModule) {
               }
               this.store.customer = customer;
               _context6.next = 4;
-              return this.core.effects.emit(ShopDiscountHooks.onCustomerChange, customer);
+              return this.core.effects.emit("".concat(this.name, ":onCustomerChange"), customer);
             case 4:
             case "end":
               return _context6.stop();
@@ -531,7 +531,7 @@ export var ShopDiscountImpl = /*#__PURE__*/function (_BaseModule) {
           while (1) switch (_context8.prev = _context8.next) {
             case 0:
               _context8.next = 2;
-              return this.core.effects.emit(ShopDiscountHooks.onDiscountListChange, discountList);
+              return this.core.effects.emit("".concat(this.name, ":onDiscountListChange"), discountList);
             case 2:
             case "end":
               return _context8.stop();
@@ -662,7 +662,7 @@ export var ShopDiscountImpl = /*#__PURE__*/function (_BaseModule) {
               customer = Object.assign({}, (_objectDestructuringEmpty(_result2.data), _result2.data));
               this.setCustomer(customer);
               _context9.next = 9;
-              return this.core.effects.emit(ShopDiscountHooks.onScanCustomerChange, customer);
+              return this.core.effects.emit("".concat(this.name, ":onScanCustomerChange"), customer);
             case 9:
               _context9.next = 14;
               break;
@@ -699,10 +699,10 @@ export var ShopDiscountImpl = /*#__PURE__*/function (_BaseModule) {
               _result3 = this.calcDiscount(this.store.productList);
               cb === null || cb === void 0 || cb(_result3);
               _context10.next = 7;
-              return this.core.effects.emit(ShopDiscountHooks.onLoadPrepareCalcResult, _result3);
+              return this.core.effects.emit("".concat(this.name, ":onLoadPrepareCalcResult"), _result3);
             case 7:
               _context10.next = 9;
-              return this.core.effects.emit(ShopDiscountHooks.onLoadDiscountList, newDiscountList);
+              return this.core.effects.emit("".concat(this.name, ":onLoadDiscountList"), newDiscountList);
             case 9:
             case "end":
               return _context10.stop();
@@ -759,10 +759,10 @@ export var ShopDiscountImpl = /*#__PURE__*/function (_BaseModule) {
               }
               _result4 = this.calcDiscount(this.store.productList);
               _context11.next = 19;
-              return this.core.effects.emit(ShopDiscountHooks.onLoadPrepareCalcResult, _result4);
+              return this.core.effects.emit("".concat(this.name, ":onLoadPrepareCalcResult"), _result4);
             case 19:
               _context11.next = 21;
-              return this.core.effects.emit(ShopDiscountHooks.onLoadDiscountList, filteredDiscountList);
+              return this.core.effects.emit("".concat(this.name, ":onLoadDiscountList"), filteredDiscountList);
             case 21:
               _context11.next = 26;
               break;

package/dist/types/index.d.ts

@@ -40,6 +40,7 @@ export interface PisellCore {
     effects: {
         on: (event: string, callback: (payload: any) => void) => () => void;
         once: (event: string, callback: (payload: any) => void) => () => void;
+        only: (event: string, callback: (payload: any) => void) => () => void;
         off: (event: string, callback: (payload: any) => void) => void;
         emit: (event: string, payload: any, value?: any) => Promise<{
             status: boolean;

package/lib/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/lib/effects/index.js

@@ -35,6 +35,19 @@ var EffectsManager = class {
       this.off(event, callback);
     };
   }
+  // 设置单例监听器，只能存在一个，新的会替换旧的
+  only(event, callback) {
+    var _a, _b;
+    if (this.listeners.has(event)) {
+      (_a = this.listeners.get(event)) == null ? void 0 : _a.clear();
+    } else {
+      this.listeners.set(event, /* @__PURE__ */ new Set());
+    }
+    (_b = this.listeners.get(event)) == null ? void 0 : _b.add(callback);
+    return () => {
+      this.off(event, callback);
+    };
+  }
   off(event, callback) {
     var _a;
     (_a = this.listeners.get(event)) == null ? void 0 : _a.delete(callback);

package/lib/modules/Payment/index.js

@@ -323,48 +323,35 @@ var PaymentModule = class extends import_BaseModule.BaseModule {
       totalAmount: params.total_amount
     });
     try {
-      const existingOrder = await this.dbManager.get("order", params.order_id);
-      this.logInfo("createPaymentOrderAsync existingOrder", {
-        existingOrder
+      const newOrder = {
+        uuid: (0, import_utils.getUniqueId)("pay_order_"),
+        id: params.order_id,
+        order_id: params.order_id,
+        order_info: params.order_info,
+        payment_status: import_types.PaymentStatus.Processing,
+        payment: [],
+        adjust_offline_payments: [],
+        total_amount: params.total_amount,
+        expect_amount: params.total_amount,
+        tax_fee: "0.00",
+        is_deposit: params.is_deposit || 0,
+        deposit_amount: params.deposit_amount || "0.00"
+      };
+      const dbAddStartTime = Date.now();
+      await this.dbManager.add("order", newOrder);
+      const dbAddDuration = Date.now() - dbAddStartTime;
+      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"
       });
-      if (existingOrder) {
-        this.logInfo(
-          `createPaymentOrderAsync found duplicate order ID: ${params.order_id}, updating existing payment order`
-        );
-        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);
-        await this.core.effects.emit(
-          `${this.name}:onOrderUpdated`,
-          existingOrder
-        );
-        return existingOrder;
-      } else {
-        const newOrder = {
-          uuid: (0, import_utils.getUniqueId)("pay_order_"),
-          id: params.order_id,
-          order_id: params.order_id,
-          order_info: params.order_info,
-          payment_status: import_types.PaymentStatus.Processing,
-          payment: [],
-          adjust_offline_payments: [],
-          total_amount: params.total_amount,
-          expect_amount: params.total_amount,
-          tax_fee: "0.00",
-          is_deposit: params.is_deposit || 0,
-          deposit_amount: params.deposit_amount || "0.00"
-        };
-        await this.dbManager.add("order", newOrder);
+      setTimeout(() => {
         this.core.effects.emit(`${this.name}:onOrderAdded`, newOrder);
-        this.logInfo("createPaymentOrderAsync completed - new payment order created", {
-          orderUuid: newOrder.uuid,
-          orderId: newOrder.id
-        });
-        return newOrder;
-      }
+      }, 0);
+      return newOrder;
     } catch (error) {
       console.error("[PaymentModule] 创建支付订单失败", error);
       this.logError("createPaymentOrderAsync failed", error, {

package/lib/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/lib/solution/BookingTicket/index.js

@@ -122,6 +122,12 @@ var BookingTicketImpl = class extends import_BaseModule.BaseModule {
       throw error;
     }
   }
+  /**
+   * 初始化外设扫码结果监听
+   */
+  initPeripheralsListener() {
+    this.scan.initPeripheralsListener();
+  }
   /**
    * 获取商品列表（不加载到模块中）
    * @returns 商品列表

package/lib/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/lib/solution/BookingTicket/utils/scan/index.js

@@ -37,9 +37,15 @@ var import_task = __toESM(require("../../../../utils/task"));
 var Scan = class {
   constructor(solution, watchKey) {
     this.listenerConfig = /* @__PURE__ */ new Map();
-    var _a, _b, _c, _d, _e;
     this.solution = solution;
     this.watchKey = watchKey;
+    this.initPeripheralsListener();
+  }
+  /**
+   * 初始化外设扫码结果监听
+   */
+  initPeripheralsListener() {
+    var _a, _b, _c, _d, _e;
     (_e = (_d = (_c = (_b = (_a = this.solution) == null ? void 0 : _a.window) == null ? void 0 : _b.interaction) == null ? void 0 : _c.utils) == null ? void 0 : _d.mountFunction) == null ? void 0 : _e.call(
       _d,
       "global",

package/lib/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;
 }