@liveblocks/core 1.8.1 → 1.8.2

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.8.2";
 var PKG_FORMAT = "esm";
 
 // src/dupe-detection.ts
@@ -3065,7 +3065,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];
@@ -6754,6 +6754,315 @@ function stringify(object, ...args) {
   return JSON.stringify(sortedObject, ...args);
 }
 
+// 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 = {
+  "&": "&amp;",
+  "<": "&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);
+}
+
 // src/index.ts
 detectDupes(PKG_NAME, PKG_VERSION, PKG_FORMAT);
 export {
@@ -6780,6 +7089,7 @@ export {
   detectDupes,
   errorIf,
   freeze,
+  getMentionedIdsFromCommentBody,
   isChildCrdt,
   isJsonArray,
   isJsonObject,
@@ -6797,6 +7107,7 @@ export {
   raise,
   shallow,
   stringify,
+  stringifyCommentBody,
   throwUsageError,
   toPlainLson,
   tryParseJson,