@liveblocks/emails 0.0.1 → 2.9.2-emails1

package/dist/index.js

@@ -0,0 +1,638 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/index.ts
+var _core = require('@liveblocks/core');
+
+// src/version.ts
+var PKG_NAME = "@liveblocks/emails";
+var PKG_VERSION = "2.9.2-emails1";
+var PKG_FORMAT = "cjs";
+
+// src/thread-notification.tsx
+
+
+
+
+
+// src/comment-body.tsx
+
+
+
+
+
+
+
+
+
+
+var _react = require('react'); var _react2 = _interopRequireDefault(_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__ */ _react2.default.createElement("div", null, children),
+  Paragraph: ({ children }) => /* @__PURE__ */ _react2.default.createElement("p", null, children),
+  Text: ({ element }) => {
+    let children = element.text;
+    if (element.bold) {
+      children = /* @__PURE__ */ _react2.default.createElement("strong", null, children);
+    }
+    if (element.italic) {
+      children = /* @__PURE__ */ _react2.default.createElement("em", null, children);
+    }
+    if (element.strikethrough) {
+      children = /* @__PURE__ */ _react2.default.createElement("s", null, children);
+    }
+    if (element.code) {
+      children = /* @__PURE__ */ _react2.default.createElement("code", null, children);
+    }
+    return /* @__PURE__ */ _react2.default.createElement("span", null, children);
+  },
+  Link: ({ element, href }) => /* @__PURE__ */ _react2.default.createElement("a", { href, target: "_blank", rel: "noopener noreferrer" }, _nullishCoalesce(element.text, () => ( element.url))),
+  Mention: ({ element, user }) => /* @__PURE__ */ _react2.default.createElement("span", { "data-mention": true }, "@", _nullishCoalesce(_optionalChain([user, 'optionalAccess', _ => _.name]), () => ( element.id)))
+};
+async function convertCommentBodyAsReact(body, options) {
+  const Components = {
+    ...baseComponents,
+    ..._optionalChain([options, 'optionalAccess', _2 => _2.components])
+  };
+  const resolvedUsers = await _core.resolveUsersInCommentBody.call(void 0, 
+    body,
+    _optionalChain([options, 'optionalAccess', _3 => _3.resolveUsers])
+  );
+  const blocks = body.content.map((block, index) => {
+    switch (block.type) {
+      case "paragraph": {
+        const children = block.children.map((inline, inlineIndex) => {
+          if (_core.isCommentBodyMention.call(void 0, inline)) {
+            return inline.id ? /* @__PURE__ */ _react2.default.createElement(
+              Components.Mention,
+              {
+                key: `lb-comment-body-mention-${inlineIndex}`,
+                element: inline,
+                user: resolvedUsers.get(inline.id)
+              }
+            ) : null;
+          }
+          if (_core.isCommentBodyLink.call(void 0, inline)) {
+            const href = _nullishCoalesce(_core.toAbsoluteUrl.call(void 0, inline.url), () => ( inline.url));
+            return /* @__PURE__ */ _react2.default.createElement(
+              Components.Link,
+              {
+                key: `lb-comment-body-link-${inlineIndex}`,
+                element: inline,
+                href
+              }
+            );
+          }
+          if (_core.isCommentBodyText.call(void 0, inline)) {
+            return /* @__PURE__ */ _react2.default.createElement(
+              Components.Text,
+              {
+                key: `lb-comment-body-text-${inlineIndex}`,
+                element: inline
+              }
+            );
+          }
+          return null;
+        });
+        return /* @__PURE__ */ _react2.default.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__ */ _react2.default.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, ..._optionalChain([options, 'optionalAccess', _4 => _4.styles]) };
+  const htmlBody = await _core.stringifyCommentBody.call(void 0, body, {
+    format: "html",
+    resolveUsers: _optionalChain([options, 'optionalAccess', _5 => _5.resolveUsers]),
+    elements: {
+      // NOTE: using prettier-ignore to preserve template strings
+      paragraph: ({ children }) => (
+        // prettier-ignore
+        children ? _core.html`<p style="${toInlineCSSString(styles.paragraph)}">${_core.htmlSafe.call(void 0, children)}</p>` : children
+      ),
+      text: ({ element }) => {
+        let children = element.text;
+        if (!children) {
+          return children;
+        }
+        if (element.bold) {
+          children = _core.html`<strong style="${toInlineCSSString(styles.strong)}">${children}</strong>`;
+        }
+        if (element.italic) {
+          children = _core.html`<em>${children}</em>`;
+        }
+        if (element.strikethrough) {
+          children = _core.html`<s>${children}</s>`;
+        }
+        if (element.code) {
+          children = _core.html`<code style="${toInlineCSSString(styles.code)}">${children}</code>`;
+        }
+        return children;
+      },
+      link: ({ element, href }) => {
+        return _core.html`<a href="${href}" target="_blank" rel="noopener noreferrer" style="${toInlineCSSString(styles.link)}">${_nullishCoalesce(element.text, () => ( element.url))}</a>`;
+      },
+      mention: ({ element, user }) => {
+        return _core.html`<span data-mention style="${toInlineCSSString(styles.mention)}">@${_nullishCoalesce(_optionalChain([user, 'optionalAccess', _6 => _6.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
+
+
+// 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 } = _core.Promise_withResolvers.call(void 0, );
+    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 _optionalChain([this, 'access', _7 => _7.primeResolveUsersFn, 'optionalCall', _8 => _8({ userIds })]);
+    for (const [index, userId] of userIds.entries()) {
+      const user = _optionalChain([users, 'optionalAccess', _9 => _9[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 _nullishCoalesce(Array.from(comments).reverse().filter((c) => c.userId !== mentionedUserId).find((c) => {
+    const mentionedUserIds = _core.getMentionedIdsFromCommentBody.call(void 0, 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 = _optionalChain([roomInfo, 'optionalAccess', _10 => _10.url]) ? _core.generateCommentUrl.call(void 0, {
+    roomUrl: _optionalChain([roomInfo, 'optionalAccess', _11 => _11.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: _nullishCoalesce(_optionalChain([roomInfo, 'optionalAccess', _12 => _12.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 = _optionalChain([users, 'optionalAccess', _13 => _13[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: _nullishCoalesce(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: _nullishCoalesce(commentBodyReact, () => ( null))
+          };
+        }),
+        roomInfo: data.roomInfo
+      };
+    }
+  }
+}
+
+// src/index.ts
+_core.detectDupes.call(void 0, PKG_NAME, PKG_VERSION, PKG_FORMAT);
+
+
+
+exports.prepareThreadNotificationEmailAsHtml = prepareThreadNotificationEmailAsHtml; exports.prepareThreadNotificationEmailAsReact = prepareThreadNotificationEmailAsReact;
+//# sourceMappingURL=index.js.map