+231

src/lib/comment-threads.ts

reviewed

··· 1 1 + /** 2 2 + * Threaded Comments — comment thread management for documents. 3 3 + * 4 4 + * Pure logic module: thread creation, replies, resolution, sorting. 5 5 + * DOM rendering handled by the editor UI layer. 6 6 + */ 7 7 + 8 8 + export interface CommentEntry { 9 9 + id: string; 10 10 + author: string; 11 11 + text: string; 12 12 + createdAt: number; 13 13 + editedAt?: number; 14 14 + } 15 15 + 16 16 + export interface CommentThread { 17 17 + id: string; 18 18 + /** The inline mark/annotation ID in the document */ 19 19 + anchorId: string; 20 20 + /** Initial comment that started the thread */ 21 21 + root: CommentEntry; 22 22 + /** Reply chain */ 23 23 + replies: CommentEntry[]; 24 24 + /** Whether the thread has been resolved */ 25 25 + resolved: boolean; 26 26 + resolvedBy?: string; 27 27 + resolvedAt?: number; 28 28 + } 29 29 + 30 30 + export type ThreadSortOrder = 'newest' | 'oldest' | 'unresolved'; 31 31 + 32 32 + let _idCounter = 0; 33 33 + 34 34 + /** 35 35 + * Generate a unique ID for comments and threads. 36 36 + */ 37 37 + export function generateCommentId(): string { 38 38 + return `cmt-${Date.now()}-${++_idCounter}`; 39 39 + } 40 40 + 41 41 + /** 42 42 + * Reset ID counter (for testing). 43 43 + */ 44 44 + export function resetCommentIdCounter(): void { 45 45 + _idCounter = 0; 46 46 + } 47 47 + 48 48 + /** 49 49 + * Create a new comment thread anchored to a document selection. 50 50 + */ 51 51 + export function createThread( 52 52 + anchorId: string, 53 53 + author: string, 54 54 + text: string, 55 55 + now = Date.now(), 56 56 + ): CommentThread { 57 57 + const threadId = generateCommentId(); 58 58 + return { 59 59 + id: threadId, 60 60 + anchorId, 61 61 + root: { 62 62 + id: generateCommentId(), 63 63 + author, 64 64 + text, 65 65 + createdAt: now, 66 66 + }, 67 67 + replies: [], 68 68 + resolved: false, 69 69 + }; 70 70 + } 71 71 + 72 72 + /** 73 73 + * Add a reply to an existing thread. 74 74 + */ 75 75 + export function addReply( 76 76 + thread: CommentThread, 77 77 + author: string, 78 78 + text: string, 79 79 + now = Date.now(), 80 80 + ): CommentThread { 81 81 + const reply: CommentEntry = { 82 82 + id: generateCommentId(), 83 83 + author, 84 84 + text, 85 85 + createdAt: now, 86 86 + }; 87 87 + return { 88 88 + ...thread, 89 89 + replies: [...thread.replies, reply], 90 90 + }; 91 91 + } 92 92 + 93 93 + /** 94 94 + * Edit a comment (root or reply) within a thread. 95 95 + * Returns the updated thread, or the original if comment not found. 96 96 + */ 97 97 + export function editComment( 98 98 + thread: CommentThread, 99 99 + commentId: string, 100 100 + newText: string, 101 101 + now = Date.now(), 102 102 + ): CommentThread { 103 103 + if (thread.root.id === commentId) { 104 104 + return { 105 105 + ...thread, 106 106 + root: { ...thread.root, text: newText, editedAt: now }, 107 107 + }; 108 108 + } 109 109 + 110 110 + const replyIdx = thread.replies.findIndex(r => r.id === commentId); 111 111 + if (replyIdx === -1) return thread; 112 112 + 113 113 + const replies = [...thread.replies]; 114 114 + replies[replyIdx] = { ...replies[replyIdx], text: newText, editedAt: now }; 115 115 + return { ...thread, replies }; 116 116 + } 117 117 + 118 118 + /** 119 119 + * Delete a reply from a thread. Cannot delete the root comment. 120 120 + */ 121 121 + export function deleteReply( 122 122 + thread: CommentThread, 123 123 + replyId: string, 124 124 + ): CommentThread { 125 125 + return { 126 126 + ...thread, 127 127 + replies: thread.replies.filter(r => r.id !== replyId), 128 128 + }; 129 129 + } 130 130 + 131 131 + /** 132 132 + * Resolve a comment thread. 133 133 + */ 134 134 + export function resolveThread( 135 135 + thread: CommentThread, 136 136 + resolvedBy: string, 137 137 + now = Date.now(), 138 138 + ): CommentThread { 139 139 + return { 140 140 + ...thread, 141 141 + resolved: true, 142 142 + resolvedBy, 143 143 + resolvedAt: now, 144 144 + }; 145 145 + } 146 146 + 147 147 + /** 148 148 + * Reopen a resolved thread. 149 149 + */ 150 150 + export function reopenThread(thread: CommentThread): CommentThread { 151 151 + return { 152 152 + ...thread, 153 153 + resolved: false, 154 154 + resolvedBy: undefined, 155 155 + resolvedAt: undefined, 156 156 + }; 157 157 + } 158 158 + 159 159 + /** 160 160 + * Sort threads by the specified order. 161 161 + */ 162 162 + export function sortThreads( 163 163 + threads: CommentThread[], 164 164 + order: ThreadSortOrder, 165 165 + ): CommentThread[] { 166 166 + const sorted = [...threads]; 167 167 + 168 168 + switch (order) { 169 169 + case 'newest': 170 170 + sorted.sort((a, b) => b.root.createdAt - a.root.createdAt); 171 171 + break; 172 172 + case 'oldest': 173 173 + sorted.sort((a, b) => a.root.createdAt - b.root.createdAt); 174 174 + break; 175 175 + case 'unresolved': 176 176 + sorted.sort((a, b) => { 177 177 + // Unresolved first, then by newest 178 178 + if (a.resolved !== b.resolved) return a.resolved ? 1 : -1; 179 179 + return b.root.createdAt - a.root.createdAt; 180 180 + }); 181 181 + break; 182 182 + } 183 183 + 184 184 + return sorted; 185 185 + } 186 186 + 187 187 + /** 188 188 + * Get the total comment count in a thread (root + replies). 189 189 + */ 190 190 + export function threadCommentCount(thread: CommentThread): number { 191 191 + return 1 + thread.replies.length; 192 192 + } 193 193 + 194 194 + /** 195 195 + * Get the most recent activity timestamp in a thread. 196 196 + */ 197 197 + export function threadLastActivity(thread: CommentThread): number { 198 198 + if (thread.replies.length === 0) return thread.root.createdAt; 199 199 + return thread.replies[thread.replies.length - 1].createdAt; 200 200 + } 201 201 + 202 202 + /** 203 203 + * Filter threads by author. 204 204 + */ 205 205 + export function filterByAuthor( 206 206 + threads: CommentThread[], 207 207 + author: string, 208 208 + ): CommentThread[] { 209 209 + const lower = author.toLowerCase(); 210 210 + return threads.filter(t => 211 211 + t.root.author.toLowerCase() === lower || 212 212 + t.replies.some(r => r.author.toLowerCase() === lower), 213 213 + ); 214 214 + } 215 215 + 216 216 + /** 217 217 + * Count unresolved threads. 218 218 + */ 219 219 + export function unresolvedCount(threads: CommentThread[]): number { 220 220 + return threads.filter(t => !t.resolved).length; 221 221 + } 222 222 + 223 223 + /** 224 224 + * Find a thread by its anchor ID. 225 225 + */ 226 226 + export function findThreadByAnchor( 227 227 + threads: CommentThread[], 228 228 + anchorId: string, 229 229 + ): CommentThread | null { 230 230 + return threads.find(t => t.anchorId === anchorId) || null; 231 231 + }

+219

tests/comment-threads.test.ts

reviewed

··· 1 1 + import { describe, it, expect, beforeEach } from 'vitest'; 2 2 + import { 3 3 + createThread, 4 4 + addReply, 5 5 + editComment, 6 6 + deleteReply, 7 7 + resolveThread, 8 8 + reopenThread, 9 9 + sortThreads, 10 10 + threadCommentCount, 11 11 + threadLastActivity, 12 12 + filterByAuthor, 13 13 + unresolvedCount, 14 14 + findThreadByAnchor, 15 15 + resetCommentIdCounter, 16 16 + type CommentThread, 17 17 + } from '../src/lib/comment-threads.js'; 18 18 + 19 19 + describe('Comment Threads', () => { 20 20 + beforeEach(() => { 21 21 + resetCommentIdCounter(); 22 22 + }); 23 23 + 24 24 + describe('createThread', () => { 25 25 + it('creates a thread with root comment', () => { 26 26 + const thread = createThread('anchor-1', 'Alice', 'Great point!', 1000); 27 27 + expect(thread.anchorId).toBe('anchor-1'); 28 28 + expect(thread.root.author).toBe('Alice'); 29 29 + expect(thread.root.text).toBe('Great point!'); 30 30 + expect(thread.root.createdAt).toBe(1000); 31 31 + expect(thread.replies).toEqual([]); 32 32 + expect(thread.resolved).toBe(false); 33 33 + }); 34 34 + 35 35 + it('generates unique IDs', () => { 36 36 + const t1 = createThread('a1', 'Alice', 'First', 1000); 37 37 + const t2 = createThread('a2', 'Bob', 'Second', 2000); 38 38 + expect(t1.id).not.toBe(t2.id); 39 39 + expect(t1.root.id).not.toBe(t2.root.id); 40 40 + }); 41 41 + }); 42 42 + 43 43 + describe('addReply', () => { 44 44 + it('adds a reply to a thread', () => { 45 45 + const thread = createThread('a1', 'Alice', 'Question?', 1000); 46 46 + const updated = addReply(thread, 'Bob', 'Answer!', 2000); 47 47 + expect(updated.replies).toHaveLength(1); 48 48 + expect(updated.replies[0].author).toBe('Bob'); 49 49 + expect(updated.replies[0].text).toBe('Answer!'); 50 50 + }); 51 51 + 52 52 + it('preserves existing replies', () => { 53 53 + let thread = createThread('a1', 'Alice', 'Start', 1000); 54 54 + thread = addReply(thread, 'Bob', 'Reply 1', 2000); 55 55 + thread = addReply(thread, 'Carol', 'Reply 2', 3000); 56 56 + expect(thread.replies).toHaveLength(2); 57 57 + expect(thread.replies[0].author).toBe('Bob'); 58 58 + expect(thread.replies[1].author).toBe('Carol'); 59 59 + }); 60 60 + }); 61 61 + 62 62 + describe('editComment', () => { 63 63 + it('edits root comment', () => { 64 64 + const thread = createThread('a1', 'Alice', 'Original', 1000); 65 65 + const updated = editComment(thread, thread.root.id, 'Edited', 2000); 66 66 + expect(updated.root.text).toBe('Edited'); 67 67 + expect(updated.root.editedAt).toBe(2000); 68 68 + }); 69 69 + 70 70 + it('edits a reply', () => { 71 71 + let thread = createThread('a1', 'Alice', 'Root', 1000); 72 72 + thread = addReply(thread, 'Bob', 'Original reply', 2000); 73 73 + const replyId = thread.replies[0].id; 74 74 + const updated = editComment(thread, replyId, 'Fixed reply', 3000); 75 75 + expect(updated.replies[0].text).toBe('Fixed reply'); 76 76 + expect(updated.replies[0].editedAt).toBe(3000); 77 77 + }); 78 78 + 79 79 + it('returns unchanged thread for unknown comment id', () => { 80 80 + const thread = createThread('a1', 'Alice', 'Text', 1000); 81 81 + const updated = editComment(thread, 'nonexistent', 'New', 2000); 82 82 + expect(updated).toEqual(thread); 83 83 + }); 84 84 + }); 85 85 + 86 86 + describe('deleteReply', () => { 87 87 + it('removes a reply', () => { 88 88 + let thread = createThread('a1', 'Alice', 'Root', 1000); 89 89 + thread = addReply(thread, 'Bob', 'To delete', 2000); 90 90 + thread = addReply(thread, 'Carol', 'To keep', 3000); 91 91 + const replyId = thread.replies[0].id; 92 92 + const updated = deleteReply(thread, replyId); 93 93 + expect(updated.replies).toHaveLength(1); 94 94 + expect(updated.replies[0].author).toBe('Carol'); 95 95 + }); 96 96 + 97 97 + it('ignores unknown reply id', () => { 98 98 + const thread = createThread('a1', 'Alice', 'Root', 1000); 99 99 + const updated = deleteReply(thread, 'nonexistent'); 100 100 + expect(updated.replies).toEqual([]); 101 101 + }); 102 102 + }); 103 103 + 104 104 + describe('resolveThread / reopenThread', () => { 105 105 + it('resolves a thread', () => { 106 106 + const thread = createThread('a1', 'Alice', 'Issue', 1000); 107 107 + const resolved = resolveThread(thread, 'Bob', 5000); 108 108 + expect(resolved.resolved).toBe(true); 109 109 + expect(resolved.resolvedBy).toBe('Bob'); 110 110 + expect(resolved.resolvedAt).toBe(5000); 111 111 + }); 112 112 + 113 113 + it('reopens a resolved thread', () => { 114 114 + const thread = createThread('a1', 'Alice', 'Issue', 1000); 115 115 + const resolved = resolveThread(thread, 'Bob', 5000); 116 116 + const reopened = reopenThread(resolved); 117 117 + expect(reopened.resolved).toBe(false); 118 118 + expect(reopened.resolvedBy).toBeUndefined(); 119 119 + expect(reopened.resolvedAt).toBeUndefined(); 120 120 + }); 121 121 + }); 122 122 + 123 123 + describe('sortThreads', () => { 124 124 + const threads: CommentThread[] = [ 125 125 + createThread('a1', 'Alice', 'Old', 1000), 126 126 + createThread('a2', 'Bob', 'New', 3000), 127 127 + createThread('a3', 'Carol', 'Mid', 2000), 128 128 + ]; 129 129 + 130 130 + it('sorts newest first', () => { 131 131 + const sorted = sortThreads(threads, 'newest'); 132 132 + expect(sorted[0].root.createdAt).toBe(3000); 133 133 + expect(sorted[2].root.createdAt).toBe(1000); 134 134 + }); 135 135 + 136 136 + it('sorts oldest first', () => { 137 137 + const sorted = sortThreads(threads, 'oldest'); 138 138 + expect(sorted[0].root.createdAt).toBe(1000); 139 139 + expect(sorted[2].root.createdAt).toBe(3000); 140 140 + }); 141 141 + 142 142 + it('sorts unresolved first', () => { 143 143 + const withResolved = [ 144 144 + ...threads, 145 145 + resolveThread(createThread('a4', 'Dave', 'Resolved', 4000), 'Eve', 5000), 146 146 + ]; 147 147 + const sorted = sortThreads(withResolved, 'unresolved'); 148 148 + expect(sorted[0].resolved).toBe(false); 149 149 + expect(sorted[sorted.length - 1].resolved).toBe(true); 150 150 + }); 151 151 + }); 152 152 + 153 153 + describe('threadCommentCount', () => { 154 154 + it('counts root + replies', () => { 155 155 + let thread = createThread('a1', 'Alice', 'Root', 1000); 156 156 + expect(threadCommentCount(thread)).toBe(1); 157 157 + thread = addReply(thread, 'Bob', 'Reply', 2000); 158 158 + expect(threadCommentCount(thread)).toBe(2); 159 159 + }); 160 160 + }); 161 161 + 162 162 + describe('threadLastActivity', () => { 163 163 + it('returns root time when no replies', () => { 164 164 + const thread = createThread('a1', 'Alice', 'Root', 1000); 165 165 + expect(threadLastActivity(thread)).toBe(1000); 166 166 + }); 167 167 + 168 168 + it('returns last reply time', () => { 169 169 + let thread = createThread('a1', 'Alice', 'Root', 1000); 170 170 + thread = addReply(thread, 'Bob', 'Reply', 5000); 171 171 + expect(threadLastActivity(thread)).toBe(5000); 172 172 + }); 173 173 + }); 174 174 + 175 175 + describe('filterByAuthor', () => { 176 176 + it('finds threads where author participated', () => { 177 177 + const t1 = createThread('a1', 'Alice', 'Thread 1', 1000); 178 178 + const t2 = addReply( 179 179 + createThread('a2', 'Bob', 'Thread 2', 2000), 180 180 + 'Alice', 'Reply', 3000, 181 181 + ); 182 182 + const t3 = createThread('a3', 'Carol', 'Thread 3', 4000); 183 183 + const filtered = filterByAuthor([t1, t2, t3], 'Alice'); 184 184 + expect(filtered).toHaveLength(2); 185 185 + }); 186 186 + 187 187 + it('is case-insensitive', () => { 188 188 + const thread = createThread('a1', 'Alice', 'Thread', 1000); 189 189 + expect(filterByAuthor([thread], 'alice')).toHaveLength(1); 190 190 + }); 191 191 + }); 192 192 + 193 193 + describe('unresolvedCount', () => { 194 194 + it('counts unresolved threads', () => { 195 195 + const threads = [ 196 196 + createThread('a1', 'Alice', 'Open', 1000), 197 197 + resolveThread(createThread('a2', 'Bob', 'Closed', 2000), 'Eve', 3000), 198 198 + createThread('a3', 'Carol', 'Open', 4000), 199 199 + ]; 200 200 + expect(unresolvedCount(threads)).toBe(2); 201 201 + }); 202 202 + }); 203 203 + 204 204 + describe('findThreadByAnchor', () => { 205 205 + it('finds thread by anchor ID', () => { 206 206 + const threads = [ 207 207 + createThread('anchor-1', 'Alice', 'A', 1000), 208 208 + createThread('anchor-2', 'Bob', 'B', 2000), 209 209 + ]; 210 210 + const found = findThreadByAnchor(threads, 'anchor-2'); 211 211 + expect(found).not.toBeNull(); 212 212 + expect(found!.root.author).toBe('Bob'); 213 213 + }); 214 214 + 215 215 + it('returns null for unknown anchor', () => { 216 216 + expect(findThreadByAnchor([], 'unknown')).toBeNull(); 217 217 + }); 218 218 + }); 219 219 + });