Comments

const superdoc = new SuperDoc({
  selector: "#editor",
  document: "contract.docx",
  user: {
    name: "John Smith",
    email: "[email protected]",
  },
  modules: {
    comments: {
      readOnly: false,
      allowResolve: true,
      element: "#comments",
    },
  },
  onCommentsUpdate: ({ type, comment }) => {
    console.log("Comment event:", type);
  },
});

modules: {
  comments: {
    element: "#comments-sidebar";
  }
}

superdoc.on("ready", () => {
  const sidebar = document.querySelector("#comments-sidebar");
  superdoc.addCommentsList(sidebar);
});

onCommentsUpdate: ({ type, comment, meta }) => {
  switch(type) {
    case 'pending':
      showCommentDialog();
      break;
    case 'add':
      await saveComment(comment);
      break;
    case 'resolved':
      await markResolved(comment.id);
      break;
  }
}

// Parent comment
const parent = {
  commentId: "parent-123",
  commentText: "Should we change this?",
  parentCommentId: null,
};

// Reply
const reply = {
  commentId: "reply-456",
  commentText: "Yes, let's update",
  parentCommentId: "parent-123",
};

// Nested reply
const nested = {
  commentId: "reply-789",
  commentText: "Done",
  parentCommentId: "reply-456",
};

onCommentsUpdate: ({ type, comment }) => {
  if (type === 'resolved') {
    const resolution = {
      commentId: comment.commentId,
      resolvedTime: comment.resolvedTime,
      resolvedByName: comment.resolvedByName,
      resolvedByEmail: comment.resolvedByEmail
    };

    await api.resolveComment(resolution);
    notifyParticipants(comment);
  }
}

const canResolve = (comment, user, role) => {
  // Document owners can always resolve
  if (role === "editor") return true;

  // Authors can resolve their own
  if (comment.creatorEmail === user.email) return true;

  return false;
};

const importedComment = {
  commentId: "uuid-generated",
  importedId: "w15:123", // Original Word ID
  importedAuthor: {
    name: "John Smith (imported)",
    email: "[email protected]",
  },
  parentCommentId: "parent-uuid", // Relationships preserved
};

// With comments
const blob = await superdoc.export({
  commentsType: "external",
  isFinalDoc: false,
});

// Clean version
const cleanBlob = await superdoc.export({
  commentsType: "clean",
  isFinalDoc: true,
});

const superdoc = new SuperDoc({
  user: { name: "Alex Editor", email: "[email protected]" },
  modules: {
    comments: {
      permissionResolver: ({
        permission,
        trackedChange,
        currentUser,
        defaultDecision,
      }) => {
        const authorEmail = trackedChange?.attrs?.authorEmail;
        const activeUserEmail = currentUser?.email;
        if (
          permission === "RESOLVE_OTHER" &&
          authorEmail &&
          activeUserEmail !== authorEmail
        ) {
          return false; // Hide Accept button for suggestions from other authors
        }
        return defaultDecision;
      },
    },
  },
});

superdoc.activeEditor.commands.insertComment({
  commentText: "Review this section",
  creatorName: "John Smith",
  creatorEmail: "[email protected]",
});

superdoc.activeEditor.commands.removeComment({
  commentId: "comment-123",
});

superdoc.activeEditor.commands.setActiveComment({
  commentId: "comment-123",
});

superdoc.activeEditor.commands.resolveComment({
  commentId: "comment-123",
});

modules: {
  comments: {
    allowResolve: false, // Only owner resolves
    element: '#legal-comments'
  }
}

onCommentsUpdate: ({ type, comment }) => {
  // Track progress
  if (type === 'add') stats.total++;
  if (type === 'resolved') stats.resolved++;

  // Auto-assign
  if (comment.commentText.match(/\bprice|cost\b/i)) {
    assignToFinanceTeam(comment);
  }
}

modules: {
  comments: {
    useInternalExternalComments: true;
  }
}

onCommentsUpdate: ({ comment }) => {
  if (comment.isInternal) {
    syncToInternalTeam(comment);
  } else {
    syncToAllUsers(comment);
  }
};

import { debounce } from "lodash";

const saveComment = debounce(async (comment) => {
  await api.updateComment(comment.commentId, comment);
}, 1000);

onCommentsUpdate: ({ type, comment }) => {
  if (type === "update") {
    saveComment(comment);
  }
};

const MAX_COMMENTS = 500;

onCommentsUpdate: ({ type }) => {
  if (type === "add" && commentCount >= MAX_COMMENTS) {
    showWarning("Maximum comments reached");
    return false;
  }
};