@liveblocks/emails 0.0.1 → 2.9.2-emails1

package/dist/index.mjs

@@ -0,0 +1,638 @@
+// src/index.ts
+import { detectDupes } from "@liveblocks/core";
+
+// src/version.ts
+var PKG_NAME = "@liveblocks/emails";
+var PKG_VERSION = "2.9.2-emails1";
+var PKG_FORMAT = "esm";
+
+// src/thread-notification.tsx
+import {
+  generateCommentUrl,
+  getMentionedIdsFromCommentBody
+} from "@liveblocks/core";
+
+// src/comment-body.tsx
+import {
+  html,
+  htmlSafe,
+  isCommentBodyLink,
+  isCommentBodyMention,
+  isCommentBodyText,
+  resolveUsersInCommentBody,
+  stringifyCommentBody,
+  toAbsoluteUrl
+} from "@liveblocks/core";
+import React from "react";
+
+// src/lib/css-properties.ts
+var VENDORS_PREFIXES = new RegExp(/^(webkit|moz|ms|o)-/);
+var UNITLESS_PROPERTIES = [
+  "animationIterationCount",
+  "aspectRatio",
+  "borderImageOutset",
+  "borderImageSlice",
+  "borderImageWidth",
+  "boxFlex",
+  "boxFlexGroup",
+  "boxOrdinalGroup",
+  "columnCount",
+  "columns",
+  "flex",
+  "flexGrow",
+  "flexPositive",
+  "flexShrink",
+  "flexNegative",
+  "flexOrder",
+  "gridArea",
+  "gridRow",
+  "gridRowEnd",
+  "gridRowSpan",
+  "gridRowStart",
+  "gridColumn",
+  "gridColumnEnd",
+  "gridColumnSpan",
+  "gridColumnStart",
+  "fontWeight",
+  "lineClamp",
+  "lineHeight",
+  "opacity",
+  "order",
+  "orphans",
+  "scale",
+  "tabSize",
+  "widows",
+  "zIndex",
+  "zoom",
+  "fillOpacity",
+  "floodOpacity",
+  "stopOpacity",
+  "strokeDasharray",
+  "strokeDashoffset",
+  "strokeMiterlimit",
+  "strokeOpacity",
+  "strokeWidth",
+  "MozAnimationIterationCount",
+  "MozBoxFlex",
+  "MozBoxFlexGroup",
+  "MozLineClamp",
+  "msAnimationIterationCount",
+  "msFlex",
+  "msZoom",
+  "msFlexPositive",
+  "msGridColumns",
+  "msGridRows",
+  "WebkitAnimationIterationCount",
+  "WebkitBoxFlex",
+  "WebKitBoxFlexGroup",
+  "WebkitBoxOrdinalGroup",
+  "WebkitColumnCount",
+  "WebkitColumns",
+  "WebkitFlex",
+  "WebkitFlexGrow",
+  "WebkitFlexPositive",
+  "WebkitFlexShrink",
+  "WebkitLineClamp"
+];
+function toInlineCSSString(styles) {
+  const entries = Object.entries(styles);
+  const inline = entries.map(([key, value]) => {
+    if (value === null || typeof value === "boolean" || value === "" || typeof value === "undefined") {
+      return "";
+    }
+    let property = key.replace(/([A-Z])/g, "-$1").toLowerCase();
+    if (VENDORS_PREFIXES.test(property)) {
+      property = `-${property}`;
+    }
+    if (typeof value === "number" && !UNITLESS_PROPERTIES.includes(key)) {
+      return `${property}:${value}px;`;
+    }
+    return `${property}:${String(value).trim()};`;
+  }).filter(Boolean).join("");
+  return inline;
+}
+
+// src/comment-body.tsx
+var baseComponents = {
+  Container: ({ children }) => /* @__PURE__ */ React.createElement("div", null, children),
+  Paragraph: ({ children }) => /* @__PURE__ */ React.createElement("p", null, children),
+  Text: ({ element }) => {
+    let children = element.text;
+    if (element.bold) {
+      children = /* @__PURE__ */ React.createElement("strong", null, children);
+    }
+    if (element.italic) {
+      children = /* @__PURE__ */ React.createElement("em", null, children);
+    }
+    if (element.strikethrough) {
+      children = /* @__PURE__ */ React.createElement("s", null, children);
+    }
+    if (element.code) {
+      children = /* @__PURE__ */ React.createElement("code", null, children);
+    }
+    return /* @__PURE__ */ React.createElement("span", null, children);
+  },
+  Link: ({ element, href }) => /* @__PURE__ */ React.createElement("a", { href, target: "_blank", rel: "noopener noreferrer" }, element.text ?? element.url),
+  Mention: ({ element, user }) => /* @__PURE__ */ React.createElement("span", { "data-mention": true }, "@", user?.name ?? element.id)
+};
+async function convertCommentBodyAsReact(body, options) {
+  const Components = {
+    ...baseComponents,
+    ...options?.components
+  };
+  const resolvedUsers = await resolveUsersInCommentBody(
+    body,
+    options?.resolveUsers
+  );
+  const blocks = body.content.map((block, index) => {
+    switch (block.type) {
+      case "paragraph": {
+        const children = block.children.map((inline, inlineIndex) => {
+          if (isCommentBodyMention(inline)) {
+            return inline.id ? /* @__PURE__ */ React.createElement(
+              Components.Mention,
+              {
+                key: `lb-comment-body-mention-${inlineIndex}`,
+                element: inline,
+                user: resolvedUsers.get(inline.id)
+              }
+            ) : null;
+          }
+          if (isCommentBodyLink(inline)) {
+            const href = toAbsoluteUrl(inline.url) ?? inline.url;
+            return /* @__PURE__ */ React.createElement(
+              Components.Link,
+              {
+                key: `lb-comment-body-link-${inlineIndex}`,
+                element: inline,
+                href
+              }
+            );
+          }
+          if (isCommentBodyText(inline)) {
+            return /* @__PURE__ */ React.createElement(
+              Components.Text,
+              {
+                key: `lb-comment-body-text-${inlineIndex}`,
+                element: inline
+              }
+            );
+          }
+          return null;
+        });
+        return /* @__PURE__ */ React.createElement(Components.Paragraph, { key: `lb-comment-body-paragraph-${index}` }, children);
+      }
+      default:
+        console.warn(
+          `Unsupported comment body block type: "${JSON.stringify(block.type)}"`
+        );
+        return null;
+    }
+  });
+  return /* @__PURE__ */ React.createElement(Components.Container, { key: "lb-comment-body-container" }, blocks);
+}
+var baseStyles = {
+  paragraph: {
+    fontSize: "14px"
+  },
+  strong: {
+    fontWeight: 500
+  },
+  code: {
+    fontFamily: 'ui-monospace, Menlo, Monaco, "Cascadia Mono", "Segoe UI Mono", "Roboto Mono", "Oxygen Mono", "Ubuntu Mono", "Source Code Pro", "Fira Mono", "Droid Sans Mono", "Consolas", "Courier New", monospace',
+    backgroundColor: "rgba(0,0,0,0.05)",
+    border: "solid 1px rgba(0,0,0,0.1)",
+    borderRadius: "4px"
+  },
+  mention: {
+    color: "blue"
+  },
+  link: {
+    textDecoration: "underline"
+  }
+};
+async function convertCommentBodyAsHtml(body, options) {
+  const styles = { ...baseStyles, ...options?.styles };
+  const htmlBody = await stringifyCommentBody(body, {
+    format: "html",
+    resolveUsers: options?.resolveUsers,
+    elements: {
+      // NOTE: using prettier-ignore to preserve template strings
+      paragraph: ({ children }) => (
+        // prettier-ignore
+        children ? html`<p style="${toInlineCSSString(styles.paragraph)}">${htmlSafe(children)}</p>` : children
+      ),
+      text: ({ element }) => {
+        let children = element.text;
+        if (!children) {
+          return children;
+        }
+        if (element.bold) {
+          children = html`<strong style="${toInlineCSSString(styles.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 style="${toInlineCSSString(styles.code)}">${children}</code>`;
+        }
+        return children;
+      },
+      link: ({ element, href }) => {
+        return html`<a href="${href}" target="_blank" rel="noopener noreferrer" style="${toInlineCSSString(styles.link)}">${element.text ?? element.url}</a>`;
+      },
+      mention: ({ element, user }) => {
+        return html`<span data-mention style="${toInlineCSSString(styles.mention)}">@${user?.name ?? element.id}</span>`;
+      }
+    }
+  });
+  return htmlBody;
+}
+
+// src/comment-with-body.ts
+var isCommentDataWithBody = (comment) => {
+  return comment.body !== void 0 && comment.deletedAt === void 0;
+};
+function filterCommentsWithBody(comments) {
+  const commentsWithBody = [];
+  for (const comment of comments) {
+    if (isCommentDataWithBody(comment)) {
+      commentsWithBody.push(comment);
+    }
+  }
+  return commentsWithBody;
+}
+
+// src/lib/batch-users-resolver.ts
+import { Promise_withResolvers } from "@liveblocks/core";
+
+// src/lib/warning.ts
+var createDevelopmentWarning = (condition, ...args) => {
+  let hasWarned = false;
+  if (process.env.NODE_ENV !== "production") {
+    return () => {
+      if (!hasWarned && (typeof condition === "function" ? condition() : condition)) {
+        console.warn(...args);
+        hasWarned = true;
+      }
+    };
+  } else {
+    return () => {
+    };
+  }
+};
+
+// src/lib/batch-users-resolver.ts
+var BatchUsersResolver = class {
+  constructor(resolveUsers) {
+    this.resolveUsers = async (args) => {
+      if (this.isResolved) {
+        this.warnAsAlreadyResolved();
+        return void 0;
+      }
+      for (const userId of args.userIds) {
+        this.usersById.set(userId, void 0);
+      }
+      await this.resolvePromise;
+      return args.userIds.map((userId) => this.usersById.get(userId));
+    };
+    const { promise, resolve } = Promise_withResolvers();
+    this.isResolved = false;
+    this.markAsResolved = resolve;
+    this.resolvePromise = promise;
+    this.primeResolveUsersFn = resolveUsers;
+    this.usersById = /* @__PURE__ */ new Map();
+    this.warnAsAlreadyResolved = createDevelopmentWarning(
+      true,
+      "Batch users resolver promise already resolved. It can only resolve once."
+    );
+  }
+  async resolve() {
+    if (this.isResolved) {
+      this.warnAsAlreadyResolved();
+      return;
+    }
+    const userIds = Array.from(this.usersById.keys());
+    const users = await this.primeResolveUsersFn?.({ userIds });
+    for (const [index, userId] of userIds.entries()) {
+      const user = users?.[index];
+      this.usersById.set(userId, user);
+    }
+    this.isResolved = true;
+    this.markAsResolved();
+  }
+};
+function createBatchUsersResolver({
+  resolveUsers,
+  callerName
+}) {
+  const warnIfNoResolveUsers = createDevelopmentWarning(
+    () => !resolveUsers,
+    `Set "resolveUsers" option in "${callerName}" to specify users info`
+  );
+  const batchUsersResolver = new BatchUsersResolver(resolveUsers);
+  const resolve = async () => {
+    warnIfNoResolveUsers();
+    await batchUsersResolver.resolve();
+  };
+  return {
+    resolveUsers: batchUsersResolver.resolveUsers,
+    resolve
+  };
+}
+
+// src/thread-notification.tsx
+var getUnreadComments = ({
+  comments,
+  inboxNotification,
+  userId
+}) => {
+  const commentsWithBody = filterCommentsWithBody(comments);
+  const readAt = inboxNotification.readAt;
+  return commentsWithBody.filter((c) => c.userId !== userId).filter(
+    (c) => readAt ? c.createdAt > readAt && c.createdAt <= inboxNotification.notifiedAt : c.createdAt <= inboxNotification.notifiedAt
+  );
+};
+var getLastUnreadCommentWithMention = ({
+  comments,
+  mentionedUserId
+}) => {
+  return Array.from(comments).reverse().filter((c) => c.userId !== mentionedUserId).find((c) => {
+    const mentionedUserIds = getMentionedIdsFromCommentBody(c.body);
+    return mentionedUserIds.includes(mentionedUserId);
+  }) ?? null;
+};
+var extractThreadNotificationData = async ({
+  client,
+  event
+}) => {
+  const { threadId, roomId, userId, inboxNotificationId } = event.data;
+  const [thread, inboxNotification] = await Promise.all([
+    client.getThread({ roomId, threadId }),
+    client.getInboxNotification({ inboxNotificationId, userId })
+  ]);
+  const unreadComments = getUnreadComments({
+    comments: thread.comments,
+    inboxNotification,
+    userId
+  });
+  if (unreadComments.length <= 0) {
+    return null;
+  }
+  const lastUnreadCommentWithMention = getLastUnreadCommentWithMention({
+    comments: unreadComments,
+    mentionedUserId: userId
+  });
+  if (lastUnreadCommentWithMention !== null) {
+    return { type: "unreadMention", comment: lastUnreadCommentWithMention };
+  }
+  return {
+    type: "unreadReplies",
+    comments: unreadComments
+  };
+};
+var makeCommentEmailBaseData = ({
+  roomInfo,
+  comment
+}) => {
+  const url = roomInfo?.url ? generateCommentUrl({
+    roomUrl: roomInfo?.url,
+    commentId: comment.id
+  }) : void 0;
+  return {
+    id: comment.id,
+    userId: comment.userId,
+    threadId: comment.threadId,
+    roomId: comment.roomId,
+    createdAt: comment.createdAt,
+    url,
+    rawBody: comment.body
+  };
+};
+var prepareThreadNotificationEmailBaseData = async ({
+  client,
+  event,
+  options = {}
+}) => {
+  const { roomId } = event.data;
+  const roomInfo = options.resolveRoomInfo ? await options.resolveRoomInfo({ roomId }) : void 0;
+  const resolvedRoomInfo = {
+    ...roomInfo,
+    name: roomInfo?.name ?? roomId
+  };
+  const data = await extractThreadNotificationData({ client, event });
+  if (data === null) {
+    return null;
+  }
+  switch (data.type) {
+    case "unreadMention":
+      return {
+        type: "unreadMention",
+        comment: makeCommentEmailBaseData({
+          roomInfo,
+          comment: data.comment
+        }),
+        roomInfo: resolvedRoomInfo
+      };
+    case "unreadReplies": {
+      return {
+        type: "unreadReplies",
+        comments: data.comments.map(
+          (comment) => makeCommentEmailBaseData({ roomInfo, comment })
+        ),
+        roomInfo: resolvedRoomInfo
+      };
+    }
+  }
+};
+var resolveAuthorsInfo = async ({
+  comments,
+  resolveUsers
+}) => {
+  const resolvedAuthors = /* @__PURE__ */ new Map();
+  if (!resolveUsers) {
+    return resolvedAuthors;
+  }
+  const userIds = comments.map((c) => c.userId);
+  const users = await resolveUsers({ userIds });
+  for (const [index, userId] of userIds.entries()) {
+    const user = users?.[index];
+    if (user) {
+      resolvedAuthors.set(userId, user);
+    }
+  }
+  return resolvedAuthors;
+};
+async function prepareThreadNotificationEmailAsHtml(client, event, options = {}) {
+  const data = await prepareThreadNotificationEmailBaseData({
+    client,
+    event,
+    options: { resolveRoomInfo: options.resolveRoomInfo }
+  });
+  if (data === null) {
+    return null;
+  }
+  const batchUsersResolver = createBatchUsersResolver({
+    resolveUsers: options.resolveUsers,
+    callerName: "prepareThreadNotificationEmailAsHtml"
+  });
+  switch (data.type) {
+    case "unreadMention": {
+      const { comment } = data;
+      const authorsInfoPromise = resolveAuthorsInfo({
+        comments: [comment],
+        resolveUsers: batchUsersResolver.resolveUsers
+      });
+      const commentBodyPromise = convertCommentBodyAsHtml(comment.rawBody, {
+        resolveUsers: batchUsersResolver.resolveUsers,
+        styles: options.styles
+      });
+      await batchUsersResolver.resolve();
+      const [authorsInfo, commentBodyHtml] = await Promise.all([
+        authorsInfoPromise,
+        commentBodyPromise
+      ]);
+      const authorInfo = authorsInfo.get(comment.userId);
+      return {
+        type: "unreadMention",
+        comment: {
+          id: comment.id,
+          threadId: comment.threadId,
+          roomId: comment.roomId,
+          author: authorInfo ? { id: comment.userId, info: authorInfo } : { id: comment.userId, info: { name: comment.userId } },
+          createdAt: comment.createdAt,
+          url: comment.url,
+          htmlBody: commentBodyHtml
+        },
+        roomInfo: data.roomInfo
+      };
+    }
+    case "unreadReplies": {
+      const { comments } = data;
+      const authorsInfoPromise = resolveAuthorsInfo({
+        comments,
+        resolveUsers: batchUsersResolver.resolveUsers
+      });
+      const commentBodiesPromises = comments.map(
+        (c) => convertCommentBodyAsHtml(c.rawBody, {
+          resolveUsers: batchUsersResolver.resolveUsers,
+          styles: options.styles
+        })
+      );
+      await batchUsersResolver.resolve();
+      const [authorsInfo, ...commentBodies] = await Promise.all([
+        authorsInfoPromise,
+        ...commentBodiesPromises
+      ]);
+      return {
+        type: "unreadReplies",
+        comments: comments.map((comment, index) => {
+          const authorInfo = authorsInfo.get(comment.userId);
+          const commentBodyHtml = commentBodies[index];
+          return {
+            id: comment.id,
+            threadId: comment.threadId,
+            roomId: comment.roomId,
+            author: authorInfo ? { id: comment.userId, info: authorInfo } : { id: comment.userId, info: { name: comment.userId } },
+            createdAt: comment.createdAt,
+            url: comment.url,
+            htmlBody: commentBodyHtml ?? ""
+          };
+        }),
+        roomInfo: data.roomInfo
+      };
+    }
+  }
+}
+async function prepareThreadNotificationEmailAsReact(client, event, options = {}) {
+  const data = await prepareThreadNotificationEmailBaseData({
+    client,
+    event,
+    options: { resolveRoomInfo: options.resolveRoomInfo }
+  });
+  if (data === null) {
+    return null;
+  }
+  const batchUsersResolver = createBatchUsersResolver({
+    resolveUsers: options.resolveUsers,
+    callerName: "prepareThreadNotificationEmailAsReact"
+  });
+  switch (data.type) {
+    case "unreadMention": {
+      const { comment } = data;
+      const authorsInfoPromise = resolveAuthorsInfo({
+        comments: [comment],
+        resolveUsers: batchUsersResolver.resolveUsers
+      });
+      const commentBodyPromise = convertCommentBodyAsReact(comment.rawBody, {
+        resolveUsers: batchUsersResolver.resolveUsers,
+        components: options.components
+      });
+      await batchUsersResolver.resolve();
+      const [authorsInfo, commentBodyReact] = await Promise.all([
+        authorsInfoPromise,
+        commentBodyPromise
+      ]);
+      const authorInfo = authorsInfo.get(comment.userId);
+      return {
+        type: "unreadMention",
+        comment: {
+          id: comment.id,
+          threadId: comment.threadId,
+          roomId: comment.roomId,
+          author: authorInfo ? { id: comment.userId, info: authorInfo } : { id: comment.userId, info: { name: comment.userId } },
+          createdAt: comment.createdAt,
+          url: comment.url,
+          reactBody: commentBodyReact
+        },
+        roomInfo: data.roomInfo
+      };
+    }
+    case "unreadReplies": {
+      const { comments } = data;
+      const authorsInfoPromise = resolveAuthorsInfo({
+        comments,
+        resolveUsers: batchUsersResolver.resolveUsers
+      });
+      const commentBodiesPromises = comments.map(
+        (c) => convertCommentBodyAsReact(c.rawBody, {
+          resolveUsers: batchUsersResolver.resolveUsers,
+          components: options.components
+        })
+      );
+      await batchUsersResolver.resolve();
+      const [authorsInfo, ...commentBodies] = await Promise.all([
+        authorsInfoPromise,
+        ...commentBodiesPromises
+      ]);
+      return {
+        type: "unreadReplies",
+        comments: comments.map((comment, index) => {
+          const authorInfo = authorsInfo.get(comment.userId);
+          const commentBodyReact = commentBodies[index];
+          return {
+            id: comment.id,
+            threadId: comment.threadId,
+            roomId: comment.roomId,
+            author: authorInfo ? { id: comment.userId, info: authorInfo } : { id: comment.userId, info: { name: comment.userId } },
+            createdAt: comment.createdAt,
+            url: comment.url,
+            reactBody: commentBodyReact ?? null
+          };
+        }),
+        roomInfo: data.roomInfo
+      };
+    }
+  }
+}
+
+// src/index.ts
+detectDupes(PKG_NAME, PKG_VERSION, PKG_FORMAT);
+export {
+  prepareThreadNotificationEmailAsHtml,
+  prepareThreadNotificationEmailAsReact
+};
+//# sourceMappingURL=index.mjs.map