@liveblocks/core 1.8.1 → 1.9.0-example1

package/dist/index.mjs

@@ -6,7 +6,7 @@ var __export = (target, all) => {
 
 // src/version.ts
 var PKG_NAME = "@liveblocks/core";
-var PKG_VERSION = "1.8.1";
+var PKG_VERSION = "1.9.0-example1";
 var PKG_FORMAT = "esm";
 
 // src/dupe-detection.ts
@@ -1744,6 +1744,359 @@ function errorIf(condition, message) {
   }
 }
 
+// src/comments/comment-body.ts
+function isCommentBodyParagraph(element) {
+  return "type" in element && element.type === "mention";
+}
+function isCommentBodyText(element) {
+  return "text" in element && typeof element.text === "string";
+}
+function isCommentBodyMention(element) {
+  return "type" in element && element.type === "mention";
+}
+function isCommentBodyLink(element) {
+  return "type" in element && element.type === "link";
+}
+var commentBodyElementsGuards = {
+  paragraph: isCommentBodyParagraph,
+  text: isCommentBodyText,
+  link: isCommentBodyLink,
+  mention: isCommentBodyMention
+};
+var commentBodyElementsTypes = {
+  paragraph: "block",
+  text: "inline",
+  link: "inline",
+  mention: "inline"
+};
+function traverseCommentBody(body, elementOrVisitor, possiblyVisitor) {
+  if (!body || !body?.content) {
+    return;
+  }
+  const element = typeof elementOrVisitor === "string" ? elementOrVisitor : void 0;
+  const type = element ? commentBodyElementsTypes[element] : "all";
+  const guard = element ? commentBodyElementsGuards[element] : () => true;
+  const visitor = typeof elementOrVisitor === "function" ? elementOrVisitor : possiblyVisitor;
+  for (const block of body.content) {
+    if (type === "all" || type === "block") {
+      if (guard(block)) {
+        visitor?.(block);
+      }
+    }
+    if (type === "all" || type === "inline") {
+      for (const inline of block.children) {
+        if (guard(inline)) {
+          visitor?.(inline);
+        }
+      }
+    }
+  }
+}
+function getMentionedIdsFromCommentBody(body) {
+  const mentionedIds = /* @__PURE__ */ new Set();
+  traverseCommentBody(
+    body,
+    "mention",
+    (mention) => mentionedIds.add(mention.id)
+  );
+  return Array.from(mentionedIds);
+}
+async function resolveUsersInCommentBody(body, resolveUsers) {
+  const resolvedUsers = /* @__PURE__ */ new Map();
+  if (!resolveUsers) {
+    return resolvedUsers;
+  }
+  const userIds = getMentionedIdsFromCommentBody(body);
+  const users = await resolveUsers({
+    userIds
+  });
+  for (const [index, userId] of userIds.entries()) {
+    const user = users?.[index];
+    if (user) {
+      resolvedUsers.set(userId, user);
+    }
+  }
+  return resolvedUsers;
+}
+var htmlEscapables = {
+  "&": "&",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&#39;"
+};
+var htmlEscapablesRegex = new RegExp(
+  Object.keys(htmlEscapables).map((entity) => `\\${entity}`).join("|"),
+  "g"
+);
+function htmlSafe(value) {
+  return new HtmlSafeString([String(value)], []);
+}
+function joinHtml(strings) {
+  if (strings.length <= 0) {
+    return new HtmlSafeString([""], []);
+  }
+  return new HtmlSafeString(
+    ["", ...Array(strings.length - 1).fill(""), ""],
+    strings
+  );
+}
+function escapeHtml(value) {
+  if (value instanceof HtmlSafeString) {
+    return value.toString();
+  }
+  if (Array.isArray(value)) {
+    return joinHtml(value).toString();
+  }
+  return String(value).replace(
+    htmlEscapablesRegex,
+    (character) => htmlEscapables[character]
+  );
+}
+var HtmlSafeString = class {
+  constructor(strings, values) {
+    this._strings = strings;
+    this._values = values;
+  }
+  toString() {
+    return this._strings.reduce((result, str, i) => {
+      return result + escapeHtml(nn(this._values[i - 1])) + str;
+    });
+  }
+};
+function html(strings, ...values) {
+  return new HtmlSafeString(strings, values);
+}
+var markdownEscapables = {
+  _: "\\_",
+  "*": "\\*",
+  "#": "\\#",
+  "`": "\\`",
+  "~": "\\~",
+  "!": "\\!",
+  "|": "\\|",
+  "(": "\\(",
+  ")": "\\)",
+  "{": "\\{",
+  "}": "\\}",
+  "[": "\\[",
+  "]": "\\]"
+};
+var markdownEscapablesRegex = new RegExp(
+  Object.keys(markdownEscapables).map((entity) => `\\${entity}`).join("|"),
+  "g"
+);
+function joinMarkdown(strings) {
+  if (strings.length <= 0) {
+    return new MarkdownSafeString([""], []);
+  }
+  return new MarkdownSafeString(
+    ["", ...Array(strings.length - 1).fill(""), ""],
+    strings
+  );
+}
+function escapeMarkdown(value) {
+  if (value instanceof MarkdownSafeString) {
+    return value.toString();
+  }
+  if (Array.isArray(value)) {
+    return joinMarkdown(value).toString();
+  }
+  return String(value).replace(
+    markdownEscapablesRegex,
+    (character) => markdownEscapables[character]
+  );
+}
+var MarkdownSafeString = class {
+  constructor(strings, values) {
+    this._strings = strings;
+    this._values = values;
+  }
+  toString() {
+    return this._strings.reduce((result, str, i) => {
+      return result + escapeMarkdown(nn(this._values[i - 1])) + str;
+    });
+  }
+};
+function markdown(strings, ...values) {
+  return new MarkdownSafeString(strings, values);
+}
+function toAbsoluteUrl(url) {
+  if (url.startsWith("http://") || url.startsWith("https://")) {
+    return url;
+  } else if (url.startsWith("www.")) {
+    return "https://" + url;
+  }
+  return;
+}
+var stringifyCommentBodyPlainElements = {
+  paragraph: ({ children }) => children,
+  text: ({ element }) => element.text,
+  link: ({ element }) => element.url,
+  mention: ({ element, user }) => {
+    return `@${user?.name ?? element.id}`;
+  }
+};
+var stringifyCommentBodyHtmlElements = {
+  paragraph: ({ children }) => {
+    return children ? html`<p>${htmlSafe(children)}</p>` : children;
+  },
+  text: ({ element }) => {
+    let children = element.text;
+    if (!children) {
+      return children;
+    }
+    if (element.bold) {
+      children = html`<strong>${children}</strong>`;
+    }
+    if (element.italic) {
+      children = html`<em>${children}</em>`;
+    }
+    if (element.strikethrough) {
+      children = html`<s>${children}</s>`;
+    }
+    if (element.code) {
+      children = html`<code>${children}</code>`;
+    }
+    return children;
+  },
+  link: ({ element, href }) => {
+    return html`<a href="${href}" target="_blank" rel="noopener noreferrer">${element.url}</a>`;
+  },
+  mention: ({ element, user }) => {
+    return html`<span data-mention>@${user?.name ?? element.id}</span>`;
+  }
+};
+var stringifyCommentBodyMarkdownElements = {
+  paragraph: ({ children }) => {
+    return children;
+  },
+  text: ({ element }) => {
+    let children = element.text;
+    if (!children) {
+      return children;
+    }
+    if (element.bold) {
+      children = markdown`**${children}**`;
+    }
+    if (element.italic) {
+      children = markdown`_${children}_`;
+    }
+    if (element.strikethrough) {
+      children = markdown`~~${children}~~`;
+    }
+    if (element.code) {
+      children = markdown`\`${children}\``;
+    }
+    return children;
+  },
+  link: ({ element, href }) => {
+    return markdown`[${element.url}](${href})`;
+  },
+  mention: ({ element, user }) => {
+    return markdown`@${user?.name ?? element.id}`;
+  }
+};
+async function stringifyCommentBody(body, options) {
+  const format = options?.format ?? "plain";
+  const separator = options?.separator ?? (format === "markdown" ? "\n\n" : "\n");
+  const elements = {
+    ...format === "html" ? stringifyCommentBodyHtmlElements : format === "markdown" ? stringifyCommentBodyMarkdownElements : stringifyCommentBodyPlainElements,
+    ...options?.elements
+  };
+  const resolvedUsers = await resolveUsersInCommentBody(
+    body,
+    options?.resolveUsers
+  );
+  const blocks = body.content.flatMap((block, blockIndex) => {
+    switch (block.type) {
+      case "paragraph": {
+        const inlines = block.children.flatMap((inline, inlineIndex) => {
+          if (isCommentBodyMention(inline)) {
+            return inline.id ? [
+              elements.mention(
+                {
+                  element: inline,
+                  user: resolvedUsers.get(inline.id)
+                },
+                inlineIndex
+              )
+            ] : [];
+          }
+          if (isCommentBodyLink(inline)) {
+            return [
+              elements.link(
+                {
+                  element: inline,
+                  href: toAbsoluteUrl(inline.url) ?? inline.url
+                },
+                inlineIndex
+              )
+            ];
+          }
+          if (isCommentBodyText(inline)) {
+            return [elements.text({ element: inline }, inlineIndex)];
+          }
+          return [];
+        });
+        return [
+          elements.paragraph(
+            { element: block, children: inlines.join("") },
+            blockIndex
+          )
+        ];
+      }
+      default:
+        return [];
+    }
+  });
+  return blocks.join(separator);
+}
+function convertToCommentData(data) {
+  const editedAt = data.editedAt ? new Date(data.editedAt) : void 0;
+  const createdAt = new Date(data.createdAt);
+  const reactions = data.reactions.map((reaction) => ({
+    ...reaction,
+    createdAt: new Date(reaction.createdAt)
+  }));
+  if (data.body) {
+    return {
+      ...data,
+      reactions,
+      createdAt,
+      editedAt
+    };
+  } else {
+    const deletedAt = new Date(data.deletedAt);
+    return {
+      ...data,
+      reactions,
+      createdAt,
+      editedAt,
+      deletedAt
+    };
+  }
+}
+function convertToThreadData(data) {
+  const updatedAt = data.updatedAt ? new Date(data.updatedAt) : void 0;
+  const createdAt = new Date(data.createdAt);
+  const comments = data.comments.map(
+    (comment) => convertToCommentData(comment)
+  );
+  return {
+    ...data,
+    createdAt,
+    updatedAt,
+    comments
+  };
+}
+function convertToCommentUserReaction(data) {
+  return {
+    ...data,
+    createdAt: new Date(data.createdAt)
+  };
+}
+
 // src/comments/index.ts
 function getAuthBearerHeaderFromAuthValue(authValue) {
   if (authValue.type === "public") {
@@ -1805,39 +2158,43 @@ function createCommentsApi(roomId, getAuthValue, config) {
     const response = await fetchApi(roomId, "/threads");
     if (response.ok) {
       const json = await response.json();
-      return json.data;
+      return json.data.map((thread) => convertToThreadData(thread));
     } else if (response.status === 404) {
       return [];
     } else {
       throw new Error("There was an error while getting threads.");
     }
   }
-  function createThread({
+  async function createThread({
     metadata,
     body,
     commentId,
     threadId
   }) {
-    return fetchJson("/threads", {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
-        id: threadId,
-        comment: {
-          id: commentId,
-          body
+    const thread = await fetchJson(
+      "/threads",
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
         },
-        metadata
-      })
-    });
+        body: JSON.stringify({
+          id: threadId,
+          comment: {
+            id: commentId,
+            body
+          },
+          metadata
+        })
+      }
+    );
+    return convertToThreadData(thread);
   }
-  function editThreadMetadata({
+  async function editThreadMetadata({
     metadata,
     threadId
   }) {
-    return fetchJson(
+    return await fetchJson(
       `/threads/${encodeURIComponent(threadId)}/metadata`,
       {
         method: "POST",
@@ -1848,12 +2205,12 @@ function createCommentsApi(roomId, getAuthValue, config) {
       }
     );
   }
-  function createComment({
+  async function createComment({
     threadId,
     commentId,
     body
   }) {
-    return fetchJson(
+    const comment = await fetchJson(
       `/threads/${encodeURIComponent(threadId)}/comments`,
       {
         method: "POST",
@@ -1866,13 +2223,14 @@ function createCommentsApi(roomId, getAuthValue, config) {
         })
       }
     );
+    return convertToCommentData(comment);
   }
-  function editComment({
+  async function editComment({
     threadId,
     commentId,
     body
   }) {
-    return fetchJson(
+    const comment = await fetchJson(
       `/threads/${encodeURIComponent(threadId)}/comments/${encodeURIComponent(
         commentId
       )}`,
@@ -1886,6 +2244,7 @@ function createCommentsApi(roomId, getAuthValue, config) {
         })
       }
     );
+    return convertToCommentData(comment);
   }
   async function deleteComment({
     threadId,
@@ -1900,12 +2259,12 @@ function createCommentsApi(roomId, getAuthValue, config) {
       }
     );
   }
-  function addReaction({
+  async function addReaction({
     threadId,
     commentId,
     emoji
   }) {
-    return fetchJson(
+    const reaction = await fetchJson(
       `/threads/${encodeURIComponent(threadId)}/comments/${encodeURIComponent(
         commentId
       )}/reactions`,
@@ -1917,13 +2276,14 @@ function createCommentsApi(roomId, getAuthValue, config) {
         body: JSON.stringify({ emoji })
       }
     );
+    return convertToCommentUserReaction(reaction);
   }
-  function removeReaction({
+  async function removeReaction({
     threadId,
     commentId,
     emoji
   }) {
-    return fetchJson(
+    await fetchJson(
       `/threads/${encodeURIComponent(threadId)}/comments/${encodeURIComponent(
         commentId
       )}/reactions/${encodeURIComponent(emoji)}`,
@@ -3065,7 +3425,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
     this._pool?.assertStorageIsWritable();
     if (index < 0 || index >= this._items.length) {
       throw new Error(
-        `Cannot delete list item at index "${index}". index should be between 0 and ${this._items.length - 1}`
+        `Cannot delete list item at index "${index}". index should be between 0 and ${this._items.length - 1}`
       );
     }
     const item = this._items[index];
@@ -4995,9 +5355,13 @@ function createRoom(options, config) {
     ydoc: makeEventSource(),
     comments: makeEventSource()
   };
-  async function httpSend(authTokenOrPublicApiKey, roomId, nonce, messages) {
+  async function httpPostToRoom(endpoint, body) {
+    if (!managedSocket.authValue) {
+      throw new Error("Not authorized");
+    }
+    const authTokenOrPublicApiKey = managedSocket.authValue.type === "public" ? managedSocket.authValue.publicApiKey : managedSocket.authValue.token.raw;
     const url = new URL(
-      `/v2/c/rooms/${encodeURIComponent(roomId)}/send-message`,
+      `/v2/c/rooms/${encodeURIComponent(config.roomId)}${endpoint}`,
       config.baseUrl
     ).toString();
     const fetcher = config.polyfills?.fetch || /* istanbul ignore next */
@@ -5008,25 +5372,22 @@ function createRoom(options, config) {
         "Content-Type": "application/json",
         Authorization: `Bearer ${authTokenOrPublicApiKey}`
       },
-      body: JSON.stringify({ nonce, messages })
+      body: JSON.stringify(body)
     });
   }
   function sendMessages(messages) {
     const serializedPayload = JSON.stringify(messages);
     const nonce = context.dynamicSessionInfo.current?.nonce;
-    if (config.unstable_fallbackToHTTP && managedSocket.authValue && nonce) {
+    if (config.unstable_fallbackToHTTP && nonce) {
       const size = new TextEncoder().encode(serializedPayload).length;
       if (size > MAX_SOCKET_MESSAGE_SIZE) {
-        void httpSend(
-          managedSocket.authValue.type === "public" ? managedSocket.authValue.publicApiKey : managedSocket.authValue.token.raw,
-          config.roomId,
-          nonce,
-          messages
-        ).then((resp) => {
-          if (!resp.ok && resp.status === 403) {
-            managedSocket.reconnect();
+        void httpPostToRoom("/send-message", { nonce, messages }).then(
+          (resp) => {
+            if (!resp.ok && resp.status === 403) {
+              managedSocket.reconnect();
+            }
           }
-        });
+        );
         warn(
           "Message was too large for websockets and sent over HTTP instead"
         );
@@ -5539,7 +5900,7 @@ ${Array.from(traces).join("\n\n")}`
     }
     const now = Date.now();
     const elapsedMillis = now - context.buffer.lastFlushedAt;
-    if (elapsedMillis > config.throttleDelay) {
+    if (elapsedMillis >= config.throttleDelay) {
       const messagesToFlush = serializeBuffer();
       if (messagesToFlush.length === 0) {
         return;
@@ -6772,6 +7133,9 @@ export {
   b64decode,
   cloneLson,
   fancy_console_exports as console,
+  convertToCommentData,
+  convertToCommentUserReaction,
+  convertToThreadData,
   createAsyncCache,
   createClient,
   createCommentsApi,
@@ -6780,6 +7144,7 @@ export {
   detectDupes,
   errorIf,
   freeze,
+  getMentionedIdsFromCommentBody,
   isChildCrdt,
   isJsonArray,
   isJsonObject,
@@ -6797,6 +7162,7 @@ export {
   raise,
   shallow,
   stringify,
+  stringifyCommentBody,
   throwUsageError,
   toPlainLson,
   tryParseJson,