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;
  }
}