test(superdoc): push coverage past 90%

Add targeted tests to close remaining gaps:
- use-comment extended — resolveComment, setIsInternal, setText, mentions
- superdoc-store extended — reset, getDocument, handlePageReady, getPageBounds,
  areDocumentsReady, setExceptionHandler, collaboration mode
- Whiteboard extended — tool/enabled propagation, opacity clamping, callbacks
- New small files: comment-schemas, DocumentUsers.vue, SuperToolbar.vue,
  use-selection, CommentsLayer/helpers formatDate

Lifts package coverage from 83.3% to 90.1%.

Author: caio-pizzol

packages/superdoc/src/components/CommentsLayer/comment-schemas.test.js

@@ -0,0 +1,23 @@
+import { describe, it, expect } from 'vitest';
+import { conversation, comment } from './comment-schemas.js';
+
+describe('comment-schemas', () => {
+  it('exposes a conversation template with null defaults', () => {
+    expect(conversation).toEqual({
+      conversationId: null,
+      documentId: null,
+      creatorEmail: null,
+      creatorName: null,
+      comments: [],
+      selection: null,
+    });
+  });
+
+  it('exposes a comment template with user/timestamp placeholders', () => {
+    expect(comment).toEqual({
+      comment: null,
+      user: { name: null, email: null },
+      timestamp: null,
+    });
+  });
+});

packages/superdoc/src/components/CommentsLayer/helpers.test.js

@@ -0,0 +1,30 @@
+import { describe, it, expect } from 'vitest';
+import { formatDate } from './helpers.js';
+
+describe('formatDate', () => {
+  it('formats a morning timestamp with AM and padded minutes', () => {
+    // 2024-01-15 09:05:00 local
+    const ts = new Date(2024, 0, 15, 9, 5).getTime();
+    expect(formatDate(ts)).toBe('9:05AM Jan 15');
+  });
+
+  it('formats an afternoon timestamp with PM', () => {
+    const ts = new Date(2024, 5, 1, 14, 30).getTime();
+    expect(formatDate(ts)).toBe('2:30PM Jun 1');
+  });
+
+  it('displays midnight as 12 AM', () => {
+    const ts = new Date(2024, 11, 31, 0, 0).getTime();
+    expect(formatDate(ts)).toBe('12:00AM Dec 31');
+  });
+
+  it('displays noon as 12 PM', () => {
+    const ts = new Date(2024, 6, 4, 12, 45).getTime();
+    expect(formatDate(ts)).toBe('12:45PM Jul 4');
+  });
+
+  it('pads single-digit minutes with a leading zero', () => {
+    const ts = new Date(2024, 2, 2, 8, 9).getTime();
+    expect(formatDate(ts)).toBe('8:09AM Mar 2');
+  });
+});

packages/superdoc/src/components/CommentsLayer/use-comment-extended.test.js

@@ -0,0 +1,219 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+vi.mock('@superdoc/core/collaboration/helpers.js', () => ({
+  syncCommentsToClients: vi.fn(),
+}));
+
+import useComment from './use-comment.js';
+import { syncCommentsToClients } from '@superdoc/core/collaboration/helpers.js';
+
+const makeSuperdoc = () => ({
+  emit: vi.fn(),
+  activeEditor: {
+    commands: {
+      resolveComment: vi.fn(),
+      setCommentInternal: vi.fn(),
+      setActiveComment: vi.fn(),
+    },
+  },
+});
+
+describe('use-comment: extended coverage', () => {
+  beforeEach(() => {
+    syncCommentsToClients.mockClear();
+  });
+
+  describe('resolveComment', () => {
+    it('sets resolved fields and emits a resolved event', () => {
+      const c = useComment({ commentId: 'c-1', fileId: 'doc-1' });
+      const superdoc = makeSuperdoc();
+      c.resolveComment({ email: 'a@b.com', name: 'Alice', superdoc });
+      expect(c.resolvedByEmail).toBe('a@b.com');
+      expect(c.resolvedByName).toBe('Alice');
+      expect(typeof c.resolvedTime).toBe('number');
+      expect(superdoc.emit).toHaveBeenCalledWith(
+        'comments-update',
+        expect.objectContaining({ type: expect.any(String) }),
+      );
+      expect(superdoc.activeEditor.commands.resolveComment).toHaveBeenCalled();
+    });
+
+    it('is a no-op when already resolved', () => {
+      const c = useComment({ commentId: 'c-1', resolvedTime: 1234 });
+      const superdoc = makeSuperdoc();
+      c.resolveComment({ email: 'a@b.com', name: 'Alice', superdoc });
+      expect(c.resolvedByEmail).toBeNull();
+      expect(superdoc.emit).not.toHaveBeenCalled();
+    });
+
+    it('emits when tracked change is present (suggestion resolve path)', () => {
+      const c = useComment({ commentId: 'c-1', trackedChange: { insert: {} } });
+      const superdoc = makeSuperdoc();
+      c.resolveComment({ email: 'a@b.com', name: 'Alice', superdoc });
+      expect(superdoc.emit).toHaveBeenCalled();
+      expect(superdoc.activeEditor.commands.resolveComment).toHaveBeenCalled();
+    });
+  });
+
+  describe('setIsInternal', () => {
+    it('updates the flag and emits', () => {
+      const c = useComment({ commentId: 'c-1', isInternal: true });
+      const superdoc = makeSuperdoc();
+      c.setIsInternal({ isInternal: false, superdoc });
+      expect(c.isInternal).toBe(false);
+      expect(superdoc.emit).toHaveBeenCalled();
+      expect(superdoc.activeEditor.commands.setCommentInternal).toHaveBeenCalledWith(
+        expect.objectContaining({ isInternal: false }),
+      );
+    });
+
+    it('short-circuits when value is unchanged', () => {
+      const c = useComment({ commentId: 'c-1', isInternal: true });
+      const superdoc = makeSuperdoc();
+      c.setIsInternal({ isInternal: true, superdoc });
+      expect(superdoc.emit).not.toHaveBeenCalled();
+    });
+
+    it('does not call editor commands when activeEditor is missing', () => {
+      const c = useComment({ commentId: 'c-1', isInternal: true });
+      const superdoc = { emit: vi.fn(), activeEditor: null };
+      c.setIsInternal({ isInternal: false, superdoc });
+      expect(superdoc.emit).toHaveBeenCalled();
+      expect(c.isInternal).toBe(false);
+    });
+  });
+
+  describe('setActive', () => {
+    it('invokes setActiveComment on the active editor', () => {
+      const c = useComment({ commentId: 'c-1' });
+      const superdoc = makeSuperdoc();
+      c.setActive(superdoc);
+      expect(superdoc.activeEditor.commands.setActiveComment).toHaveBeenCalledWith(
+        expect.objectContaining({ commentId: 'c-1' }),
+      );
+    });
+
+    it('is a no-op when no active editor', () => {
+      const c = useComment({ commentId: 'c-1' });
+      expect(() => c.setActive({ activeEditor: null })).not.toThrow();
+    });
+  });
+
+  describe('setText', () => {
+    it('updates comment text and extracts mentions', () => {
+      const c = useComment({ commentId: 'c-1' });
+      const superdoc = makeSuperdoc();
+      c.setText({
+        text:
+          'Hello <span data-type="mention" email="a@b.com" name="Alice"></span> and ' +
+          '<span data-type="mention" email="c@d.com" name="Carol"></span>',
+        superdoc,
+      });
+      expect(c.commentText).toContain('Hello');
+      expect(c.mentions).toHaveLength(2);
+      expect(c.mentions[0]).toMatchObject({ email: 'a@b.com', name: 'Alice' });
+      expect(superdoc.emit).toHaveBeenCalled();
+    });
+
+    it('deduplicates repeated mentions by email + name', () => {
+      const c = useComment({ commentId: 'c-1' });
+      const superdoc = makeSuperdoc();
+      c.setText({
+        text:
+          '<span data-type="mention" email="a@b.com" name="Alice"></span>' +
+          '<span data-type="mention" email="a@b.com" name="Alice"></span>',
+        superdoc,
+      });
+      expect(c.mentions).toHaveLength(1);
+    });
+
+    it('skips emit when suppressUpdate is true', () => {
+      const c = useComment({ commentId: 'c-1' });
+      const superdoc = makeSuperdoc();
+      c.setText({ text: 'silent update', superdoc, suppressUpdate: true });
+      expect(c.commentText).toBe('silent update');
+      expect(superdoc.emit).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('updatePosition', () => {
+    it('translates coords relative to the parent bounding rect', () => {
+      const c = useComment({
+        commentId: 'c-1',
+        selection: { documentId: 'doc-1', selectionBounds: { top: 0, left: 0 } },
+      });
+      const parent = { getBoundingClientRect: () => ({ top: 50, left: 0 }) };
+      c.updatePosition({ top: 100, left: 10, right: 20, bottom: 150 }, parent);
+      expect(c.selection.selectionBounds).toEqual({
+        top: 50,
+        left: 10,
+        right: 20,
+        bottom: 100,
+      });
+      expect(c.selection.source).toBe('super-editor');
+    });
+  });
+
+  describe('getCommentUser', () => {
+    it('returns imported author when present', () => {
+      const c = useComment({
+        commentId: 'c-1',
+        importedAuthor: { name: 'Imported One', email: 'imp@x.com' },
+      });
+      expect(c.getCommentUser()).toEqual({ name: 'Imported One', email: 'imp@x.com' });
+    });
+
+    it('uses fallback "(Imported)" when importedAuthor.name is missing', () => {
+      const c = useComment({
+        commentId: 'c-1',
+        importedAuthor: { email: 'imp@x.com' },
+      });
+      expect(c.getCommentUser()).toEqual({ name: '(Imported)', email: 'imp@x.com' });
+    });
+
+    it('returns creator info when no imported author', () => {
+      const c = useComment({
+        commentId: 'c-1',
+        creatorName: 'Alice',
+        creatorEmail: 'a@b.com',
+        creatorImage: '/a.png',
+      });
+      expect(c.getCommentUser()).toEqual({
+        name: 'Alice',
+        email: 'a@b.com',
+        image: '/a.png',
+      });
+    });
+  });
+
+  describe('getValues', () => {
+    it('maps mentions to fall back to email when name is missing', () => {
+      const c = useComment({ commentId: 'c-1' });
+      const superdoc = makeSuperdoc();
+      c.setText({
+        text: '<span data-type="mention" email="x@y.com"></span>',
+        superdoc,
+        suppressUpdate: true,
+      });
+      const v = c.getValues();
+      expect(v.mentions[0]).toEqual({ email: 'x@y.com', name: 'x@y.com' });
+    });
+
+    it('returns selection.getValues() when selection was provided', () => {
+      const c = useComment({
+        commentId: 'c-1',
+        selection: { documentId: 'doc-1', page: 2, source: 'superdoc' },
+      });
+      const v = c.getValues();
+      expect(v.selection.documentId).toBe('doc-1');
+      expect(v.selection.page).toBe(2);
+    });
+
+    it('falls back to synthetic selection when none provided', () => {
+      const c = useComment({ commentId: 'c-1', fileId: 'doc-1' });
+      const v = c.getValues();
+      expect(v.selection).toBeDefined();
+      expect(v.selection.documentId).toBe('doc-1');
+    });
+  });
+});

packages/superdoc/src/components/SuperToolbar/SuperToolbar.test.js

@@ -0,0 +1,49 @@
+import { describe, it, expect, vi } from 'vitest';
+import { mount } from '@vue/test-utils';
+import { defineComponent, h } from 'vue';
+
+vi.mock('@superdoc/super-editor', () => ({
+  Toolbar: defineComponent({
+    name: 'ToolbarStub',
+    emits: ['command'],
+    setup(_, { emit, expose }) {
+      expose({ triggerCommand: (payload) => emit('command', payload) });
+      return () => h('div', { class: 'toolbar-stub' });
+    },
+  }),
+}));
+
+import SuperToolbar from './SuperToolbar.vue';
+
+describe('SuperToolbar.vue', () => {
+  const onToolbarCommand = vi.fn();
+
+  const mountToolbar = () => {
+    return mount(SuperToolbar, {
+      global: {
+        config: {
+          globalProperties: {
+            $superdoc: { onToolbarCommand },
+          },
+        },
+      },
+    });
+  };
+
+  it('renders the inner Toolbar', () => {
+    const wrapper = mountToolbar();
+    expect(wrapper.find('.toolbar-stub').exists()).toBe(true);
+  });
+
+  it('forwards toolbar commands to $superdoc.onToolbarCommand', async () => {
+    const wrapper = mountToolbar();
+    const inner = wrapper.findComponent({ name: 'ToolbarStub' });
+    await inner.vm.$emit('command', { item: 'bold', argument: true });
+    expect(onToolbarCommand).toHaveBeenCalledWith({ item: 'bold', argument: true });
+  });
+
+  it('exposes innerToolbar via defineExpose', () => {
+    const wrapper = mountToolbar();
+    expect(wrapper.vm.innerToolbar).toBeDefined();
+  });
+});

packages/superdoc/src/components/general/DocumentUsers.test.js

@@ -0,0 +1,49 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { mount } from '@vue/test-utils';
+import { ref } from 'vue';
+
+vi.mock('@stores/superdoc-store', () => ({
+  useSuperdocStore: () => ({
+    documentUsers: ref([
+      { name: 'Alice', email: 'a@x.com' },
+      { name: 'Bob', email: 'b@x.com' },
+      { name: 'Carol', email: 'c@x.com' },
+    ]),
+  }),
+}));
+
+vi.mock('pinia', async (orig) => {
+  const actual = await orig();
+  return {
+    ...actual,
+    storeToRefs: (store) => store,
+  };
+});
+
+import DocumentUsers from './DocumentUsers.vue';
+
+describe('DocumentUsers.vue', () => {
+  it('renders all users when no filter is provided', () => {
+    const wrapper = mount(DocumentUsers);
+    const rows = wrapper.findAll('.user-row');
+    expect(rows).toHaveLength(3);
+    expect(rows[0].text()).toBe('Alice');
+  });
+
+  it('filters users by case-insensitive prefix match', () => {
+    const wrapper = mount(DocumentUsers, { props: { filter: 'b' } });
+    const rows = wrapper.findAll('.user-row');
+    expect(rows).toHaveLength(1);
+    expect(rows[0].text()).toBe('Bob');
+  });
+
+  it('matches filter case-insensitively', () => {
+    const wrapper = mount(DocumentUsers, { props: { filter: 'A' } });
+    expect(wrapper.findAll('.user-row')).toHaveLength(1);
+  });
+
+  it('renders no rows when filter has no matches', () => {
+    const wrapper = mount(DocumentUsers, { props: { filter: 'zzz' } });
+    expect(wrapper.findAll('.user-row')).toHaveLength(0);
+  });
+});