@liveblocks/chat-sdk-adapter 0.0.0 → 3.16.0-feeds2

package/dist/index.js

@@ -0,0 +1,972 @@
+// src/adapter.ts
+import {
+  getMentionsFromCommentBody,
+  isCommentBodyLink,
+  isCommentBodyMention,
+  isCommentBodyText
+} from "@liveblocks/core";
+import {
+  Liveblocks,
+  LiveblocksError,
+  WebhookHandler
+} from "@liveblocks/node";
+import {
+  ConsoleLogger,
+  defaultEmojiResolver,
+  Message,
+  parseMarkdown,
+  tableToAscii,
+  toPlainText
+} from "chat";
+var ADAPTER_PREFIX = "liveblocks";
+var LiveblocksAdapter = class {
+  name = "liveblocks";
+  userName;
+  #client;
+  #webhookHandler;
+  #resolveUsers;
+  #resolveGroupsInfo;
+  #logger;
+  #botUserId;
+  #chat = null;
+  constructor(config) {
+    this.#client = new Liveblocks({ secret: config.apiKey });
+    this.#webhookHandler = new WebhookHandler(config.webhookSecret);
+    this.#resolveUsers = config.resolveUsers;
+    this.#resolveGroupsInfo = config.resolveGroupsInfo;
+    this.#botUserId = config.botUserId;
+    this.userName = config.botUserName ?? "liveblocks-bot";
+    this.#logger = config.logger ?? new ConsoleLogger("info").child(ADAPTER_PREFIX);
+  }
+  async initialize(chat) {
+    this.#chat = chat;
+  }
+  async handleWebhook(request, options) {
+    let event;
+    try {
+      event = this.#webhookHandler.verifyRequest({
+        headers: request.headers,
+        rawBody: await request.text()
+      });
+    } catch (error) {
+      this.#logger.error("Failed to verify webhook request", { error });
+      return new Response("Invalid webhook request", { status: 401 });
+    }
+    if (event.type === "commentCreated") {
+      const threadId = this.encodeThreadId({
+        roomId: event.data.roomId,
+        threadId: event.data.threadId
+      });
+      const comment = await this.#client.getComment({
+        roomId: event.data.roomId,
+        threadId: event.data.threadId,
+        commentId: event.data.commentId
+      });
+      if (comment.deletedAt !== void 0) {
+        return new Response(null, { status: 200 });
+      }
+      this.#chat?.processMessage(
+        this,
+        threadId,
+        () => this.#convertLiveblocksCommentDataToChatMessage(comment),
+        options
+      );
+    } else if (event.type === "commentReactionAdded" || event.type === "commentReactionRemoved") {
+      const threadId = this.encodeThreadId({
+        roomId: event.data.roomId,
+        threadId: event.data.threadId
+      });
+      const userId = event.type === "commentReactionAdded" ? event.data.addedBy : event.data.removedBy;
+      const resolvedUsers = await this.#resolveUsers?.({ userIds: [userId] });
+      const user = resolvedUsers?.[0];
+      this.#chat?.processReaction(
+        {
+          added: event.type === "commentReactionAdded",
+          emoji: defaultEmojiResolver.fromGChat(event.data.emoji),
+          rawEmoji: event.data.emoji,
+          messageId: event.data.commentId,
+          threadId,
+          user: {
+            userId,
+            userName: user?.name ?? userId,
+            fullName: user?.name ?? userId,
+            // This assumes that the current bot is the only bot in the thread; if we want
+            // to support multiple bots, we need to add a way to determine the bot's user id.
+            isBot: userId === this.#botUserId,
+            isMe: userId === this.#botUserId
+          },
+          raw: event.data,
+          adapter: this
+        },
+        options
+      );
+    }
+    return new Response(null, { status: 200 });
+  }
+  async postMessage(threadId, message) {
+    const { roomId, threadId: threadId_liveblocks } = this.decodeThreadId(threadId);
+    const comment = await this.#client.createComment({
+      roomId,
+      threadId: threadId_liveblocks,
+      data: {
+        userId: this.#botUserId,
+        body: convertPostableMessageToCommentBody(message)
+      }
+    });
+    return { id: comment.id, threadId, raw: comment };
+  }
+  async editMessage(threadId, messageId, message) {
+    const { roomId, threadId: threadId_liveblocks } = this.decodeThreadId(threadId);
+    const comment = await this.#client.editComment({
+      roomId,
+      threadId: threadId_liveblocks,
+      commentId: messageId,
+      data: {
+        body: convertPostableMessageToCommentBody(message)
+      }
+    });
+    return { id: comment.id, threadId, raw: comment };
+  }
+  async deleteMessage(threadId, messageId) {
+    const { roomId, threadId: threadId_liveblocks } = this.decodeThreadId(threadId);
+    await this.#client.deleteComment({
+      roomId,
+      threadId: threadId_liveblocks,
+      commentId: messageId
+    });
+  }
+  async addReaction(threadId, messageId, emoji) {
+    const { roomId, threadId: threadId_liveblocks } = this.decodeThreadId(threadId);
+    await this.#client.addCommentReaction({
+      roomId,
+      threadId: threadId_liveblocks,
+      commentId: messageId,
+      data: {
+        // Liveblocks expects unicode emoji; 'toGChat' converts normalized names (e.g. 'thumbs_up') to unicode ('👍').
+        // Unknown normalized names (e.g. 'custom_emoji') will fail Liveblocks validation since they are not valid unicode emoji.
+        emoji: defaultEmojiResolver.toGChat(emoji),
+        userId: this.#botUserId
+      }
+    });
+  }
+  async removeReaction(threadId, messageId, emoji) {
+    const { roomId, threadId: threadId_liveblocks } = this.decodeThreadId(threadId);
+    await this.#client.removeCommentReaction({
+      roomId,
+      threadId: threadId_liveblocks,
+      commentId: messageId,
+      data: {
+        emoji: defaultEmojiResolver.toGChat(emoji),
+        userId: this.#botUserId
+      }
+    });
+  }
+  async fetchMessages(threadId, options) {
+    const { roomId, threadId: threadId_liveblocks } = this.decodeThreadId(threadId);
+    const thread = await this.#client.getThread({
+      roomId,
+      threadId: threadId_liveblocks
+    });
+    const comments = thread.comments.filter(
+      (comment) => comment.deletedAt === void 0
+    );
+    const direction = options?.direction ?? "backward";
+    const limit = options?.limit;
+    const startingAfter = options?.cursor;
+    const sliced = slicePageByCreatedAt(comments, {
+      direction: direction === "forward" ? "ascending" : "descending",
+      limit,
+      startingAfter
+    });
+    const messages = await Promise.all(
+      sliced.data.map(
+        (comment) => this.#convertLiveblocksCommentDataToChatMessage(comment)
+      )
+    );
+    return { messages, nextCursor: sliced.nextCursor };
+  }
+  async fetchThread(threadId) {
+    const { roomId, threadId: threadId_liveblocks } = this.decodeThreadId(threadId);
+    const thread = await this.#client.getThread({
+      roomId,
+      threadId: threadId_liveblocks
+    });
+    return {
+      id: threadId,
+      channelId: `${ADAPTER_PREFIX}:${roomId}`,
+      metadata: {
+        resolved: thread.resolved,
+        ...thread.metadata
+      },
+      channelName: thread.roomId,
+      isDM: false
+    };
+  }
+  async fetchMessage(threadId, messageId) {
+    try {
+      const { roomId, threadId: threadId_liveblocks } = this.decodeThreadId(threadId);
+      const comment = await this.#client.getComment({
+        roomId,
+        threadId: threadId_liveblocks,
+        commentId: messageId
+      });
+      if (comment.deletedAt !== void 0) {
+        return null;
+      }
+      return this.#convertLiveblocksCommentDataToChatMessage(comment);
+    } catch (error) {
+      if (error instanceof LiveblocksError && error.status === 404) {
+        return null;
+      }
+      throw error;
+    }
+  }
+  async listThreads(channelId, options) {
+    const roomId = getRoomIdFromChannelId(channelId);
+    const { data } = await this.#client.getThreads({ roomId });
+    const threads = data.map((thread) => {
+      const nonDeletedComments = thread.comments.filter((comment) => comment.deletedAt === void 0).sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
+      const firstNonDeletedComment = nonDeletedComments[0];
+      if (firstNonDeletedComment === void 0) return null;
+      return {
+        id: this.encodeThreadId({
+          roomId,
+          threadId: thread.id
+        }),
+        updatedAt: thread.updatedAt,
+        numOfComments: nonDeletedComments.length,
+        firstComment: firstNonDeletedComment
+      };
+    }).filter((thread) => thread !== null);
+    const limit = options?.limit;
+    const startingAfter = options?.cursor;
+    const sliced = slicePageByUpdatedAt(threads, {
+      limit,
+      startingAfter
+    });
+    return {
+      threads: await Promise.all(
+        sliced.data.map(async (thread) => ({
+          id: thread.id,
+          rootMessage: await this.#convertLiveblocksCommentDataToChatMessage(
+            thread.firstComment
+          ),
+          lastReplyAt: thread.updatedAt,
+          replyCount: thread.numOfComments - 1
+        }))
+      ),
+      nextCursor: sliced.nextCursor
+    };
+  }
+  async fetchChannelInfo(channelId) {
+    const room = await this.#client.getRoom(getRoomIdFromChannelId(channelId));
+    return {
+      id: room.id,
+      name: room.id,
+      isDM: false,
+      metadata: {}
+    };
+  }
+  async fetchChannelMessages(channelId, options) {
+    const roomId = getRoomIdFromChannelId(channelId);
+    const { data } = await this.#client.getThreads({ roomId });
+    const comments = data.map((thread) => {
+      const nonDeletedComments = thread.comments.filter((comment) => comment.deletedAt === void 0).sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
+      const firstNonDeletedComment = nonDeletedComments[0];
+      if (firstNonDeletedComment !== void 0) {
+        return firstNonDeletedComment;
+      }
+      return null;
+    }).filter((comment) => comment !== null);
+    const direction = options?.direction ?? "backward";
+    const limit = options?.limit;
+    const startingAfter = options?.cursor;
+    const sliced = slicePageByCreatedAt(comments, {
+      direction: direction === "forward" ? "ascending" : "descending",
+      limit,
+      startingAfter
+    });
+    const messages = await Promise.all(
+      sliced.data.map(
+        (comment) => this.#convertLiveblocksCommentDataToChatMessage(comment)
+      )
+    );
+    return { messages, nextCursor: sliced.nextCursor };
+  }
+  async postChannelMessage(channelId, message) {
+    const roomId = getRoomIdFromChannelId(channelId);
+    const thread = await this.#client.createThread({
+      roomId,
+      data: {
+        comment: {
+          userId: this.#botUserId,
+          body: convertPostableMessageToCommentBody(message)
+        }
+      }
+    });
+    const firstComment = thread.comments[0];
+    if (firstComment === void 0) {
+      throw new Error(`Failed to create thread in room ${channelId}`);
+    }
+    return {
+      id: firstComment.id,
+      threadId: this.encodeThreadId({
+        roomId,
+        threadId: thread.id
+      }),
+      raw: firstComment
+    };
+  }
+  // This method isn't used by the Chat SDK, but it's required to implement the Adapter interface,
+  // so we will return a less rich message here. We have a separate (asynchronous) method for converting a comment to a message.
+  parseMessage(data) {
+    return new Message({
+      id: data.id,
+      threadId: this.encodeThreadId({
+        roomId: data.roomId,
+        threadId: data.threadId
+      }),
+      raw: data,
+      formatted: { type: "root", children: [] },
+      text: "",
+      author: {
+        userId: data.userId,
+        userName: data.userId,
+        fullName: data.userId,
+        isBot: data.userId === this.#botUserId,
+        isMe: data.userId === this.#botUserId
+      },
+      metadata: {
+        dateSent: data.createdAt,
+        edited: !!data.editedAt,
+        editedAt: data.editedAt
+      },
+      attachments: data.attachments.map(
+        (att) => this.#createAttachment(data.roomId, att)
+      )
+    });
+  }
+  renderFormatted(content) {
+    return toPlainText(content);
+  }
+  channelIdFromThreadId(threadId) {
+    const { roomId } = this.decodeThreadId(threadId);
+    return `${ADAPTER_PREFIX}:${roomId}`;
+  }
+  /**
+   * This method is a no-op as typing indicators are not supported by Liveblocks Comments.
+   */
+  startTyping(_threadId, _status) {
+    return Promise.resolve();
+  }
+  #createAttachment(roomId, attachment) {
+    const client = this.#client;
+    return {
+      type: getAttachmentType(attachment.mimeType),
+      name: attachment.name,
+      mimeType: attachment.mimeType,
+      size: attachment.size,
+      fetchData: async () => {
+        const { url } = await client.getAttachment({
+          roomId,
+          attachmentId: attachment.id
+        });
+        const response = await fetch(url);
+        if (!response.ok) {
+          throw new Error(
+            `Failed to fetch attachment "${attachment.name}": ${response.status} ${response.statusText}`
+          );
+        }
+        return Buffer.from(await response.arrayBuffer());
+      }
+    };
+  }
+  /**
+   * Encodes a Liveblocks room ID and thread ID into a single thread ID string.
+   *
+   * Format: `liveblocks:{roomId}:{threadId}`
+   *
+   * **Note**: Room IDs may contain colons (':'), which are preserved during encoding/decoding.
+   * However, Liveblocks thread IDs must not contain colons as the last colon is used as the delimiter when decoding.
+   */
+  encodeThreadId(data) {
+    return `${ADAPTER_PREFIX}:${data.roomId}:${data.threadId}`;
+  }
+  /**
+   * Decodes an encoded thread ID string back into its room ID and thread ID components.
+   *
+   * @throws {Error} If the thread ID format is invalid
+   */
+  decodeThreadId(threadId) {
+    const parts = threadId.split(":");
+    if (parts.length < 3 || parts[0] !== ADAPTER_PREFIX) {
+      throw new Error(
+        `Invalid thread ID: ${threadId}. Expected format: liveblocks:{roomId}:{threadId}`
+      );
+    }
+    return {
+      roomId: parts.slice(1, -1).join(":"),
+      threadId: parts[parts.length - 1]
+    };
+  }
+  async #convertLiveblocksCommentDataToChatMessage(comment) {
+    const mentions = getMentionsFromCommentBody(comment.body);
+    const userIds = /* @__PURE__ */ new Set([comment.userId]);
+    const groupIds = /* @__PURE__ */ new Set();
+    for (const mention of mentions) {
+      if (mention.kind === "user") {
+        userIds.add(mention.id);
+      } else if (mention.kind === "group") {
+        groupIds.add(mention.id);
+      }
+    }
+    const [users, groups] = await Promise.all([
+      this.#resolveUsers ? this.#resolveUsers({ userIds: Array.from(userIds) }) : void 0,
+      this.#resolveGroupsInfo && groupIds.size > 0 ? this.#resolveGroupsInfo({ groupIds: Array.from(groupIds) }) : void 0
+    ]);
+    const resolvedUsers = /* @__PURE__ */ new Map();
+    if (users !== void 0) {
+      for (const [index, userId] of Array.from(userIds).entries()) {
+        const user = users[index];
+        if (user === void 0) continue;
+        resolvedUsers.set(userId, user);
+      }
+    }
+    const resolvedGroups = /* @__PURE__ */ new Map();
+    if (groups !== void 0) {
+      for (const [index, groupId] of Array.from(groupIds).entries()) {
+        const group = groups[index];
+        if (group === void 0) continue;
+        resolvedGroups.set(groupId, group);
+      }
+    }
+    const links = /* @__PURE__ */ new Set();
+    const nodes = comment.body.content.map((block) => {
+      const children = [];
+      for (const inline of block.children) {
+        if (isCommentBodyMention(inline)) {
+          if (inline.kind === "user") {
+            children.push({
+              type: "text",
+              value: resolvedUsers.get(inline.id)?.name ?? inline.id
+            });
+          } else {
+            children.push({
+              type: "text",
+              value: resolvedGroups.get(inline.id)?.name ?? inline.id
+            });
+          }
+        } else if (isCommentBodyLink(inline)) {
+          links.add(inline.url);
+          children.push({
+            type: "link",
+            children: [{ type: "text", value: inline.text ?? "" }],
+            url: inline.url
+          });
+        } else if (isCommentBodyText(inline)) {
+          if (inline.code) {
+            children.push({
+              type: "inlineCode",
+              value: inline.text
+            });
+          } else {
+            let node = {
+              type: "text",
+              value: inline.text
+            };
+            if (inline.strikethrough) {
+              node = { type: "delete", children: [node] };
+            }
+            if (inline.italic) {
+              node = { type: "emphasis", children: [node] };
+            }
+            if (inline.bold) {
+              node = { type: "strong", children: [node] };
+            }
+            children.push(node);
+          }
+        }
+      }
+      return { type: "paragraph", children };
+    });
+    const text = comment.body.content.reduce((acc, block) => {
+      return acc + block.children.reduce((acc2, inline) => {
+        if (isCommentBodyMention(inline)) {
+          if (inline.kind === "user") {
+            return acc2 + (resolvedUsers.get(inline.id)?.name ?? inline.id);
+          } else {
+            return acc2 + (resolvedGroups.get(inline.id)?.name ?? inline.id);
+          }
+        } else if (isCommentBodyLink(inline)) {
+          if (inline.text) {
+            return acc2 + inline.text;
+          } else {
+            return acc2 + inline.url;
+          }
+        } else if (isCommentBodyText(inline)) {
+          return acc2 + inline.text;
+        }
+        return acc2;
+      }, "");
+    }, "");
+    return new Message({
+      id: comment.id,
+      threadId: this.encodeThreadId({
+        roomId: comment.roomId,
+        threadId: comment.threadId
+      }),
+      raw: comment,
+      formatted: { type: "root", children: nodes },
+      text,
+      isMention: resolvedUsers.has(this.#botUserId),
+      links: Array.from(links.values()).map((url) => ({ url })),
+      author: {
+        userId: comment.userId,
+        userName: resolvedUsers.get(comment.userId)?.name ?? comment.userId,
+        fullName: resolvedUsers.get(comment.userId)?.name ?? comment.userId,
+        // This assumes that the current bot is the only bot in the thread; if we want
+        // to support multiple bots, we need to add a way to determine the bot's user id.
+        isBot: comment.userId === this.#botUserId,
+        isMe: comment.userId === this.#botUserId
+      },
+      metadata: {
+        dateSent: comment.createdAt,
+        edited: comment.editedAt !== void 0,
+        editedAt: comment.editedAt
+      },
+      attachments: comment.attachments.map(
+        (attachment) => this.#createAttachment(comment.roomId, attachment)
+      )
+    });
+  }
+};
+function getRoomIdFromChannelId(channelId) {
+  const prefix = `${ADAPTER_PREFIX}:`;
+  if (!channelId.startsWith(prefix)) {
+    throw new Error(
+      `Invalid channel ID: "${channelId}". Expected format: ${prefix}{roomId}`
+    );
+  }
+  const roomId = channelId.slice(prefix.length);
+  if (roomId === "") {
+    throw new Error(
+      `Invalid channel ID: "${channelId}". Expected format: ${prefix}{roomId}`
+    );
+  }
+  return roomId;
+}
+function convertPostableMessageToCommentBody(message) {
+  if (typeof message === "string") {
+    return convertChatRootElementToCommentBodyRootElement(
+      parseMarkdown(message)
+    );
+  } else if ("raw" in message) {
+    return convertChatRootElementToCommentBodyRootElement(
+      parseMarkdown(message.raw)
+    );
+  } else if ("markdown" in message) {
+    return convertChatRootElementToCommentBodyRootElement(
+      parseMarkdown(message.markdown)
+    );
+  } else if ("ast" in message) {
+    return convertChatRootElementToCommentBodyRootElement(message.ast);
+  } else if ("card" in message) {
+    return convertChatRootElementToCommentBodyRootElement(
+      parseMarkdown(
+        message.fallbackText ?? convertCardToMarkdownString(message.card)
+      )
+    );
+  } else if ("type" in message && message.type === "card") {
+    return convertChatRootElementToCommentBodyRootElement(
+      parseMarkdown(convertCardToMarkdownString(message))
+    );
+  } else {
+    console.error(`Unexpected message type: ${JSON.stringify(message)}`);
+    return {
+      version: 1,
+      content: []
+    };
+  }
+}
+function convertCardToMarkdownString(card) {
+  const parts = [];
+  if (card.title) {
+    parts.push(`**${card.title}**`);
+  }
+  if (card.subtitle) {
+    parts.push(card.subtitle);
+  }
+  for (const child of card.children) {
+    parts.push(convertCardChildToMarkdownString(child));
+  }
+  return parts.join("\n");
+}
+function convertCardChildToMarkdownString(child) {
+  switch (child.type) {
+    case "text":
+      return child.content;
+    case "fields":
+      return child.children.map((field) => `**${field.label}**: ${field.value}`).join("\n");
+    case "actions":
+      return "";
+    case "table": {
+      let markdown = "|";
+      for (const header of child.headers) {
+        markdown += ` ${header} |`;
+      }
+      markdown += "\n|";
+      for (const _ of child.headers) {
+        markdown += "--- |";
+      }
+      markdown += "\n";
+      for (const row of child.rows) {
+        markdown += "|";
+        for (const cell of row) {
+          markdown += ` ${cell} |`;
+        }
+        markdown += "\n";
+      }
+      return markdown;
+    }
+    case "section":
+      return child.children.map((c) => convertCardChildToMarkdownString(c)).filter(Boolean).join("\n");
+    case "link":
+      return `[${child.label}](${child.url})`;
+    case "divider":
+      return "---";
+    case "image":
+      return `![${child.alt ?? ""}](${child.url})`;
+    default:
+      return "";
+  }
+}
+function convertChatRootElementToCommentBodyRootElement(root) {
+  return {
+    version: 1,
+    content: root.children.flatMap(
+      (child) => convertChatBlockElementToCommentBodyBlockElement(child)
+    )
+  };
+}
+function convertChatBlockElementToCommentBodyBlockElement(node) {
+  switch (node.type) {
+    case "paragraph": {
+      const children = [];
+      for (const child of node.children) {
+        children.push(
+          convertChatInlineElementToCommentBodyInlineElement(child)
+        );
+      }
+      return {
+        type: "paragraph",
+        children
+      };
+    }
+    case "blockquote": {
+      return node.children.flatMap((child) => {
+        return convertChatBlockElementToCommentBodyBlockElement(child);
+      });
+    }
+    case "list": {
+      return node.children.flatMap((child) => {
+        return convertChatBlockElementToCommentBodyBlockElement(child);
+      });
+    }
+    case "listItem": {
+      return node.children.flatMap((child) => {
+        return convertChatBlockElementToCommentBodyBlockElement(child);
+      });
+    }
+    case "heading": {
+      return convertChatBlockElementToCommentBodyBlockElement({
+        type: "paragraph",
+        children: node.children
+      });
+    }
+    case "code": {
+      return convertChatBlockElementToCommentBodyBlockElement({
+        type: "paragraph",
+        children: [{ type: "text", value: node.value }]
+      });
+    }
+    case "html": {
+      return convertChatBlockElementToCommentBodyBlockElement({
+        type: "paragraph",
+        children: [{ type: "text", value: node.value }]
+      });
+    }
+    case "table": {
+      return {
+        type: "paragraph",
+        children: [{ text: tableToAscii(node) }]
+      };
+    }
+    case "link":
+    case "image":
+    case "strong":
+    case "emphasis":
+    case "inlineCode":
+    case "delete":
+    case "text": {
+      return {
+        type: "paragraph",
+        children: [convertChatInlineElementToCommentBodyInlineElement(node)]
+      };
+    }
+    case "break":
+    case "thematicBreak":
+    case "definition":
+    case "tableCell":
+    case "tableRow":
+    case "yaml":
+    case "footnoteDefinition":
+    case "footnoteReference":
+    case "imageReference":
+    case "linkReference":
+    default: {
+      return [];
+    }
+  }
+}
+function convertChatInlineElementToCommentBodyInlineElement(inline) {
+  switch (inline.type) {
+    case "text":
+      return { text: inline.value };
+    case "link":
+      return {
+        type: "link",
+        url: inline.url,
+        // Link elements in Liveblocks comments are considered leaf nodes (i.e. they do not have inline elements as children),
+        // so we convert the children to plain text to match the expected format
+        text: inline.children.map((child) => {
+          return convertChatInlineElementToPlainText(child);
+        }).join("")
+      };
+    case "image":
+      return { text: inline.url };
+    case "emphasis":
+      return {
+        // Emphasis elements in Liveblocks comments are considered leaf nodes (i.e. they do not have inline elements as children),
+        // so we convert the children to plain text to match the expected format
+        text: inline.children.map((child) => {
+          return convertChatInlineElementToPlainText(child);
+        }).join(""),
+        italic: true
+      };
+    case "strong":
+      return {
+        text: inline.children.map((child) => {
+          return convertChatInlineElementToPlainText(child);
+        }).join(""),
+        bold: true
+      };
+    case "delete":
+      return {
+        text: inline.children.map((child) => {
+          return convertChatInlineElementToPlainText(child);
+        }).join(""),
+        strikethrough: true
+      };
+    case "inlineCode":
+      return {
+        text: inline.value,
+        code: true
+      };
+    case "html":
+      return { text: inline.value };
+    case "break":
+    case "linkReference":
+    case "imageReference":
+    case "footnoteReference":
+    default: {
+      return { text: "" };
+    }
+  }
+}
+function convertChatInlineElementToPlainText(inline) {
+  switch (inline.type) {
+    case "text":
+      return inline.value;
+    case "link":
+      return inline.children.map((child) => {
+        return convertChatInlineElementToPlainText(child);
+      }).join("");
+    case "image":
+      return inline.url;
+    case "emphasis":
+      return inline.children.map((child) => {
+        return convertChatInlineElementToPlainText(child);
+      }).join("");
+    case "strong":
+      return inline.children.map((child) => {
+        return convertChatInlineElementToPlainText(child);
+      }).join("");
+    case "delete":
+      return inline.children.map((child) => {
+        return convertChatInlineElementToPlainText(child);
+      }).join("");
+    case "inlineCode":
+      return inline.value;
+    case "html":
+      return inline.value;
+    case "break":
+    case "linkReference":
+    case "imageReference":
+    case "footnoteReference":
+    default:
+      return "";
+  }
+}
+function encodePaginationCursorByCreatedAt(id, createdAt) {
+  return base64UrlEncode(
+    JSON.stringify([
+      ["id", id],
+      ["createdAt", createdAt.getTime()]
+    ])
+  );
+}
+function decodePaginationCursorByCreatedAt(cursor) {
+  try {
+    const parsed = JSON.parse(base64UrlDecode(cursor));
+    if (!Array.isArray(parsed) || parsed.length !== 2 || parsed[0]?.[0] !== "id" || parsed[1]?.[0] !== "createdAt") {
+      throw new Error("Invalid cursor structure");
+    }
+    return {
+      id: parsed[0][1],
+      createdAt: new Date(parsed[1][1])
+    };
+  } catch {
+    throw new Error(`Invalid pagination cursor: ${cursor}`);
+  }
+}
+function encodePaginationCursorByUpdatedAt(id, updatedAt) {
+  return base64UrlEncode(
+    JSON.stringify([
+      ["id", id],
+      ["updatedAt", updatedAt.getTime()]
+    ])
+  );
+}
+function decodePaginationCursorByUpdatedAt(cursor) {
+  try {
+    const parsed = JSON.parse(base64UrlDecode(cursor));
+    if (!Array.isArray(parsed) || parsed.length !== 2 || parsed[0]?.[0] !== "id" || parsed[1]?.[0] !== "updatedAt") {
+      throw new Error("Invalid cursor structure");
+    }
+    return {
+      id: parsed[0][1],
+      updatedAt: new Date(parsed[1][1])
+    };
+  } catch {
+    throw new Error(`Invalid pagination cursor: ${cursor}`);
+  }
+}
+function base64UrlEncode(str) {
+  const bytes = new TextEncoder().encode(str);
+  const binary = String.fromCharCode(...bytes);
+  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function base64UrlDecode(str) {
+  let s = str.replace(/-/g, "+").replace(/_/g, "/");
+  while (s.length % 4) s += "=";
+  const binary = atob(s);
+  const bytes = Uint8Array.from(binary, (c) => c.codePointAt(0));
+  return new TextDecoder().decode(bytes);
+}
+function slicePageByCreatedAt(data, options) {
+  const { direction, limit, startingAfter } = options;
+  data = data.slice().sort((a, b) => {
+    if (a.createdAt.getTime() !== b.createdAt.getTime()) {
+      return a.createdAt.getTime() - b.createdAt.getTime();
+    }
+    return b.id.localeCompare(a.id);
+  });
+  let startIndex;
+  let endIndex;
+  if (direction === "descending") {
+    if (startingAfter) {
+      const cursor = decodePaginationCursorByCreatedAt(startingAfter);
+      endIndex = data.findIndex(
+        (c) => c.createdAt.getTime() > cursor.createdAt.getTime() || c.createdAt.getTime() === cursor.createdAt.getTime() && c.id <= cursor.id
+      );
+      if (endIndex === -1) {
+        endIndex = data.length;
+      }
+    } else {
+      endIndex = data.length;
+    }
+    startIndex = limit !== void 0 ? Math.max(0, endIndex - limit) : 0;
+  } else {
+    if (startingAfter) {
+      const cursor = decodePaginationCursorByCreatedAt(startingAfter);
+      startIndex = data.findIndex(
+        (c) => c.createdAt.getTime() > cursor.createdAt.getTime() || c.createdAt.getTime() === cursor.createdAt.getTime() && c.id < cursor.id
+      );
+      if (startIndex === -1) {
+        return { data: [], nextCursor: void 0 };
+      }
+    } else {
+      startIndex = 0;
+    }
+    endIndex = limit !== void 0 ? Math.min(data.length, startIndex + limit) : data.length;
+  }
+  const page = data.slice(startIndex, endIndex);
+  if (page.length === 0) {
+    return { data: [], nextCursor: void 0 };
+  }
+  let nextCursor;
+  if (direction === "descending") {
+    nextCursor = startIndex > 0 ? encodePaginationCursorByCreatedAt(page[0].id, page[0].createdAt) : void 0;
+  } else {
+    nextCursor = endIndex < data.length ? encodePaginationCursorByCreatedAt(
+      page[page.length - 1].id,
+      page[page.length - 1].createdAt
+    ) : void 0;
+  }
+  return { data: page, nextCursor };
+}
+function slicePageByUpdatedAt(data, options) {
+  const { limit, startingAfter } = options;
+  data = data.slice().sort((a, b) => {
+    if (a.updatedAt.getTime() !== b.updatedAt.getTime()) {
+      return a.updatedAt.getTime() - b.updatedAt.getTime();
+    }
+    return b.id.localeCompare(a.id);
+  });
+  let endIndex;
+  if (startingAfter) {
+    const cursor = decodePaginationCursorByUpdatedAt(startingAfter);
+    endIndex = data.findIndex(
+      (c) => c.updatedAt.getTime() > cursor.updatedAt.getTime() || c.updatedAt.getTime() === cursor.updatedAt.getTime() && c.id <= cursor.id
+    );
+    if (endIndex === -1) {
+      endIndex = data.length;
+    }
+  } else {
+    endIndex = data.length;
+  }
+  const startIndex = limit !== void 0 ? Math.max(0, endIndex - limit) : 0;
+  const page = data.slice(startIndex, endIndex);
+  if (page.length === 0) {
+    return { data: [], nextCursor: void 0 };
+  }
+  const nextCursor = startIndex > 0 ? encodePaginationCursorByUpdatedAt(page[0].id, page[0].updatedAt) : void 0;
+  return { data: page, nextCursor };
+}
+function getAttachmentType(mimeType) {
+  if (mimeType.startsWith("image/")) {
+    return "image";
+  } else if (mimeType.startsWith("video/")) {
+    return "video";
+  } else if (mimeType.startsWith("audio/")) {
+    return "audio";
+  }
+  return "file";
+}
+function createLiveblocksAdapter(config) {
+  return new LiveblocksAdapter(config);
+}
+export {
+  createLiveblocksAdapter
+};
+//# sourceMappingURL=index.js.map