@flowlab/event/dist/index.mjs

FlowLab event-driven system

#!/usr/bin/env node

// src/bus/EventBus.ts
var EventBus = class {
  handlers = /* @__PURE__ */ new Map();
  /**
   * 触发事件
   * @param eventName - 事件名称
   * @param payload - 事件数据
   */
  async emit(eventName, payload) {
    const handlers = this.handlers.get(eventName);
    if (handlers) {
      for (const handler of handlers) {
        try {
          await handler(payload);
        } catch (err) {
          console.error(`[FlowLab EventBus] Error handling event ${eventName}`, err);
        }
      }
    }
  }
  /**
   * 绑定事件处理器
   * @param eventName - 事件名称
   * @param handler - 事件处理函数
   */
  on(eventName, handler) {
    if (!this.handlers.has(eventName)) {
      this.handlers.set(eventName, /* @__PURE__ */ new Set());
    }
    this.handlers.get(eventName)?.add(handler);
  }
  /**
   * 解绑事件处理器
   * @param eventName - 事件名称
   * @param handler - 事件处理函数
   */
  off(eventName, handler) {
    this.handlers.get(eventName)?.delete(handler);
  }
};

// src/bus/InMemoryBus.ts
var InMemoryBus = class extends EventBus {
  running = false;
  async start() {
    this.running = true;
    console.log("[FlowLab] \u2705 InMemory EventBus started successfully");
  }
  async stop() {
    this.running = false;
    console.log("[FlowLab] \u{1F6D1} InMemory EventBus stopped");
  }
  isRunning() {
    return this.running;
  }
};

// src/internal/context.ts
var currentEventBus = new InMemoryBus();
function getCurrentEventBus() {
  return currentEventBus;
}
function useEventBus(bus) {
  currentEventBus = bus;
}

// src/api/emitEvents.ts
async function emitEvent(eventName, payload) {
  const bus = getCurrentEventBus();
  await bus.emit(eventName, payload);
}

// src/api/bindEvent.ts
function bindEvent(eventName, handler) {
  getCurrentEventBus().on(eventName, handler);
}

// src/api/unbindEvent.ts
function unbindEvent(eventName, handler) {
  if (handler) {
    getCurrentEventBus().off(eventName, handler);
  }
}

// src/api/registerWorkflow.ts
function registerWorkflow(eventName, workflow) {
  bindEvent(eventName, async (payload) => {
    await workflow.run(payload);
  });
}

// src/api/startEventListener.ts
async function startEventListener() {
  await getCurrentEventBus().start();
}

// src/api/stopEventListener.ts
async function stopEventListener() {
  await getCurrentEventBus().stop();
}

// src/api/listBoundEvents.ts
function listBoundEvents() {
  const bus = getCurrentEventBus();
  return bus.handlers ? Array.from(bus.handlers.keys()) : [];
}

// src/api/isEventBound.ts
function isEventBound(eventName) {
  const bus = getCurrentEventBus();
  return bus.handlers?.has(eventName) ?? false;
}

// src/api/onAnyEvent.ts
function onAnyEvent(callback) {
  const bus = getCurrentEventBus();
  const originalEmit = bus.emit.bind(bus);
  bus.emit = async (eventName, payload) => {
    callback(eventName, payload);
    return originalEmit(eventName, payload);
  };
}
export {
  bindEvent,
  emitEvent,
  getCurrentEventBus,
  isEventBound,
  listBoundEvents,
  onAnyEvent,
  registerWorkflow,
  startEventListener,
  stopEventListener,
  unbindEvent,
  useEventBus
};
//# sourceMappingURL=index.mjs.map