@bootdesk/js-web-adapter-core 0.1.0

package/dist/index.js

@@ -0,0 +1,997 @@
+// src/client/HttpClient.ts
+var HttpClient = class {
+  constructor(config) {
+    const headers = { ...config.headers };
+    if (config.verifyToken) {
+      headers["X-Verify-Token"] = config.verifyToken;
+    }
+    this.config = { apiUrl: config.apiUrl, timeout: config.timeout ?? 3e4, headers };
+  }
+  async get(url, signal) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+    try {
+      const fullUrl = this.resolve(url);
+      const combined = signal ? AbortSignal.any([controller.signal, signal]) : controller.signal;
+      const response = await fetch(fullUrl, {
+        method: "GET",
+        headers: this.config.headers,
+        signal: combined
+      });
+      if (!response.ok) throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      return response.json();
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  async post(url, body, signal) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+    try {
+      const fullUrl = this.resolve(url);
+      const combined = signal ? AbortSignal.any([controller.signal, signal]) : controller.signal;
+      const response = await fetch(fullUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...this.config.headers },
+        signal: combined,
+        body: JSON.stringify(body)
+      });
+      if (!response.ok) throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      return response.json();
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  async delete(url, signal) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+    try {
+      const fullUrl = this.resolve(url);
+      const combined = signal ? AbortSignal.any([controller.signal, signal]) : controller.signal;
+      const response = await fetch(fullUrl, {
+        method: "DELETE",
+        headers: this.config.headers,
+        signal: combined
+      });
+      if (!response.ok) throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      const text = await response.text();
+      return text ? JSON.parse(text) : void 0;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  async sendMessage(messages, endpoint = "/api/webhooks/web", conversationId) {
+    return this.post(endpoint, { id: conversationId, messages });
+  }
+  async sendAction(actionId, value, messageId, conversationId, endpoint = "/api/webhooks/web") {
+    return this.post(endpoint, {
+      id: conversationId,
+      action: { actionId, value, messageId }
+    });
+  }
+  async editMessage(messageId, newText, endpointTemplate = "/api/chat/messages/{id}/edit") {
+    const url = this.expandTemplate(endpointTemplate, { id: messageId });
+    await this.post(url, { text: newText });
+  }
+  async deleteMessage(messageId, endpointTemplate = "/api/chat/messages/{id}") {
+    const url = this.expandTemplate(endpointTemplate, { id: messageId });
+    await this.delete(url);
+  }
+  async addReaction(messageId, emoji, endpointTemplate = "/api/chat/messages/{id}/reactions") {
+    const url = this.expandTemplate(endpointTemplate, { id: messageId });
+    await this.post(url, { emoji });
+  }
+  async removeReaction(messageId, emoji, endpointTemplate = "/api/chat/messages/{id}/reactions/{emoji}") {
+    const url = this.expandTemplate(endpointTemplate, { id: messageId, emoji });
+    await this.delete(url);
+  }
+  resolve(url) {
+    return /^https?:\/\//.test(url) ? url : `${this.config.apiUrl}${url}`;
+  }
+  expandTemplate(template, params) {
+    let url = template;
+    for (const [key, value] of Object.entries(params)) {
+      url = url.replace(`{${key}}`, encodeURIComponent(value));
+    }
+    return this.resolve(url);
+  }
+};
+
+// src/events/base/ChatEvent.ts
+var ChatEvent = class {
+  constructor(type, threadId, timestamp) {
+    this.type = type;
+    this.threadId = threadId;
+    this.timestamp = timestamp;
+  }
+};
+var UnknownEvent = class extends ChatEvent {
+  constructor(type, threadId, data, timestamp) {
+    super(type, threadId, timestamp);
+    this.data = data;
+  }
+};
+
+// src/events/MessagePostedEvent.ts
+var MessagePostedEvent = class extends ChatEvent {
+  constructor(threadId, messageId, text, author, card, attachments, timestamp) {
+    super("message.posted", threadId, timestamp ?? Date.now());
+    this.messageId = messageId;
+    this.text = text;
+    this.author = author;
+    this.card = card;
+    this.attachments = attachments;
+  }
+};
+
+// src/events/MessageEditedEvent.ts
+var MessageEditedEvent = class extends ChatEvent {
+  constructor(threadId, messageId, newText, card, timestamp) {
+    super("message.edited", threadId, timestamp ?? Date.now());
+    this.messageId = messageId;
+    this.newText = newText;
+    this.card = card;
+  }
+};
+
+// src/events/MessageDeletedEvent.ts
+var MessageDeletedEvent = class extends ChatEvent {
+  constructor(threadId, messageId, timestamp) {
+    super("message.deleted", threadId, timestamp ?? Date.now());
+    this.messageId = messageId;
+  }
+};
+
+// src/events/ReactionAddedEvent.ts
+var ReactionAddedEvent = class extends ChatEvent {
+  constructor(threadId, messageId, emoji, user, timestamp) {
+    super("reaction.added", threadId, timestamp ?? Date.now());
+    this.messageId = messageId;
+    this.emoji = emoji;
+    this.user = user;
+  }
+};
+
+// src/events/ReactionRemovedEvent.ts
+var ReactionRemovedEvent = class extends ChatEvent {
+  constructor(threadId, messageId, emoji, user, timestamp) {
+    super("reaction.removed", threadId, timestamp ?? Date.now());
+    this.messageId = messageId;
+    this.emoji = emoji;
+    this.user = user;
+  }
+};
+
+// src/events/TypingStartedEvent.ts
+var TypingStartedEvent = class extends ChatEvent {
+  constructor(threadId, userId, timestamp) {
+    super("typing.started", threadId, timestamp ?? Date.now());
+    this.userId = userId;
+  }
+};
+
+// src/events/StreamingChunkEvent.ts
+var StreamingChunkEvent = class extends ChatEvent {
+  constructor(threadId, messageId, chunk, isFinal, timestamp) {
+    super("streaming.chunk", threadId, timestamp ?? Date.now());
+    this.messageId = messageId;
+    this.chunk = chunk;
+    this.isFinal = isFinal;
+  }
+};
+
+// src/events/DMRequestedEvent.ts
+var DMRequestedEvent = class extends ChatEvent {
+  constructor(threadId, userId, timestamp) {
+    super("dm.requested", threadId, timestamp ?? Date.now());
+    this.userId = userId;
+  }
+};
+
+// src/events/ChatEventFactory.ts
+function parseCard(value) {
+  if (!value || typeof value !== "object") return void 0;
+  const obj = value;
+  if (typeof obj.type !== "string") return void 0;
+  return obj;
+}
+function parseChatEvent(json) {
+  const type = json.type;
+  const threadId = json.threadId;
+  const timestamp = json.timestamp;
+  const data = json.data ?? {};
+  switch (type) {
+    case "message.posted":
+      return new MessagePostedEvent(
+        threadId,
+        data.messageId,
+        data.text,
+        data.author,
+        parseCard(data.card),
+        data.attachments,
+        timestamp
+      );
+    case "message.edited":
+      return new MessageEditedEvent(
+        threadId,
+        data.messageId,
+        data.newText,
+        parseCard(data.card),
+        timestamp
+      );
+    case "message.deleted":
+      return new MessageDeletedEvent(threadId, data.messageId, timestamp);
+    case "reaction.added":
+      return new ReactionAddedEvent(
+        threadId,
+        data.messageId,
+        data.emoji,
+        data.user,
+        timestamp
+      );
+    case "reaction.removed":
+      return new ReactionRemovedEvent(
+        threadId,
+        data.messageId,
+        data.emoji,
+        data.user,
+        timestamp
+      );
+    case "typing.started":
+      return new TypingStartedEvent(threadId, data.userId, timestamp);
+    case "streaming.chunk":
+      return new StreamingChunkEvent(
+        threadId,
+        data.messageId,
+        data.chunk,
+        data.isFinal,
+        timestamp
+      );
+    case "dm.requested":
+      return new DMRequestedEvent(threadId, data.userId, timestamp);
+    default:
+      return new UnknownEvent(type, threadId, data, timestamp);
+  }
+}
+ChatEvent.fromJSON = parseChatEvent;
+
+// src/utils/eventIdGenerator.ts
+function generateId() {
+  return `msg-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+}
+function generateConversationId() {
+  return `conv-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+}
+
+// src/client/WebChatClient.ts
+var WebChatClient = class {
+  constructor(config) {
+    this.messages = [];
+    this.eventHandlers = {};
+    this.streamingMessages = /* @__PURE__ */ new Map();
+    this.pendingTyping = null;
+    this.subscribers = /* @__PURE__ */ new Map();
+    this.config = config;
+    this.httpClient = new HttpClient({
+      apiUrl: config.apiUrl,
+      headers: {
+        "X-User-Id": config.userId,
+        "X-User-Name": config.userName,
+        ...config.headers ?? {}
+      },
+      verifyToken: config.verifyToken
+    });
+    this.broadcastClient = config.broadcastClient;
+    this.conversationId = config.conversationId ?? generateConversationId();
+    this.currentUserId = config.userId;
+  }
+  async connect() {
+    if (this.broadcastClient) {
+      this.broadcastClient.connect();
+      const threadId = this.getThreadId();
+      const threadEvents = {
+        onMessagePosted: (event) => this.handleMessagePosted(event)
+      };
+      if (this.config.features?.editMessages) {
+        threadEvents.onMessageEdited = (event) => this.handleMessageEdited(event);
+      }
+      if (this.config.features?.deleteMessages) {
+        threadEvents.onMessageDeleted = (event) => this.handleMessageDeleted(event);
+      }
+      if (this.config.features?.reactions) {
+        threadEvents.onReactionAdded = (event) => this.handleReactionAdded(event);
+        threadEvents.onReactionRemoved = (event) => this.handleReactionRemoved(event);
+      }
+      this.broadcastClient.subscribe(threadId, threadEvents);
+      this.unsubscribeUserChannel = this.broadcastClient.subscribeToUser(
+        threadId,
+        this.currentUserId,
+        {
+          onTypingStarted: (event) => this.handleTypingStarted(event),
+          onStreamingChunk: (event) => this.handleStreamingChunk(event),
+          onDMRequested: (event) => this.handleDMRequested(event)
+        }
+      );
+    }
+  }
+  disconnect() {
+    this.unsubscribeUserChannel?.();
+    this.unsubscribeUserChannel = void 0;
+    this.broadcastClient?.disconnect();
+    this.streamingMessages.clear();
+  }
+  async loadMessages(options, signal) {
+    const endpoint = this.config.endpoints?.loadMessages ?? "/api/chat/messages";
+    const threadId = this.getThreadId();
+    const params = new URLSearchParams({
+      threadId,
+      limit: String(options?.limit ?? 50)
+    });
+    if (options?.before) params.set("before", String(options.before));
+    if (options?.after) params.set("after", String(options.after));
+    const response = await this.httpClient.get(
+      `${endpoint}?${params.toString()}`,
+      signal
+    );
+    const messages = (response.messages || []).map((msg) => ({
+      id: msg.id,
+      threadId,
+      content: { text: msg.text, cards: msg.card ? [msg.card] : void 0 },
+      author: {
+        id: msg.author.id,
+        name: msg.author.name,
+        isBot: msg.author.isBot ?? false,
+        isMe: msg.author.id === this.currentUserId
+      },
+      timestamp: msg.timestamp,
+      attachments: msg.attachments?.map((a) => ({
+        id: `att-${msg.id}-${a.url}`,
+        url: a.url,
+        name: a.name,
+        type: a.type,
+        mimeType: a.mime_type,
+        size: a.size
+      })),
+      reactions: msg.reactions ?? []
+    }));
+    if (!options?.before && !options?.after && !options?.skipStateSeed) {
+      this.messages = messages;
+      this.notifySubscribers("messages:loaded", messages);
+    }
+    return {
+      messages,
+      hasMore: response.hasMore ?? false,
+      nextCursor: response.nextCursor,
+      prevCursor: response.prevCursor
+    };
+  }
+  async sendMessage(text, attachments = []) {
+    const messageId = generateId();
+    const userMessage = {
+      id: messageId,
+      threadId: this.getThreadId(),
+      content: { text },
+      author: { id: this.currentUserId, name: this.config.userName, isMe: true },
+      timestamp: Date.now(),
+      attachments: attachments.length > 0 ? attachments.map((a, i) => ({
+        id: `att-${messageId}-${i}`,
+        name: a.name || "",
+        url: a.url,
+        size: a.size,
+        mimeType: a.mimeType
+      })) : void 0
+    };
+    this.messages.push(userMessage);
+    this.notifySubscribers("message:added", userMessage);
+    const endpoint = this.config.endpoints?.sendMessage ?? "/api/webhooks/web";
+    const response = await this.httpClient.sendMessage(
+      [
+        {
+          id: messageId,
+          role: "user",
+          text,
+          attachments: attachments?.map((a) => ({
+            url: a.url,
+            name: a.name,
+            mime_type: a.mimeType,
+            size: a.size
+          }))
+        }
+      ],
+      endpoint,
+      this.conversationId
+    );
+    if (response.events) {
+      response.events.forEach((eventData) => {
+        const event = parseChatEvent(eventData);
+        this.dispatchEvent(event);
+      });
+    }
+    if (response.text && !response.events?.some((e) => e.type === "message.posted")) {
+      const assistantMessage = {
+        id: response.id || generateId(),
+        threadId: this.getThreadId(),
+        content: { text: response.text },
+        author: { id: "assistant", name: "Assistant", isBot: true },
+        timestamp: Date.now(),
+        attachments: response.attachments?.map((a, i) => ({
+          id: `att-${response.id || "msg"}-${i}`,
+          name: a.name || "",
+          url: a.url || "",
+          type: a.type,
+          mimeType: a.mime_type,
+          size: a.size
+        }))
+      };
+      this.messages.push(assistantMessage);
+      this.notifySubscribers("message:added", assistantMessage);
+    }
+  }
+  async sendAction(messageId, actionId, value) {
+    const endpoint = this.config.endpoints?.sendMessage ?? "/api/webhooks/web";
+    const response = await this.httpClient.sendAction(
+      actionId,
+      value,
+      messageId,
+      this.conversationId,
+      endpoint
+    );
+    if (response.events) {
+      response.events.forEach((eventData) => {
+        const event = parseChatEvent(eventData);
+        this.dispatchEvent(event);
+      });
+    }
+  }
+  async editMessage(messageId, newText) {
+    if (!this.config.features?.editMessages) {
+      throw new Error("Edit messages not enabled. Set features.editMessages = true in config.");
+    }
+    const endpoint = this.config.endpoints?.editMessage ?? "/api/chat/messages/{id}/edit";
+    await this.httpClient.editMessage(messageId, newText, endpoint);
+  }
+  async deleteMessage(messageId) {
+    if (!this.config.features?.deleteMessages) {
+      throw new Error("Delete messages not enabled. Set features.deleteMessages = true in config.");
+    }
+    const endpoint = this.config.endpoints?.deleteMessage ?? "/api/chat/messages/{id}";
+    await this.httpClient.deleteMessage(messageId, endpoint);
+  }
+  async addReaction(messageId, emoji) {
+    if (!this.config.features?.reactions) {
+      throw new Error("Reactions not enabled. Set features.reactions = true in config.");
+    }
+    const endpoint = this.config.endpoints?.addReaction ?? "/api/chat/messages/{id}/reactions";
+    await this.httpClient.addReaction(messageId, emoji, endpoint);
+  }
+  async removeReaction(messageId, emoji) {
+    if (!this.config.features?.reactions) {
+      throw new Error("Reactions not enabled. Set features.reactions = true in config.");
+    }
+    const endpoint = this.config.endpoints?.removeReaction ?? "/api/chat/messages/{id}/reactions/{emoji}";
+    await this.httpClient.removeReaction(messageId, emoji, endpoint);
+  }
+  onMessagePosted(handler) {
+    return this.addEventListener("message.posted", handler);
+  }
+  onStreamingChunk(handler) {
+    return this.addEventListener("streaming.chunk", handler);
+  }
+  onTypingStarted(handler) {
+    return this.addEventListener("typing.started", handler);
+  }
+  getConversationId() {
+    return this.conversationId;
+  }
+  getMessages() {
+    return [...this.messages];
+  }
+  getThreadId() {
+    return `web:${this.currentUserId}:${this.conversationId}`;
+  }
+  getCurrentUserId() {
+    return this.currentUserId;
+  }
+  getFeatures() {
+    return this.config.features ?? {};
+  }
+  getEndpoints() {
+    return this.config.endpoints ?? {};
+  }
+  getHttpClient() {
+    return this.httpClient;
+  }
+  addEventListener(eventType, handler) {
+    if (!this.subscribers.has(eventType)) this.subscribers.set(eventType, []);
+    this.subscribers.get(eventType).push(handler);
+    return () => {
+      const handlers = this.subscribers.get(eventType);
+      if (handlers) {
+        const index = handlers.indexOf(handler);
+        if (index !== -1) handlers.splice(index, 1);
+      }
+    };
+  }
+  handleMessagePosted(event) {
+    if (this.messages.some((m) => m.id === event.messageId)) return;
+    if (this.streamingMessages.has(event.messageId)) return;
+    const message = {
+      id: event.messageId,
+      threadId: event.threadId,
+      content: { text: event.text, cards: event.card ? [event.card] : void 0 },
+      author: event.author,
+      timestamp: event.timestamp,
+      attachments: event.attachments?.map((a) => ({
+        id: `att-${event.messageId}-${Math.random().toString(36).slice(2, 8)}`,
+        name: a.name || "",
+        url: a.url || "",
+        type: a.type,
+        mimeType: a.mimeType,
+        size: a.size
+      }))
+    };
+    this.messages.push(message);
+    this.notifySubscribers("message:added", message);
+    this.notifySubscribers("message.posted", event);
+  }
+  handleMessageEdited(event) {
+    const message = this.messages.find((m) => m.id === event.messageId);
+    if (message?.content) {
+      message.content.text = event.newText;
+      this.notifySubscribers("message:edited", {
+        messageId: event.messageId,
+        newText: event.newText
+      });
+    }
+  }
+  handleMessageDeleted(event) {
+    const index = this.messages.findIndex((m) => m.id === event.messageId);
+    if (index !== -1) {
+      this.messages.splice(index, 1);
+      this.notifySubscribers("message:deleted", { messageId: event.messageId });
+    }
+  }
+  handleReactionAdded(event) {
+    const message = this.messages.find((m) => m.id === event.messageId);
+    if (!message) return;
+    if (!message.reactions) message.reactions = [];
+    const existing = message.reactions.find((r) => r.emoji === event.emoji);
+    if (existing) {
+      existing.count++;
+      existing.users.push(event.user.id);
+    } else {
+      message.reactions.push({ emoji: event.emoji, count: 1, users: [event.user.id] });
+    }
+    this.notifySubscribers("reaction:added", { messageId: event.messageId, emoji: event.emoji });
+  }
+  handleReactionRemoved(event) {
+    const message = this.messages.find((m) => m.id === event.messageId);
+    if (!message?.reactions) return;
+    const index = message.reactions.findIndex((r) => r.emoji === event.emoji);
+    if (index !== -1) {
+      const reaction = message.reactions[index];
+      reaction.count--;
+      reaction.users = reaction.users.filter((id) => id !== event.user.id);
+      if (reaction.count === 0) message.reactions.splice(index, 1);
+    }
+    this.notifySubscribers("reaction:removed", { messageId: event.messageId, emoji: event.emoji });
+  }
+  handleStreamingChunk(event) {
+    const { messageId, chunk, isFinal } = event;
+    if (!this.streamingMessages.has(messageId)) {
+      this.streamingMessages.set(messageId, { messageId, accumulatedText: "", isComplete: false });
+      this.notifySubscribers("streaming:started", { messageId });
+    }
+    const state = this.streamingMessages.get(messageId);
+    state.accumulatedText += chunk;
+    if (isFinal) {
+      state.isComplete = true;
+      if (!this.messages.some((m) => m.id === messageId)) {
+        const message = {
+          id: messageId,
+          threadId: event.threadId,
+          content: { text: state.accumulatedText },
+          author: { id: "assistant", name: "Assistant", isBot: true },
+          timestamp: event.timestamp
+        };
+        this.messages.push(message);
+        this.notifySubscribers("message:added", message);
+      }
+      this.streamingMessages.delete(messageId);
+      this.notifySubscribers("streaming:complete", { messageId, text: state.accumulatedText });
+    } else {
+      this.notifySubscribers("streaming:chunk", {
+        messageId,
+        chunk,
+        fullText: state.accumulatedText
+      });
+    }
+    this.notifySubscribers("streaming.chunk", event);
+  }
+  handleTypingStarted(event) {
+    if (this.pendingTyping) clearTimeout(this.pendingTyping);
+    this.notifySubscribers("typing:started", { userId: event.userId });
+    this.pendingTyping = setTimeout(() => {
+      this.notifySubscribers("typing:stopped", { userId: event.userId });
+    }, 3e3);
+    this.notifySubscribers("typing.started", event);
+  }
+  handleDMRequested(event) {
+    this.notifySubscribers("dm.requested", { userId: event.userId, threadId: event.threadId });
+  }
+  notifySubscribers(eventType, data) {
+    this.subscribers.get(eventType)?.forEach((handler) => handler(data));
+  }
+  dispatchEvent(event) {
+    switch (event.type) {
+      case "message.posted":
+        this.handleMessagePosted(event);
+        break;
+      case "message.edited":
+        this.handleMessageEdited(event);
+        break;
+      case "message.deleted":
+        this.handleMessageDeleted(event);
+        break;
+      case "reaction.added":
+        this.handleReactionAdded(event);
+        break;
+      case "reaction.removed":
+        this.handleReactionRemoved(event);
+        break;
+      case "typing.started":
+        this.handleTypingStarted(event);
+        break;
+      case "streaming.chunk":
+        this.handleStreamingChunk(event);
+        break;
+      case "dm.requested":
+        this.handleDMRequested(event);
+        break;
+    }
+  }
+};
+
+// src/client/PusherBroadcastClient.ts
+var PusherBroadcastClient = class {
+  constructor(pusherOrConfig, channelPrefix = "chat", channelTypes) {
+    this.subscriptions = /* @__PURE__ */ new Map();
+    this.channelPrefix = channelPrefix;
+    this.threadChannelType = channelTypes?.threadChannel ?? "public";
+    this.userChannelType = channelTypes?.userChannel ?? "private";
+    if ("key" in pusherOrConfig) {
+      const PusherCtor = globalThis.Pusher ?? globalThis.pusherJs;
+      if (!PusherCtor) {
+        throw new Error("pusher-js not found. Install it or pass a Pusher instance.");
+      }
+      this.pusher = new PusherCtor(pusherOrConfig.key, pusherOrConfig);
+    } else {
+      this.pusher = pusherOrConfig;
+    }
+  }
+  buildChannelName(base, type) {
+    switch (type) {
+      case "private":
+        return `private-${base}`;
+      case "presence":
+        return `presence-${base}`;
+      default:
+        return base;
+    }
+  }
+  connect() {
+    if (this.pusher.connection?.state !== "connected") {
+      this.pusher.connect();
+    }
+  }
+  disconnect() {
+    this.subscriptions.forEach((channel) => channel.unbind_all?.() ?? channel.unsubscribe?.());
+    this.subscriptions.clear();
+    this.pusher.disconnect?.();
+  }
+  subscribe(threadId, handlers) {
+    const baseName = `${this.channelPrefix}.${threadId}`;
+    const channelName = this.buildChannelName(baseName, this.threadChannelType);
+    const channel = this.pusher.subscribe(channelName);
+    const key = `thread:${threadId}`;
+    this.subscriptions.set(key, channel);
+    const threadEvents = [
+      "message.posted",
+      "message.edited",
+      "message.deleted",
+      "reaction.added",
+      "reaction.removed"
+    ];
+    threadEvents.forEach((eventType) => {
+      const eventName = `${this.channelPrefix}.${eventType}`;
+      channel.bind(eventName, (data) => {
+        const event = parseChatEvent(data);
+        this.dispatchToHandler(event, handlers);
+      });
+    });
+    return () => {
+      channel.unbind_all?.();
+      this.pusher.unsubscribe(channelName);
+      this.subscriptions.delete(key);
+    };
+  }
+  subscribeToUser(threadId, userId, handlers) {
+    const baseName = `${this.channelPrefix}.${threadId}.${userId}`;
+    const channelName = this.buildChannelName(baseName, this.userChannelType);
+    const channel = this.pusher.subscribe(channelName);
+    const key = `user:${threadId}:${userId}`;
+    this.subscriptions.set(key, channel);
+    const userEvents = ["typing.started", "streaming.chunk", "dm.requested"];
+    userEvents.forEach((eventType) => {
+      const eventName = `${this.channelPrefix}.${eventType}`;
+      channel.bind(eventName, (data) => {
+        const event = parseChatEvent(data);
+        this.dispatchToHandler(event, handlers);
+      });
+    });
+    return () => {
+      channel.unbind_all?.();
+      this.pusher.unsubscribe(channelName);
+      this.subscriptions.delete(key);
+    };
+  }
+  isConnected() {
+    return this.pusher.connection?.state === "connected";
+  }
+  dispatchToHandler(event, handlers) {
+    switch (event.type) {
+      case "message.posted":
+        handlers.onMessagePosted?.(event);
+        break;
+      case "message.edited":
+        handlers.onMessageEdited?.(event);
+        break;
+      case "message.deleted":
+        handlers.onMessageDeleted?.(event);
+        break;
+      case "reaction.added":
+        handlers.onReactionAdded?.(event);
+        break;
+      case "reaction.removed":
+        handlers.onReactionRemoved?.(event);
+        break;
+      case "typing.started":
+        handlers.onTypingStarted?.(event);
+        break;
+      case "streaming.chunk":
+        handlers.onStreamingChunk?.(event);
+        break;
+      case "dm.requested":
+        handlers.onDMRequested?.(event);
+        break;
+    }
+  }
+};
+
+// src/client/LaravelEchoBroadcastClient.ts
+var LaravelEchoBroadcastClient = class {
+  constructor(echo, channelPrefix = "chat", channelTypes) {
+    this.subscriptions = /* @__PURE__ */ new Map();
+    this.echo = echo;
+    this.channelPrefix = channelPrefix;
+    this.threadChannelType = channelTypes?.threadChannel ?? "public";
+    this.userChannelType = channelTypes?.userChannel ?? "private";
+  }
+  subscribeToEcho(name, type) {
+    switch (type) {
+      case "private":
+        return this.echo.private(name);
+      case "presence":
+        return this.echo.join(name);
+      default:
+        return this.echo.channel(name);
+    }
+  }
+  connect() {
+    return Promise.resolve();
+  }
+  disconnect() {
+    this.subscriptions.forEach((channel) => {
+      channel.unsubscribe?.();
+      channel.stopListening?.();
+    });
+    this.subscriptions.clear();
+  }
+  subscribe(threadId, handlers) {
+    const channelName = `${this.channelPrefix}.${threadId}`;
+    const channel = this.subscribeToEcho(channelName, this.threadChannelType);
+    const key = `thread:${threadId}`;
+    this.subscriptions.set(key, channel);
+    const threadEvents = [
+      { type: "message.posted", handler: "onMessagePosted" },
+      { type: "message.edited", handler: "onMessageEdited" },
+      { type: "message.deleted", handler: "onMessageDeleted" },
+      { type: "reaction.added", handler: "onReactionAdded" },
+      { type: "reaction.removed", handler: "onReactionRemoved" }
+    ];
+    threadEvents.forEach(({ type, handler }) => {
+      const eventName = `.${this.channelPrefix}.${type}`;
+      channel.listen(eventName, (data) => {
+        const event = parseChatEvent(data);
+        handlers[handler]?.(event);
+      });
+    });
+    return () => {
+      channel.unsubscribe?.();
+      this.subscriptions.delete(key);
+    };
+  }
+  subscribeToUser(threadId, userId, handlers) {
+    const channelName = `${this.channelPrefix}.${threadId}.${userId}`;
+    const channel = this.subscribeToEcho(channelName, this.userChannelType);
+    const key = `user:${threadId}:${userId}`;
+    this.subscriptions.set(key, channel);
+    const userEvents = [
+      { type: "typing.started", handler: "onTypingStarted" },
+      { type: "streaming.chunk", handler: "onStreamingChunk" },
+      { type: "dm.requested", handler: "onDMRequested" }
+    ];
+    userEvents.forEach(({ type, handler }) => {
+      const eventName = `.${this.channelPrefix}.${type}`;
+      channel.listen(eventName, (data) => {
+        const event = parseChatEvent(data);
+        handlers[handler]?.(event);
+      });
+    });
+    return () => {
+      channel.unsubscribe?.();
+      this.subscriptions.delete(key);
+    };
+  }
+  isConnected() {
+    try {
+      const connector = this.echo.connector;
+      if (!connector) return false;
+      if (connector.pusher?.connection?.state === "connected") return true;
+      if (connector.socket?.connected) return true;
+      return false;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/push/PushManager.ts
+var PushManager = class _PushManager {
+  constructor(config) {
+    this.registration = null;
+    this.status = "unsupported";
+    this.statusListeners = /* @__PURE__ */ new Set();
+    this.messageListeners = /* @__PURE__ */ new Set();
+    this.config = config;
+  }
+  static isSupported() {
+    return typeof navigator !== "undefined" && "serviceWorker" in navigator && "PushManager" in window && "Notification" in window;
+  }
+  getStatus() {
+    return this.status;
+  }
+  onStatusChange(listener) {
+    this.statusListeners.add(listener);
+    return () => {
+      this.statusListeners.delete(listener);
+    };
+  }
+  onMessage(listener) {
+    this.messageListeners.add(listener);
+    return () => {
+      this.messageListeners.delete(listener);
+    };
+  }
+  async initialize() {
+    if (!_PushManager.isSupported()) {
+      this.setStatus("unsupported");
+      return;
+    }
+    if (Notification.permission === "denied") {
+      this.setStatus("denied");
+      return;
+    }
+    try {
+      this.registration = await navigator.serviceWorker.register(
+        this.config.serviceWorkerUrl || "/chat-service-worker.js",
+        { scope: this.config.serviceWorkerScope || "/" }
+      );
+      await navigator.serviceWorker.ready;
+      const subscription = await this.registration.pushManager.getSubscription();
+      this.setStatus(subscription ? "subscribed" : "default");
+    } catch {
+      this.setStatus("error");
+    }
+  }
+  async subscribe() {
+    if (!this.registration)
+      throw new Error("PushManager not initialized. Call initialize() first.");
+    this.setStatus("subscribing");
+    try {
+      let subscription = await this.registration.pushManager.getSubscription();
+      if (!subscription) {
+        const permission = await Notification.requestPermission();
+        if (permission !== "granted") {
+          this.setStatus(permission === "denied" ? "denied" : "default");
+          return;
+        }
+        const vapidPublicKey = await this.config.getVapidPublicKey();
+        const convertedKey = this.urlBase64ToUint8Array(vapidPublicKey);
+        subscription = await this.registration.pushManager.subscribe({
+          userVisibleOnly: true,
+          applicationServerKey: convertedKey.buffer
+        });
+      }
+      await this.config.onSubscribe(subscription.toJSON());
+      this.setStatus("subscribed");
+    } catch {
+      this.setStatus("error");
+      throw new Error("Push subscription failed");
+    }
+  }
+  async unsubscribe() {
+    if (!this.registration) return;
+    try {
+      const subscription = await this.registration.pushManager.getSubscription();
+      if (subscription) {
+        await this.config.onUnsubscribe(subscription.toJSON());
+        await subscription.unsubscribe();
+      }
+      this.setStatus("default");
+    } catch {
+      this.setStatus("error");
+      throw new Error("Push unsubscription failed");
+    }
+  }
+  urlBase64ToUint8Array(base64String) {
+    const padding = "=".repeat((4 - base64String.length % 4) % 4);
+    const base64 = (base64String + padding).replace(/-/g, "+").replace(/_/g, "/");
+    const rawData = atob(base64);
+    return Uint8Array.from([...rawData].map((char) => char.charCodeAt(0)));
+  }
+  setStatus(status) {
+    this.status = status;
+    this.statusListeners.forEach((listener) => listener(status));
+  }
+};
+
+// src/push/PushSubscriptionManager.ts
+function createPushSubscriptionHandlers(httpClient, userId) {
+  return {
+    onSubscribe: async (subscription) => {
+      await httpClient.post("/api/push/subscriptions", {
+        userId,
+        subscription,
+        userAgent: navigator.userAgent
+      });
+    },
+    onUnsubscribe: async (subscription) => {
+      await httpClient.delete(
+        `/api/push/subscriptions?userId=${encodeURIComponent(userId)}&endpoint=${encodeURIComponent(subscription.endpoint || "")}`
+      );
+    }
+  };
+}
+export {
+  ChatEvent,
+  DMRequestedEvent,
+  HttpClient,
+  LaravelEchoBroadcastClient,
+  MessageDeletedEvent,
+  MessageEditedEvent,
+  MessagePostedEvent,
+  PushManager,
+  PusherBroadcastClient,
+  ReactionAddedEvent,
+  ReactionRemovedEvent,
+  StreamingChunkEvent,
+  TypingStartedEvent,
+  UnknownEvent,
+  WebChatClient,
+  createPushSubscriptionHandlers,
+  generateConversationId,
+  generateId,
+  parseChatEvent
+};
+//# sourceMappingURL=index.js.map