@pisell/pisellos 0.0.215 → 0.0.217

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

@@ -10,10 +10,15 @@ function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol"
 function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 import watch from "../../../../utils/watch";
 import Tasks from "../../../../utils/task";
-export var Scan = /*#__PURE__*/function () {
+var ScanResultType = /*#__PURE__*/function (ScanResultType) {
+  ScanResultType["Scanner"] = "scanner";
+  ScanResultType["NFC"] = "nfc";
+  ScanResultType["NativeScanner"] = "nativeScanner";
+  return ScanResultType;
+}(ScanResultType || {});
+var Scan = /*#__PURE__*/function () {
   function Scan(solution, watchKey) {
-    var _solution$window,
-      _this$solution,
+    var _this$solution,
       _this$solution$mountF,
       _this = this;
     _classCallCheck(this, Scan);
@@ -22,9 +27,9 @@ export var Scan = /*#__PURE__*/function () {
     _defineProperty(this, "listenerConfig", new Map());
     this.solution = solution;
     this.watchKey = watchKey;
-    console.log('this.solution?.window?.interaction', solution === null || solution === void 0 || (_solution$window = solution.window) === null || _solution$window === void 0 ? void 0 : _solution$window.interaction);
+
     // 监听扫码结果
-    (_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', 'nativeScannerResult', function (strVal) {
+    (_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);
@@ -42,7 +47,7 @@ export var Scan = /*#__PURE__*/function () {
    */
   _createClass(Scan, [{
     key: "addListener",
-    value: function addListener(event, callback) {
+    value: function addListener(event, scanCallback) {
       var _this2 = this;
       // 订阅事件
       watch.subscribe(this.watchKey, event);
@@ -54,9 +59,10 @@ export var Scan = /*#__PURE__*/function () {
         }
         return _this2.handleScanResultFn.apply(_this2, [event.key].concat(args));
       });
+
       // 创建监听配置
       this.listenerConfig.set(event.key, {
-        callback: callback,
+        scanCallback: scanCallback,
         task: task
       });
       return {
@@ -131,7 +137,8 @@ export var Scan = /*#__PURE__*/function () {
           _ref,
           type,
           value,
-          listenerCallback,
+          data,
+          scanCallback,
           _result2,
           _args = arguments;
         return _regeneratorRuntime().wrap(function _callee$(_context) {
@@ -141,43 +148,47 @@ export var Scan = /*#__PURE__*/function () {
                 args[_key2] = _args[_key2];
               }
               eventKey = args[0], other = args[1];
-              _ref = (other === null || other === void 0 ? void 0 : other.scanResult) || {}, type = _ref.type, value = _ref.value;
-              listenerCallback = (_this$getListenerConf = this.getListenerConfig(eventKey)) === null || _this$getListenerConf === void 0 ? void 0 : _this$getListenerConf.callback;
-              if (!listenerCallback) {
-                _context.next = 15;
+              _ref = (other === null || other === void 0 ? void 0 : other.scanResult) || {}, type = _ref.type, value = _ref.value, data = _ref.data;
+              scanCallback = (_this$getListenerConf = this.getListenerConfig(eventKey)) === null || _this$getListenerConf === void 0 ? void 0 : _this$getListenerConf.scanCallback;
+              if (!scanCallback) {
+                _context.next = 17;
                 break;
               }
               _context.prev = 5;
               _context.next = 8;
-              return listenerCallback({
+              return scanCallback({
                 type: type,
                 value: value
               });
             case 8:
               _result2 = _context.sent;
+              console.log("".concat(eventKey, "_result>>>>>>>"), _result2);
               watch.publishByEventKey(this.watchKey, eventKey, {
                 type: eventKey,
                 status: 'success',
                 scanType: type,
                 scanCode: value,
+                scanData: data,
                 result: _result2
               });
-              _context.next = 15;
+              _context.next = 17;
               break;
-            case 12:
-              _context.prev = 12;
+            case 13:
+              _context.prev = 13;
               _context.t0 = _context["catch"](5);
+              console.log("".concat(eventKey, "_result_error>>>>>>>"), _context.t0);
               watch.publishByEventKey(this.watchKey, eventKey, {
                 type: eventKey,
                 status: 'failed',
                 scanType: type,
-                scanCode: value
+                scanCode: value,
+                scanData: data
               });
-            case 15:
+            case 17:
             case "end":
               return _context.stop();
           }
-        }, _callee, this, [[5, 12]]);
+        }, _callee, this, [[5, 13]]);
       }));
       function handleScanResultFn() {
         return _handleScanResultFn.apply(this, arguments);
@@ -186,4 +197,5 @@ export var Scan = /*#__PURE__*/function () {
     }())
   }]);
   return Scan;
-}();
+}();
+export { Scan as default };

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

@@ -0,0 +1,78 @@
+/**
+ * LRU缓存类，用于缓存接口数据
+ * 限制最多存储100条数据，超过时移除最久未使用的数据
+ * 支持数据压缩以减小缓存压力
+ * 尾部优先策略：新节点插入尾部，最近使用的节点移动到尾部，删除头部节点
+ */
+declare class LRUCache<T> {
+    private head;
+    private tail;
+    private keyMap;
+    private readonly maxSize;
+    constructor(maxSize?: number);
+    /**
+     * 将节点移动到链表尾部（最近使用）
+     * @param node 要移动的节点
+     */
+    private moveToTail;
+    /**
+     * 添加新节点到链表尾部
+     * @param key 缓存键
+     * @param compressedData 压缩后的数据
+     * @param timestamp 时间戳
+     */
+    private addToTail;
+    /**
+     * 从链表中移除节点
+     * @param node 要移除的节点
+     */
+    private removeNode;
+    /**
+     * 移除最久未使用的节点（链表头部）
+     */
+    private removeOldest;
+    /**
+     * 设置缓存
+     * @param key 缓存键
+     * @param data 缓存数据
+     */
+    set(key: string, data: T): void;
+    /**
+     * 获取缓存
+     * @param key 缓存键
+     * @returns 缓存数据或undefined
+     */
+    get(key: string): T | undefined;
+    /**
+     * 检查是否存在缓存
+     * @param key 缓存键
+     * @returns 是否存在
+     */
+    has(key: string): boolean;
+    /**
+     * 清除所有缓存
+     */
+    clear(): void;
+    /**
+     * 获取缓存大小
+     * @returns 当前缓存数量
+     */
+    size(): number;
+    /**
+     * 获取缓存统计信息
+     * @returns 缓存统计信息
+     */
+    getStats(): {
+        size: number;
+        maxSize: number;
+        usage: number;
+    };
+    /**
+     * 删除指定的缓存项
+     * @param key 要删除的缓存键
+     * @returns 是否删除成功
+     */
+    delete(key: string): boolean;
+}
+declare const scanCache: LRUCache<any>;
+export default scanCache;

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

@@ -0,0 +1,305 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+/**
+ * 简单的数据压缩函数
+ * @param data 要压缩的数据
+ * @returns 压缩后的字符串
+ */
+var compressData = function compressData(data) {
+  try {
+    // 处理undefined值
+    if (data === undefined) {
+      return 'undefined';
+    }
+    return JSON.stringify(data);
+  } catch (error) {
+    console.warn('数据压缩失败:', error);
+    return JSON.stringify(data);
+  }
+};
+
+/**
+ * 数据解压缩函数
+ * @param compressedData 压缩后的数据
+ * @returns 解压缩后的数据
+ */
+var decompressData = function decompressData(compressedData) {
+  try {
+    // 处理undefined值
+    if (compressedData === 'undefined') {
+      return undefined;
+    }
+    return JSON.parse(compressedData);
+  } catch (error) {
+    console.warn('数据解压缩失败:', error);
+    return null;
+  }
+};
+
+/**
+ * 双向链表节点
+ */
+/**
+ * LRU缓存类，用于缓存接口数据
+ * 限制最多存储100条数据，超过时移除最久未使用的数据
+ * 支持数据压缩以减小缓存压力
+ * 尾部优先策略：新节点插入尾部，最近使用的节点移动到尾部，删除头部节点
+ */
+var LRUCache = /*#__PURE__*/function () {
+  function LRUCache() {
+    var maxSize = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 100;
+    _classCallCheck(this, LRUCache);
+    _defineProperty(this, "head", null);
+    // 最久未使用的节点
+    _defineProperty(this, "tail", null);
+    // 最近使用的节点
+    _defineProperty(this, "keyMap", new Map());
+    // key到节点的映射（只存储引用）
+    _defineProperty(this, "maxSize", void 0);
+    this.maxSize = maxSize;
+  }
+
+  /**
+   * 将节点移动到链表尾部（最近使用）
+   * @param node 要移动的节点
+   */
+  _createClass(LRUCache, [{
+    key: "moveToTail",
+    value: function moveToTail(node) {
+      if (this.tail === node) return; // 已经是尾部
+
+      // 从当前位置移除
+      if (node.prev) {
+        node.prev.next = node.next;
+      }
+      if (node.next) {
+        node.next.prev = node.prev;
+      }
+
+      // 如果是头部，更新头部
+      if (this.head === node) {
+        this.head = node.next;
+      }
+
+      // 移动到尾部
+      if (this.tail) {
+        this.tail.next = node;
+      }
+      node.prev = this.tail;
+      node.next = null;
+      this.tail = node;
+
+      // 如果链表为空，设置头部
+      if (!this.head) {
+        this.head = node;
+      }
+    }
+
+    /**
+     * 添加新节点到链表尾部
+     * @param key 缓存键
+     * @param compressedData 压缩后的数据
+     * @param timestamp 时间戳
+     */
+  }, {
+    key: "addToTail",
+    value: function addToTail(key, compressedData, timestamp) {
+      // 先保存当前的tail引用
+      var oldTail = this.tail;
+      var node = {
+        key: key,
+        compressedData: compressedData,
+        timestamp: timestamp,
+        prev: oldTail,
+        // 使用保存的引用，避免循环引用
+        next: null
+      };
+
+      // 存储节点引用
+      this.keyMap.set(key, node);
+
+      // 更新链表关系
+      if (oldTail) {
+        oldTail.next = node;
+      }
+      this.tail = node;
+
+      // 如果是第一个节点，设置head
+      if (!this.head) {
+        this.head = node;
+      }
+      return node;
+    }
+
+    /**
+     * 从链表中移除节点
+     * @param node 要移除的节点
+     */
+  }, {
+    key: "removeNode",
+    value: function removeNode(node) {
+      if (node.prev) {
+        node.prev.next = node.next;
+      }
+      if (node.next) {
+        node.next.prev = node.prev;
+      }
+      if (this.head === node) {
+        this.head = node.next;
+      }
+      if (this.tail === node) {
+        this.tail = node.prev;
+      }
+
+      // 从Map中移除引用
+      this.keyMap.delete(node.key);
+    }
+
+    /**
+     * 移除最久未使用的节点（链表头部）
+     */
+  }, {
+    key: "removeOldest",
+    value: function removeOldest() {
+      if (this.head) {
+        this.removeNode(this.head);
+      }
+    }
+
+    /**
+     * 设置缓存
+     * @param key 缓存键
+     * @param data 缓存数据
+     */
+  }, {
+    key: "set",
+    value: function set(key, data) {
+      // 压缩数据
+      var compressedData = compressData(data);
+      var timestamp = Date.now();
+
+      // 检查是否已存在该key
+      var existingNode = this.keyMap.get(key);
+      if (existingNode) {
+        // 如果已存在，更新数据并移动到链表尾部
+        existingNode.compressedData = compressedData;
+        existingNode.timestamp = timestamp;
+        this.moveToTail(existingNode);
+      } else {
+        // 如果是新数据且缓存已满，移除最久未使用的数据（头部）
+        if (this.keyMap.size >= this.maxSize) {
+          this.removeOldest();
+        }
+
+        // 添加新数据到尾部
+        this.addToTail(key, compressedData, timestamp);
+      }
+    }
+
+    /**
+     * 获取缓存
+     * @param key 缓存键
+     * @returns 缓存数据或undefined
+     */
+  }, {
+    key: "get",
+    value: function get(key) {
+      var node = this.keyMap.get(key);
+      if (node) {
+        // 解压缩数据
+        var decompressedData = decompressData(node.compressedData);
+        if (decompressedData !== null) {
+          // 更新访问时间戳并移动到链表尾部
+          node.timestamp = Date.now();
+          this.moveToTail(node);
+          return decompressedData;
+        } else {
+          // 如果解压缩失败，删除该缓存项
+          this.removeNode(node);
+          return undefined;
+        }
+      }
+      return undefined;
+    }
+
+    /**
+     * 检查是否存在缓存
+     * @param key 缓存键
+     * @returns 是否存在
+     */
+  }, {
+    key: "has",
+    value: function has(key) {
+      return this.keyMap.has(key);
+    }
+
+    /**
+     * 清除所有缓存
+     */
+  }, {
+    key: "clear",
+    value: function clear() {
+      // 清除所有节点的引用关系，帮助垃圾回收
+      var current = this.head;
+      while (current) {
+        var next = current.next;
+        current.prev = null;
+        current.next = null;
+        current = next;
+      }
+
+      // 清除Map和头尾指针
+      this.keyMap.clear();
+      this.head = null;
+      this.tail = null;
+    }
+
+    /**
+     * 获取缓存大小
+     * @returns 当前缓存数量
+     */
+  }, {
+    key: "size",
+    value: function size() {
+      return this.keyMap.size;
+    }
+
+    /**
+     * 获取缓存统计信息
+     * @returns 缓存统计信息
+     */
+  }, {
+    key: "getStats",
+    value: function getStats() {
+      return {
+        size: this.keyMap.size,
+        maxSize: this.maxSize,
+        usage: Math.round(this.keyMap.size / this.maxSize * 100)
+      };
+    }
+
+    /**
+     * 删除指定的缓存项
+     * @param key 要删除的缓存键
+     * @returns 是否删除成功
+     */
+  }, {
+    key: "delete",
+    value: function _delete(key) {
+      var node = this.keyMap.get(key);
+      if (node) {
+        this.removeNode(node);
+        return true;
+      }
+      return false;
+    }
+  }]);
+  return LRUCache;
+}(); // 创建全局缓存实例
+var scanCache = new LRUCache();
+export default scanCache;

package/lib/modules/Customer/index.d.ts

@@ -11,6 +11,18 @@ export declare class CustomerModule extends BaseModule implements Module, Custom
     private fatherModule;
     constructor(name?: string, version?: string);
     initialize(core: PisellCore, options?: ModuleOptions): Promise<void>;
+    /**
+     * 获取客户列表数据（内部方法）
+     * @param params 查询参数
+     * @returns API响应数据
+     */
+    private fetchCustomerListData;
+    /**
+     * 处理客户列表操作的错误（内部方法）
+     * @param error 错误对象
+     * @param operation 操作名称
+     */
+    private handleCustomerListError;
     /**
      * 获取客户列表
      * @param params 查询参数
@@ -81,6 +93,27 @@ export declare class CustomerModule extends BaseModule implements Module, Custom
      * @returns 客户列表响应
      */
     changeCustomerPage(page: number, pageSize?: number): Promise<ICustomerListResponse>;
+    /**
+     * 滚动加载更多客户数据 - 数据会追加到现有列表中
+     * @returns 客户列表响应
+     */
+    loadMoreCustomers(): Promise<ICustomerListResponse>;
+    /**
+     * 重置并重新开始滚动加载
+     * @param params 查询参数
+     * @returns 客户列表响应
+     */
+    resetAndLoadCustomers(params?: ShopGetCustomerListParams): Promise<ICustomerListResponse>;
+    /**
+     * 检查是否还有更多数据可以加载
+     * @returns 是否还有更多数据
+     */
+    hasMoreCustomers(): boolean;
+    /**
+     * 获取当前的搜索条件
+     * @returns 当前搜索条件
+     */
+    getCurrentSearchParams(): Omit<ShopGetCustomerListParams, 'skip' | 'num'>;
     /**
      * 缓存状态变化
      */