@boo-dreamer/event-bus 0.0.3

package/dist/index.cjs

@@ -0,0 +1,659 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+class WildcardMatcher {
+  /**
+   * 测试事件名称是否匹配模式
+   * @param pattern 模式（如 "user:*"、"**:*:error"）
+   * @param event 事件名称（如 "user:login"）
+   */
+  test(pattern, event) {
+    if (pattern === event) {
+      return true;
+    }
+    if (!pattern.includes("*")) {
+      return false;
+    }
+    const patternParts = pattern.split(":");
+    const eventParts = event.split(":");
+    return this.matchParts(patternParts, eventParts);
+  }
+  /**
+   * 递归匹配各部分
+   */
+  matchParts(patternParts, eventParts) {
+    let pIndex = 0;
+    let eIndex = 0;
+    while (pIndex < patternParts.length && eIndex < eventParts.length) {
+      const patternPart = patternParts[pIndex];
+      const eventPart = eventParts[eIndex];
+      if (patternPart === "**") {
+        if (pIndex === patternParts.length - 1) {
+          return true;
+        }
+        const remainingPattern = patternParts.slice(pIndex + 1);
+        for (let i = eIndex; i < eventParts.length; i++) {
+          if (this.matchParts(remainingPattern, eventParts.slice(i))) {
+            return true;
+          }
+        }
+        return false;
+      } else if (patternPart === "*") {
+        pIndex++;
+        eIndex++;
+      } else if (patternPart === eventPart) {
+        pIndex++;
+        eIndex++;
+      } else {
+        return false;
+      }
+    }
+    if (pIndex < patternParts.length) {
+      return patternParts.slice(pIndex).every((p) => p === "**");
+    }
+    return eIndex === eventParts.length;
+  }
+  /**
+   * 提取命名空间
+   * @param event 事件名称（如 "user:login:success"）
+   * @returns 命名空间（如 "user"）
+   */
+  getNamespace(event) {
+    const parts = event.split(":");
+    return parts[0] ?? "";
+  }
+  /**
+   * 提取事件名（不含命名空间）
+   * @param event 事件名称（如 "user:login:success"）
+   * @returns 事件名（如 "login:success"）
+   */
+  getEventName(event) {
+    const parts = event.split(":");
+    return parts.slice(1).join(":");
+  }
+  /**
+   * 检查是否为通配符模式
+   */
+  isWildcard(pattern) {
+    return pattern.includes("*");
+  }
+  /**
+   * 获取模式匹配的所有可能事件（有限集）
+   * 用于优化订阅查找
+   */
+  getPossibleEvents(pattern, knownEvents) {
+    if (!this.isWildcard(pattern)) {
+      return [pattern];
+    }
+    return knownEvents.filter((event) => this.test(pattern, event));
+  }
+}
+function createMatcher() {
+  return new WildcardMatcher();
+}
+const defaultMatcher = new WildcardMatcher();
+class HistoryManager {
+  constructor(maxSize = 100, enabled = true) {
+    __publicField(this, "history", []);
+    __publicField(this, "maxSize");
+    __publicField(this, "enabled");
+    this.maxSize = maxSize;
+    this.enabled = enabled;
+  }
+  /**
+   * 添加历史记录
+   */
+  add(event, data) {
+    if (!this.enabled) {
+      return;
+    }
+    const entry = {
+      event,
+      data,
+      timestamp: Date.now()
+    };
+    this.history.push(entry);
+    if (this.history.length > this.maxSize) {
+      this.history.shift();
+    }
+  }
+  /**
+   * 获取历史记录
+   * @param event 事件名称（可选，不传则返回所有）
+   * @param count 数量限制
+   */
+  get(event, count) {
+    let result = [...this.history];
+    if (event) {
+      result = result.filter((entry) => entry.event === event);
+    }
+    if (count && count > 0) {
+      result = result.slice(-count);
+    }
+    return result;
+  }
+  /**
+   * 获取匹配通配符模式的历史记录
+   */
+  getByPattern(pattern, matcher, count) {
+    let result = this.history.filter((entry) => matcher(pattern, entry.event));
+    if (count && count > 0) {
+      result = result.slice(-count);
+    }
+    return result;
+  }
+  /**
+   * 清空历史
+   */
+  clear() {
+    this.history = [];
+  }
+  /**
+   * 获取历史记录数量
+   */
+  size() {
+    return this.history.length;
+  }
+  /**
+   * 获取特定事件的历史记录数量
+   */
+  sizeOf(event) {
+    return this.history.filter((entry) => entry.event === event).length;
+  }
+  /**
+   * 设置最大容量
+   */
+  setMaxSize(size) {
+    this.maxSize = size;
+    if (this.history.length > size) {
+      this.history = this.history.slice(-size);
+    }
+  }
+  /**
+   * 获取最大容量
+   */
+  getMaxSize() {
+    return this.maxSize;
+  }
+  /**
+   * 启用/禁用历史记录
+   */
+  setEnabled(enabled) {
+    this.enabled = enabled;
+    if (!enabled) {
+      this.clear();
+    }
+  }
+  /**
+   * 是否启用
+   */
+  isEnabled() {
+    return this.enabled;
+  }
+  /**
+   * 获取所有事件名称（去重）
+   */
+  getEventNames() {
+    return [...new Set(this.history.map((entry) => entry.event))];
+  }
+  /**
+   * 获取时间范围内的历史记录
+   */
+  getByTimeRange(startTime, endTime, event) {
+    let result = this.history.filter(
+      (entry) => entry.timestamp >= startTime && entry.timestamp <= endTime
+    );
+    if (event) {
+      result = result.filter((entry) => entry.event === event);
+    }
+    return result;
+  }
+}
+function createHistoryManager(maxSize, enabled) {
+  return new HistoryManager(maxSize, enabled);
+}
+class MiddlewareManager {
+  constructor() {
+    __publicField(this, "middlewares", []);
+  }
+  /**
+   * 注册中间件
+   */
+  use(middleware) {
+    this.middlewares.push(middleware);
+  }
+  /**
+   * 执行中间件链
+   */
+  async execute(ctx, finalHandler) {
+    let index = 0;
+    const next = async () => {
+      if (ctx.stopped) {
+        return;
+      }
+      if (index < this.middlewares.length) {
+        const middleware = this.middlewares[index++];
+        await middleware(ctx, next);
+      } else {
+        await finalHandler();
+      }
+    };
+    await next();
+  }
+  /**
+   * 获取中间件数量
+   */
+  count() {
+    return this.middlewares.length;
+  }
+  /**
+   * 清空所有中间件
+   */
+  clear() {
+    this.middlewares = [];
+  }
+  /**
+   * 移除特定中间件
+   */
+  remove(middleware) {
+    const index = this.middlewares.indexOf(middleware);
+    if (index > -1) {
+      this.middlewares.splice(index, 1);
+      return true;
+    }
+    return false;
+  }
+}
+function createEventContext(event, data) {
+  return {
+    event,
+    data,
+    stopped: false,
+    stopPropagation() {
+      this.stopped = true;
+    }
+  };
+}
+function createLoggerMiddleware(logger) {
+  return async (ctx, next) => {
+    const startTime = Date.now();
+    if (logger) {
+      logger(ctx.event, ctx.data);
+    } else {
+      console.log(`[EventBus] Event: ${ctx.event}`, ctx.data);
+    }
+    await next();
+    const duration = Date.now() - startTime;
+    console.log(`[EventBus] Event: ${ctx.event} processed in ${duration}ms`);
+  };
+}
+function createErrorMiddleware(onError) {
+  return async (ctx, next) => {
+    try {
+      await next();
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      if (onError) {
+        onError(err, ctx.event, ctx.data);
+      } else {
+        console.error(`[EventBus] Error in event ${ctx.event}:`, err);
+      }
+      throw err;
+    }
+  };
+}
+function createPerformanceMiddleware(threshold = 100, onSlow) {
+  return async (ctx, next) => {
+    const startTime = performance.now();
+    await next();
+    const duration = performance.now() - startTime;
+    if (duration > threshold) {
+      if (onSlow) {
+        onSlow(ctx.event, duration, ctx.data);
+      } else {
+        console.warn(`[EventBus] Slow event: ${ctx.event} took ${duration.toFixed(2)}ms`);
+      }
+    }
+  };
+}
+function createValidationMiddleware(validator, onInvalid) {
+  return async (ctx, next) => {
+    const result = validator(ctx.data);
+    if (result === false || typeof result === "string") {
+      const reason = typeof result === "string" ? result : "Validation failed";
+      if (onInvalid) {
+        onInvalid(ctx.event, ctx.data, reason);
+      } else {
+        console.warn(`[EventBus] Validation failed for ${ctx.event}: ${reason}`);
+      }
+      ctx.stopPropagation();
+      return;
+    }
+    await next();
+  };
+}
+function createMiddlewareManager() {
+  return new MiddlewareManager();
+}
+class EventBus {
+  constructor(options = {}) {
+    __publicField(this, "subscribers", /* @__PURE__ */ new Map());
+    __publicField(this, "wildcardSubscribers", /* @__PURE__ */ new Map());
+    __publicField(this, "matcher");
+    __publicField(this, "history");
+    __publicField(this, "middleware");
+    __publicField(this, "options");
+    /**
+     * 默认错误处理器
+     */
+    __publicField(this, "defaultErrorHandler", (error, event, data) => {
+      console.error(`[EventBus] Error in event "${event}":`, error, data);
+    });
+    this.options = {
+      historySize: options.historySize ?? 100,
+      enableHistory: options.enableHistory ?? true,
+      onError: options.onError ?? this.defaultErrorHandler,
+      asyncHandlers: options.asyncHandlers ?? true
+    };
+    this.matcher = new WildcardMatcher();
+    this.history = new HistoryManager(this.options.historySize, this.options.enableHistory);
+    this.middleware = new MiddlewareManager();
+  }
+  /**
+   * 订阅事件
+   */
+  on(event, handler, options = {}) {
+    const eventName = String(event);
+    const subscriber = {
+      handler,
+      once: false,
+      priority: options.priority ?? 0
+    };
+    if (this.matcher.isWildcard(eventName)) {
+      this.addWildcardSubscriber(eventName, subscriber);
+    } else {
+      this.addSubscriber(eventName, subscriber);
+    }
+    if (options.replay) {
+      void this.replay(event, options.replayCount);
+    }
+    return () => {
+      this.off(event, handler);
+    };
+  }
+  /**
+   * 一次性订阅
+   */
+  once(event, handler, options = {}) {
+    const eventName = String(event);
+    const subscriber = {
+      handler,
+      once: true,
+      priority: options.priority ?? 0
+    };
+    if (this.matcher.isWildcard(eventName)) {
+      this.addWildcardSubscriber(eventName, subscriber);
+    } else {
+      this.addSubscriber(eventName, subscriber);
+    }
+    if (options.replay) {
+      void this.replay(event, options.replayCount);
+    }
+    return () => {
+      this.off(event, handler);
+    };
+  }
+  /**
+   * 取消订阅
+   */
+  off(event, handler) {
+    const eventName = String(event);
+    if (this.matcher.isWildcard(eventName)) {
+      this.removeWildcardSubscriber(eventName, handler);
+    } else {
+      this.removeSubscriber(eventName, handler);
+    }
+  }
+  /**
+   * 添加订阅者
+   */
+  addSubscriber(event, subscriber) {
+    if (!this.subscribers.has(event)) {
+      this.subscribers.set(event, /* @__PURE__ */ new Set());
+    }
+    this.subscribers.get(event).add(subscriber);
+  }
+  /**
+   * 移除订阅者
+   */
+  removeSubscriber(event, handler) {
+    const subs = this.subscribers.get(event);
+    if (!subs) return;
+    if (handler) {
+      for (const sub of subs) {
+        if (sub.handler === handler) {
+          subs.delete(sub);
+          break;
+        }
+      }
+    } else {
+      subs.clear();
+    }
+    if (subs.size === 0) {
+      this.subscribers.delete(event);
+    }
+  }
+  /**
+   * 添加通配符订阅者
+   */
+  addWildcardSubscriber(pattern, subscriber) {
+    if (!this.wildcardSubscribers.has(pattern)) {
+      this.wildcardSubscribers.set(pattern, /* @__PURE__ */ new Set());
+    }
+    this.wildcardSubscribers.get(pattern).add(subscriber);
+  }
+  /**
+   * 移除通配符订阅者
+   */
+  removeWildcardSubscriber(pattern, handler) {
+    const subs = this.wildcardSubscribers.get(pattern);
+    if (!subs) return;
+    if (handler) {
+      for (const sub of subs) {
+        if (sub.handler === handler) {
+          subs.delete(sub);
+          break;
+        }
+      }
+    } else {
+      subs.clear();
+    }
+    if (subs.size === 0) {
+      this.wildcardSubscribers.delete(pattern);
+    }
+  }
+  /**
+   * 获取匹配的订阅者（包括通配符）
+   */
+  getMatchingSubscribers(event) {
+    const result = [];
+    const exactSubs = this.subscribers.get(event);
+    if (exactSubs) {
+      result.push(...exactSubs);
+    }
+    for (const [pattern, subs] of this.wildcardSubscribers) {
+      if (this.matcher.test(pattern, event)) {
+        result.push(...subs);
+      }
+    }
+    return result.sort((a, b) => a.priority - b.priority);
+  }
+  /**
+   * 发射事件（同步返回 Promise 数组）
+   */
+  async emit(event, data) {
+    const eventName = String(event);
+    this.history.add(eventName, data);
+    const subscribers = this.getMatchingSubscribers(eventName);
+    const result = {
+      executedCount: 0,
+      failedCount: 0,
+      errors: []
+    };
+    if (subscribers.length === 0) {
+      return result;
+    }
+    const ctx = createEventContext(eventName, data);
+    await this.middleware.execute(ctx, async () => {
+      if (ctx.stopped) {
+        return;
+      }
+      const promises = subscribers.map(async (sub) => {
+        try {
+          await sub.handler(data);
+          result.executedCount++;
+          if (sub.once) {
+            this.off(event, sub.handler);
+          }
+        } catch (error) {
+          result.failedCount++;
+          const err = error instanceof Error ? error : new Error(String(error));
+          result.errors.push(err);
+          this.options.onError(err, eventName, data);
+        }
+      });
+      if (this.options.asyncHandlers) {
+        await Promise.all(promises);
+      } else {
+        for (const promise of promises) {
+          await promise;
+        }
+      }
+    });
+    return result;
+  }
+  /**
+   * 发射事件（异步等待所有 handler 完成）
+   */
+  async emitAsync(event, data) {
+    return this.emit(event, data);
+  }
+  /**
+   * 注册中间件
+   */
+  use(middleware) {
+    this.middleware.use(middleware);
+  }
+  /**
+   * 重放历史事件
+   */
+  async replay(event, count) {
+    const eventName = String(event);
+    const history = this.history.get(eventName, count);
+    const result = {
+      executedCount: 0,
+      failedCount: 0,
+      errors: []
+    };
+    for (const entry of history) {
+      try {
+        const subResult = await this.emit(event, entry.data);
+        result.executedCount += subResult.executedCount;
+        result.failedCount += subResult.failedCount;
+        result.errors.push(...subResult.errors);
+      } catch (error) {
+        result.failedCount++;
+        const err = error instanceof Error ? error : new Error(String(error));
+        result.errors.push(err);
+      }
+    }
+    return result;
+  }
+  /**
+   * 清空历史
+   */
+  clearHistory() {
+    this.history.clear();
+  }
+  /**
+   * 获取订阅数量
+   */
+  listenerCount(event) {
+    var _a;
+    if (event) {
+      const eventName = String(event);
+      const exactCount = ((_a = this.subscribers.get(eventName)) == null ? void 0 : _a.size) ?? 0;
+      let wildcardCount = 0;
+      for (const [pattern, subs] of this.wildcardSubscribers) {
+        if (this.matcher.test(pattern, eventName)) {
+          wildcardCount += subs.size;
+        }
+      }
+      return exactCount + wildcardCount;
+    }
+    let total = 0;
+    for (const subs of this.subscribers.values()) {
+      total += subs.size;
+    }
+    for (const subs of this.wildcardSubscribers.values()) {
+      total += subs.size;
+    }
+    return total;
+  }
+  /**
+   * 获取所有事件名称
+   */
+  eventNames() {
+    const names = /* @__PURE__ */ new Set();
+    for (const event of this.subscribers.keys()) {
+      names.add(event);
+    }
+    for (const event of this.history.getEventNames()) {
+      names.add(event);
+    }
+    return Array.from(names);
+  }
+  /**
+   * 销毁
+   */
+  destroy() {
+    this.subscribers.clear();
+    this.wildcardSubscribers.clear();
+    this.history.clear();
+    this.middleware.clear();
+  }
+  /**
+   * 获取历史管理器
+   */
+  getHistory() {
+    return this.history;
+  }
+  /**
+   * 获取中间件管理器
+   */
+  getMiddleware() {
+    return this.middleware;
+  }
+}
+function createEventBus(options) {
+  return new EventBus(options);
+}
+const eventBus = new EventBus();
+exports.EventBus = EventBus;
+exports.HistoryManager = HistoryManager;
+exports.MiddlewareManager = MiddlewareManager;
+exports.WildcardMatcher = WildcardMatcher;
+exports.createErrorMiddleware = createErrorMiddleware;
+exports.createEventBus = createEventBus;
+exports.createEventContext = createEventContext;
+exports.createHistoryManager = createHistoryManager;
+exports.createLoggerMiddleware = createLoggerMiddleware;
+exports.createMatcher = createMatcher;
+exports.createMiddlewareManager = createMiddlewareManager;
+exports.createPerformanceMiddleware = createPerformanceMiddleware;
+exports.createValidationMiddleware = createValidationMiddleware;
+exports.defaultMatcher = defaultMatcher;
+exports.eventBus = eventBus;
+//# sourceMappingURL=index.cjs.map