@pisell/pisellos 2.1.3 → 2.1.5

package/dist/utils/watch.d.ts

@@ -0,0 +1,102 @@
+/**
+ * 监听模块
+ *
+ */
+export type WatchEventCallback = (...args: any[]) => void;
+export type WatchEventItem = {
+    key: string;
+    callback: WatchEventCallback;
+};
+export interface WatchEventSubscription {
+    unsubscribe: () => void;
+}
+declare class Watch {
+    private events;
+    private enableListMap;
+    /**
+     * 订阅事件
+     * @param event 事件名称
+     * @param callback 回调函数
+     * @returns 订阅对象，可用于取消订阅
+     */
+    subscribe(watchKey: string, event: WatchEventItem): WatchEventSubscription;
+    /**
+     * 启用事件
+     * @param watchKey 监听的key
+     * @param event 事件名称
+     */
+    enableEvent(watchKey: string, eventKey: string): void;
+    /**
+     * 禁用某个事件
+     * @param watchKey 监听的key
+     * @param eventKey 事件名称
+     */
+    disableEvent(watchKey: string, eventKey: string): void;
+    /**
+     * 冻结某个监听下的所有事件
+     * @param watchKey 监听的key
+     */
+    disabledAllEventByWatchKey(watchKey: string): void;
+    /**
+     * 启用某个监听下的所有事件
+     * @param watchKey 监听的key
+     */
+    enableAllEventByWatchKey(watchKey: string): void;
+    /**
+     * 取消订阅事件
+     * @param event 事件名称
+     * @param callback 回调函数
+     * @returns 是否成功取消订阅
+     */
+    unsubscribe(watchKey: string, event: WatchEventItem): void;
+    /**
+     * 发布事件
+     * @param event 事件名称
+     * @param args 事件参数
+     */
+    publish(watchKey: string, ...args: any[]): void;
+    /**
+     * 根据事件名称发布事件
+     * @param watchKey 监听的key
+     * @param eventKey 事件名称
+     * @param args 事件参数
+     */
+    publishByEventKey(watchKey: string, eventKey: string, ...args: any[]): void;
+    /**
+     * 获取最后一个启用的事件
+     * @param watchKey 监听的key
+     * @returns 最后一个启用的事件
+     */
+    getLastEnableEventKey(watchKey: string): WatchEventItem['key'] | undefined;
+    /**
+     * 移除某个事件的所有订阅
+     * @param event 事件名称
+     * @returns 是否成功移除
+     */
+    clearEvent(watchKey: string): void;
+    /**
+     * 移除所有事件订阅
+     */
+    clearAllEvents(): void;
+    /**
+     * 获取事件的订阅数量
+     * @param event 事件名称
+     * @returns 订阅数量
+     */
+    getSubscriberCount(event: string): number;
+    /**
+     * 检查事件是否有订阅者
+     * @param event 事件名称
+     * @returns 是否有订阅者
+     */
+    hasSubscribers(event: string): boolean;
+    /**
+     * 一次性订阅事件，事件触发后自动取消订阅
+     * @param event 事件名称
+     * @param callback 回调函数
+     * @returns 订阅对象，可用于取消订阅
+     */
+    once(watchKey: string, event: WatchEventItem): WatchEventSubscription;
+}
+declare const watch: Watch;
+export default watch;

package/dist/utils/watch.js

@@ -0,0 +1,294 @@
+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); }
+/**
+ * 监听模块
+ *
+ */
+var Watch = /*#__PURE__*/function () {
+  function Watch() {
+    _classCallCheck(this, Watch);
+    // 监听列表
+    _defineProperty(this, "events", new Map());
+    // 启用列表 - 使用数组保持顺序
+    _defineProperty(this, "enableListMap", new Map());
+  }
+  _createClass(Watch, [{
+    key: "subscribe",
+    value:
+    /**
+     * 订阅事件
+     * @param event 事件名称
+     * @param callback 回调函数
+     * @returns 订阅对象，可用于取消订阅
+     */
+    function subscribe(watchKey, event) {
+      var _this = this;
+      // 如果监听列表不存在，则创建
+      if (!this.events.has(watchKey)) {
+        this.events.set(watchKey, new Map());
+      }
+
+      // 获取监听列表
+      var callbacks = this.events.get(watchKey);
+      // 设置事件
+      callbacks.set(event.key, event.callback);
+
+      // 启用事件
+      this.enableEvent(watchKey, event.key);
+      return {
+        // 取消订阅
+        unsubscribe: function unsubscribe() {
+          // 取消订阅事件
+          _this.unsubscribe(watchKey, event);
+        }
+      };
+    }
+
+    /**
+     * 启用事件
+     * @param watchKey 监听的key
+     * @param event 事件名称
+     */
+  }, {
+    key: "enableEvent",
+    value: function enableEvent(watchKey, eventKey) {
+      // 获取启用列表
+      var enableList = this.enableListMap.get(watchKey);
+      // 如果启用列表存在，则添加事件
+      if (enableList) {
+        if (enableList.includes(eventKey)) {
+          return;
+        }
+        enableList.push(eventKey);
+      } else {
+        // 如果启用列表不存在，则创建启用列表
+        this.enableListMap.set(watchKey, [eventKey]);
+      }
+    }
+
+    /**
+     * 禁用某个事件
+     * @param watchKey 监听的key
+     * @param eventKey 事件名称
+     */
+  }, {
+    key: "disableEvent",
+    value: function disableEvent(watchKey, eventKey) {
+      // 获取启用列表
+      var enableList = this.enableListMap.get(watchKey);
+      if (enableList) {
+        // 找到当前事件的索引
+        var index = enableList.indexOf(eventKey);
+        if (index !== -1) {
+          // 删除当前事件以及之后的所有事件
+          enableList.splice(index);
+        }
+      }
+    }
+
+    /**
+     * 冻结某个监听下的所有事件
+     * @param watchKey 监听的key
+     */
+  }, {
+    key: "disabledAllEventByWatchKey",
+    value: function disabledAllEventByWatchKey(watchKey) {
+      // 设置启用列表为空
+      this.enableListMap.set(watchKey, []);
+    }
+
+    /**
+     * 启用某个监听下的所有事件
+     * @param watchKey 监听的key
+     */
+  }, {
+    key: "enableAllEventByWatchKey",
+    value: function enableAllEventByWatchKey(watchKey) {
+      var _this$events$get;
+      // 遍历当前监听下的所有事件， 并启用
+      this.enableListMap.set(watchKey, Array.from(((_this$events$get = this.events.get(watchKey)) === null || _this$events$get === void 0 ? void 0 : _this$events$get.keys()) || []));
+    }
+
+    /**
+     * 取消订阅事件
+     * @param event 事件名称
+     * @param callback 回调函数
+     * @returns 是否成功取消订阅
+     */
+  }, {
+    key: "unsubscribe",
+    value: function unsubscribe(watchKey, event) {
+      // 获取监听列表
+      var callbacks = this.events.get(watchKey);
+      // 如果监听列表不存在，则返回false
+      if (!callbacks) {
+        return;
+      }
+      // 禁用事件
+      this.disableEvent(watchKey, event.key);
+      // 删除事件
+      callbacks.delete(event.key);
+      return;
+    }
+
+    /**
+     * 发布事件
+     * @param event 事件名称
+     * @param args 事件参数
+     */
+  }, {
+    key: "publish",
+    value: function publish(watchKey) {
+      // 获取监听列表
+      var callbacks = this.events.get(watchKey);
+      // 如果监听列表不存在，则返回
+      if (!callbacks) {
+        return;
+      }
+
+      // 获取启用列表
+      var enableList = this.enableListMap.get(watchKey);
+      // 如果启用列表不存在，则返回
+      if (!enableList || enableList.length === 0) {
+        return;
+      }
+
+      // 只执行最后一个事件
+      var lastCallbackKey = enableList.at(-1);
+      // 如果最后一个事件存在，则执行
+      if (lastCallbackKey) {
+        try {
+          var _callbacks$get;
+          for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+            args[_key - 1] = arguments[_key];
+          }
+          (_callbacks$get = callbacks.get(lastCallbackKey)) === null || _callbacks$get === void 0 || _callbacks$get.apply(void 0, args);
+        } catch (error) {
+          console.error("\u6267\u884C\u4E8B\u4EF6\"".concat(watchKey, "\"\u7684\u56DE\u8C03\u65F6\u51FA\u9519:"), error);
+        }
+      }
+    }
+
+    /**
+     * 根据事件名称发布事件
+     * @param watchKey 监听的key
+     * @param eventKey 事件名称
+     * @param args 事件参数
+     */
+  }, {
+    key: "publishByEventKey",
+    value: function publishByEventKey(watchKey, eventKey) {
+      var _callbacks$get2;
+      var callbacks = this.events.get(watchKey);
+      if (!callbacks) {
+        return;
+      }
+      for (var _len2 = arguments.length, args = new Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
+        args[_key2 - 2] = arguments[_key2];
+      }
+      (_callbacks$get2 = callbacks.get(eventKey)) === null || _callbacks$get2 === void 0 || _callbacks$get2.apply(void 0, args);
+    }
+
+    /**
+     * 获取最后一个启用的事件
+     * @param watchKey 监听的key
+     * @returns 最后一个启用的事件
+     */
+  }, {
+    key: "getLastEnableEventKey",
+    value: function getLastEnableEventKey(watchKey) {
+      var enableList = this.enableListMap.get(watchKey);
+      console.log('enableList', enableList);
+      if (!enableList) {
+        return undefined;
+      }
+      return enableList.at(-1) || undefined;
+    }
+
+    /**
+     * 移除某个事件的所有订阅
+     * @param event 事件名称
+     * @returns 是否成功移除
+     */
+  }, {
+    key: "clearEvent",
+    value: function clearEvent(watchKey) {
+      // 禁用所有事件
+      this.disabledAllEventByWatchKey(watchKey);
+      // 删除监听列表
+      this.events.delete(watchKey);
+    }
+
+    /**
+     * 移除所有事件订阅
+     */
+  }, {
+    key: "clearAllEvents",
+    value: function clearAllEvents() {
+      // 清空监听列表
+      this.events.clear();
+      // 清空启用列表
+      this.enableListMap.clear();
+    }
+
+    /**
+     * 获取事件的订阅数量
+     * @param event 事件名称
+     * @returns 订阅数量
+     */
+  }, {
+    key: "getSubscriberCount",
+    value: function getSubscriberCount(event) {
+      // 获取监听列表
+      var callbacks = this.events.get(event);
+      // 如果监听列表不存在，则返回0
+      return callbacks ? callbacks.size : 0;
+    }
+
+    /**
+     * 检查事件是否有订阅者
+     * @param event 事件名称
+     * @returns 是否有订阅者
+     */
+  }, {
+    key: "hasSubscribers",
+    value: function hasSubscribers(event) {
+      // 获取监听列表
+      return this.getSubscriberCount(event) > 0;
+    }
+
+    /**
+     * 一次性订阅事件，事件触发后自动取消订阅
+     * @param event 事件名称
+     * @param callback 回调函数
+     * @returns 订阅对象，可用于取消订阅
+     */
+  }, {
+    key: "once",
+    value: function once(watchKey, event) {
+      var _this2 = this;
+      // 包装回调函数
+      var wrappedCallback = function wrappedCallback() {
+        // 取消订阅
+        _this2.unsubscribe(watchKey, {
+          key: event.key,
+          callback: wrappedCallback
+        });
+        // 执行回调
+        event.callback.apply(event, arguments);
+      };
+      return this.subscribe(watchKey, {
+        key: event.key,
+        callback: wrappedCallback
+      });
+    }
+  }]);
+  return Watch;
+}(); // 创建单例实例
+var watch = new Watch();
+export default watch;

package/lib/core/index.js

@@ -61,7 +61,7 @@ var PisellOSCore = class {
         console.log(`${prefix} ${message}`);
         break;
       case "warn":
-        console.warn(`${prefix} ${message}`);
+        console.log(`%c${prefix}%c ${message}`, "color: #f59e0b; font-weight: bold;", "color: #f59e0b;");
         break;
       case "error":
         console.error(`${prefix} ${message}`);

package/lib/effects/index.d.ts

@@ -2,16 +2,17 @@ type EffectCallback = (payload: any) => void | Promise<void | {
     status: boolean;
     message?: string;
 }>;
+type UnsubscribeFunction = () => void;
 declare class EffectsManager {
     private listeners;
-    on(event: string, callback: EffectCallback): void;
+    on(event: string, callback: EffectCallback): UnsubscribeFunction;
     off(event: string, callback: EffectCallback): void;
     offByModuleDestroy(module: string): void;
-    once(event: string, callback: EffectCallback): void;
+    once(event: string, callback: EffectCallback): UnsubscribeFunction;
     emit(event: string, payload: any): Promise<{
         status: boolean;
         data: any;
     }>;
     clear(): void;
 }
-export { EffectsManager };
+export { EffectsManager, UnsubscribeFunction };

package/lib/effects/index.js

@@ -31,6 +31,9 @@ var EffectsManager = class {
     if (!this.listeners.has(event))
       this.listeners.set(event, /* @__PURE__ */ new Set());
     (_a = this.listeners.get(event)) == null ? void 0 : _a.add(callback);
+    return () => {
+      this.off(event, callback);
+    };
   }
   off(event, callback) {
     var _a;
@@ -49,7 +52,7 @@ var EffectsManager = class {
       await callback(payload);
       this.off(event, wrapper);
     };
-    this.on(event, wrapper);
+    return this.on(event, wrapper);
   }
   async emit(event, payload) {
     const callbacks = this.listeners.get(event);

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

@@ -1,7 +1,7 @@
 import { Module, PisellCore, ModuleOptions } from '../../types';
 import { AccountModule, Account } from '../Account';
 import { BaseModule } from '../BaseModule';
-import { IFetchHolderAccountsParams, IHolder } from './types';
+import { IFetchHolderAccountsParams, IHolder, IGetCustomerListParams } from './types';
 export declare class AccountListModule extends BaseModule implements Module {
     protected defaultName: string;
     protected defaultVersion: string;
@@ -37,6 +37,12 @@ export declare class AccountListModule extends BaseModule implements Module {
         customerId: number;
         type?: 'unshift' | 'push';
     }): Promise<AccountModule[]>;
+    /**
+     * 获取客户列表
+     * @param params 查询参数
+     * @returns 客户列表
+     */
+    getCustomerList(params?: IGetCustomerListParams): Promise<any>;
     /**
      * 获取holder类型账户列表
      * @param params

package/lib/modules/AccountList/index.js

@@ -288,6 +288,33 @@ var AccountListModule = class extends import_BaseModule.BaseModule {
     );
     return accountModules;
   }
+  /**
+   * 获取客户列表
+   * @param params 查询参数
+   * @returns 客户列表
+   */
+  async getCustomerList(params = {}) {
+    const url = "/customer/es/data";
+    const { page = 1, pageSize = 20, keyword, ...otherParams } = params;
+    try {
+      this.store.isLoading = true;
+      this.store.error = null;
+      const queryParams = {
+        page,
+        pageSize,
+        ...keyword && { keyword },
+        ...otherParams
+      };
+      const res = await this.request.get(url, queryParams);
+      return (res == null ? void 0 : res.data) || [];
+    } catch (error) {
+      console.error("Failed to fetch customer list:", error);
+      this.store.error = error instanceof Error ? error.message : "Failed to fetch customer list";
+      throw error;
+    } finally {
+      this.store.isLoading = false;
+    }
+  }
   /**
    * 获取holder类型账户列表
    * @param params

package/lib/modules/AccountList/types.d.ts

@@ -67,3 +67,31 @@ export interface IHolder {
     main_field: string;
     customer_cover?: string;
 }
+/**
+ * 获取客户列表参数
+ */
+export interface IGetCustomerListParams {
+    /** 页码 */
+    page?: number;
+    /** 每页数量 */
+    pageSize?: number;
+    /** 搜索关键词 */
+    keyword?: string;
+    /** 其他筛选参数 */
+    [key: string]: any;
+}
+/**
+ * 客户数据
+ */
+export interface ICustomer {
+    /** 客户ID */
+    id: string | number;
+    /** 客户姓名 */
+    name: string;
+    /** 客户电话 */
+    phone?: string;
+    /** 客户邮箱 */
+    email?: string;
+    /** 其他客户信息 */
+    [key: string]: any;
+}

package/lib/modules/Cart/index.js

@@ -31,7 +31,7 @@ var import_utils2 = require("../Product/utils");
 __reExport(Cart_exports, require("./types"), module.exports);
 var CartModule = class extends import_BaseModule.BaseModule {
   constructor(name, version) {
-    super(name, version);
+    super(name || "cart", version || "1.0.0");
     // 提供给 baseModule 用的默认名称 和 默认版本
     this.defaultName = "cart";
     this.defaultVersion = "1.0.0";

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

@@ -0,0 +1,7 @@
+export declare const SORT_BY = "id";
+export declare const DEFAULT_PAGE_SIZE = 20;
+export declare const DEFAULT_CUSTOMER: {
+    id: number;
+    nickname: string;
+    name: string;
+};

package/lib/modules/Customer/constants.js

@@ -0,0 +1,39 @@
+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);
+
+// src/modules/Customer/constants.ts
+var constants_exports = {};
+__export(constants_exports, {
+  DEFAULT_CUSTOMER: () => DEFAULT_CUSTOMER,
+  DEFAULT_PAGE_SIZE: () => DEFAULT_PAGE_SIZE,
+  SORT_BY: () => SORT_BY
+});
+module.exports = __toCommonJS(constants_exports);
+var SORT_BY = "id";
+var DEFAULT_PAGE_SIZE = 20;
+var DEFAULT_CUSTOMER = {
+  "id": 1,
+  "nickname": "Select a customer",
+  "name": "选择一个客户"
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_CUSTOMER,
+  DEFAULT_PAGE_SIZE,
+  SORT_BY
+});