@dxos/react-ui-editor 0.3.11-main.f437bee → 0.3.11-main.f4c1077

package/src/extensions/comments.ts

@@ -2,121 +2,112 @@
 // Copyright 2023 DXOS.org
 //
 
-import { type Extension, StateEffect, StateField } from '@codemirror/state';
-import {
-  hoverTooltip,
-  keymap,
-  type Command,
-  type DecorationSet,
-  type ViewUpdate,
-  Decoration,
-  EditorView,
-  MatchDecorator,
-  ViewPlugin,
-  WidgetType,
-  type Rect,
-} from '@codemirror/view';
+import { invertedEffects } from '@codemirror/commands';
+import { type Extension, Facet, StateEffect, StateField, type Text, type ChangeDesc } from '@codemirror/state';
+import { hoverTooltip, keymap, type Command, Decoration, EditorView, type Rect } from '@codemirror/view';
 import sortBy from 'lodash.sortby';
+import { useEffect } from 'react';
 
 import { debounce } from '@dxos/async';
-import { invariant } from '@dxos/invariant';
-import { log } from '@dxos/log';
 import { nonNullable } from '@dxos/util';
 
-import { type CommentRange, type EditorModel, type Range } from '../hooks';
+import { Cursor } from './cursor';
+import { type Comment, type Range } from '../hooks';
 import { getToken } from '../styles';
-import { callbackWrapper, CursorConverter } from '../util';
-
-// TODO(burdon): Handle delete, cut, copy, and paste (separately) text that includes comment range.
-// TODO(burdon): Consider breaking into separate plugin (since not standalone)? Like mermaid?
+import { callbackWrapper } from '../util';
 
 // TODO(burdon): Reconcile with theme.
 const styles = EditorView.baseTheme({
-  '& .cm-bookmark': {
-    cursor: 'pointer',
-    margin: '4px',
-    padding: '4px',
-    backgroundColor: 'yellow',
-  },
-  '& .cm-bookmark-selected': {
-    backgroundColor: 'orange',
-  },
-  '& .cm-comment': {
+  '&light .cm-comment, &light .cm-comment-current': { mixBlendMode: 'darken' },
+  '&dark .cm-comment, &dark .cm-comment-current': { mixBlendMode: 'plus-lighter' },
+  '&light .cm-comment': {
     backgroundColor: getToken('extend.colors.yellow.50'),
   },
-  '& .cm-comment-active': {
+  '&light .cm-comment-current': {
     backgroundColor: getToken('extend.colors.yellow.100'),
   },
+  '&dark .cm-comment': {
+    color: getToken('extend.colors.yellow.50'),
+    backgroundColor: getToken('extend.colors.yellow.900'),
+  },
+  '&dark .cm-comment-current': {
+    color: getToken('extend.colors.yellow.100'),
+    backgroundColor: getToken('extend.colors.yellow.950'),
+  },
 });
 
-const marks = {
-  highlight: Decoration.mark({ class: 'cm-comment' }),
-  highlightActive: Decoration.mark({ class: 'cm-comment-active' }),
+const commentMark = Decoration.mark({ class: 'cm-comment' });
+const commentCurrentMark = Decoration.mark({ class: 'cm-comment-current' });
+
+type CommentState = {
+  comment: Comment;
+  range: Range;
+  location?: Rect | null;
 };
 
-// TODO(burdon): Should this be part of state?
-type CommentSelected = {
-  active?: string;
+type SelectionState = {
+  current?: string;
   closest?: string;
 };
 
-// TODO(burdon): Rename.
-type ExtendedCommentRange = Range &
-  CommentRange & {
-    // TODO(burdon): Not part of state; just required for callback.
-    location?: Rect | null;
-  };
-
-export type CommentsState = CommentSelected & {
-  ranges: ExtendedCommentRange[];
+export type CommentsState = {
+  comments: CommentState[];
+  selection: SelectionState;
 };
 
-export const setFocus = (view: EditorView, thread: string) => {
-  const range = view.state.field(commentsStateField).ranges.find((range) => range.id === thread);
-  if (!range) {
+export const focusComment = (view: EditorView, id: string, center = true) => {
+  const comment = view.state.field(commentsState).comments.find((range) => range.comment.id === id);
+  if (!comment?.comment.cursor) {
     return;
   }
 
-  view.dispatch({
-    effects: setSelection.of({ active: thread }),
-    selection: { anchor: range.from },
-    scrollIntoView: true,
-  });
+  const range = Cursor.getRangeFromCursor(view.state, comment.comment.cursor);
+  if (range) {
+    view.dispatch({
+      selection: { anchor: range.from },
+      effects: [
+        //
+        EditorView.scrollIntoView(range.from, center ? { y: 'center' } : undefined),
+        setSelection.of({ current: id }),
+      ],
+    });
+  }
 };
 
-export const setCommentRange = StateEffect.define<{ model: EditorModel; comments: CommentRange[] }>();
+export const setComments = StateEffect.define<Comment[]>();
 
-export const setSelection = StateEffect.define<CommentSelected>();
+export const setSelection = StateEffect.define<SelectionState>();
 
 const setCommentState = StateEffect.define<CommentsState>();
 
 /**
  * State field (reducer) that tracks comment ranges.
- * The ranges are tracked as codemirror ranges (i.e., not relative YJS/Automerge positions), and
- * therefore must be updated when the document changes.
+ * The ranges are tracked as Automerge cursors from which the absolute indexed ranges can be computed.
  */
-const commentsStateField = StateField.define<CommentsState>({
-  create: () => ({ ranges: [] }),
+const commentsState = StateField.define<CommentsState>({
+  create: () => ({ comments: [], selection: {} }),
   update: (value, tr) => {
-    const cursorConverter = tr.state.facet(CursorConverter);
-
     for (const effect of tr.effects) {
       // Update selection.
       if (effect.is(setSelection)) {
-        return { ...value, ...effect.value };
+        return { ...value, selection: effect.value };
       }
 
       // Update range from store.
-      if (effect.is(setCommentRange)) {
-        const { comments } = effect.value;
-        const ranges: ExtendedCommentRange[] = comments
+      if (effect.is(setComments)) {
+        const comments: CommentState[] = effect.value
           .map((comment) => {
-            const range = getRangeFromCursor(cursorConverter, comment.cursor);
-            return range && { ...comment, ...range };
+            // Skip cut/deleted comments.
+            if (!comment.cursor) {
+              return undefined;
+            }
+
+            const range = Cursor.getRangeFromCursor(tr.state, comment.cursor);
+            return range && { comment, range };
           })
           .filter(nonNullable);
 
-        return { ...value, ranges };
+        return { ...value, comments };
       }
 
       // Update entire state.
@@ -132,64 +123,48 @@ const commentsStateField = StateField.define<CommentsState>({
 /**
  * Decorate ranges.
  */
-const highlightDecorations = EditorView.decorations.compute([commentsStateField], (state) => {
-  const { active, ranges } = state.field(commentsStateField);
-  const decorations =
-    sortBy(ranges ?? [], (range) => range.from)
-      ?.flatMap((selection) => {
-        // TODO(burdon): Invalid range (e.g., deleted).
-        if (selection.from === selection.to) {
-          return undefined;
-        }
+const commentsDecorations = EditorView.decorations.compute([commentsState], (state) => {
+  const {
+    selection: { current },
+    comments,
+  } = state.field(commentsState);
+
+  const decorations = sortBy(comments ?? [], (range) => range.range.from)
+    ?.flatMap((comment) => {
+      const range = comment.range;
+      if (!range || range.from === range.to) {
+        console.warn('Invalid range:', range);
+        return undefined;
+      }
 
-        const range = { from: selection.from, to: selection.to };
-        if (selection.id === active) {
-          return marks.highlightActive.range(range.from, range.to);
-        } else {
-          return marks.highlight.range(range.from, range.to);
-        }
-      })
-      .filter(nonNullable) ?? [];
+      if (comment.comment.id === current) {
+        return commentCurrentMark.range(range.from, range.to);
+      } else {
+        return commentMark.range(range.from, range.to);
+      }
+    })
+    .filter(nonNullable);
 
   return Decoration.set(decorations);
 });
 
-/**
- * Optional bookmark widget at the start/end of the selection.
- * May correspond to a markdown bookmark.
- */
-class BookmarkWidget extends WidgetType {
-  constructor(
-    private readonly _anchor: number,
-    private readonly _id: string,
-    private readonly _handleClick?: () => void,
-  ) {
-    super();
-    invariant(this._id);
-  }
-
-  override eq(other: BookmarkWidget) {
-    return this._anchor === other._anchor && this._id === other._id;
-  }
-
-  override toDOM() {
-    const span = document.createElement('span');
-    span.className = 'cm-bookmark';
-    span.textContent = '※';
-    if (this._handleClick) {
-      span.onclick = () => this._handleClick!();
-    }
-    return span;
-  }
-}
-
 export type CommentsOptions = {
+  /**
+   * Key shortcut to create a new thread.
+   */
   key?: string;
-  footnote?: boolean;
   /**
    * Called to create a new thread and return the thread id.
    */
-  onCreate?: (range: string) => string | undefined;
+  onCreate?: (params: { cursor: string; from: number; location?: Rect | null }) => string | undefined;
+  /**
+   * Selection cut/deleted.
+   */
+  onDelete?: (thread: string) => void;
+  /**
+   * Called when a comment is moved.
+   */
+  onUpdate?: (thread: string, cursor: string) => void;
   /**
    * Called to notify which thread is currently closest to the cursor.
    */
@@ -197,103 +172,185 @@ export type CommentsOptions = {
   /**
    * Called to render tooltip.
    */
-  onHover?: (el: Element) => void;
+  onHover?: (el: Element, shortcut: string) => void;
 };
 
-/**
- * Comment threads.
- * 1). Updates the EditorModel to store relative selections for a set of comments threads.
- *     Since the selections are relative, they do not need to be updated when the document is edited.
- * 2). Implements a StateField to track absolute selections corresponding to the comments (i.e., when the document is edited).
- * 3). Creates decoration marks to apply classes to each selection.
- * 4). Tracks the current cursor position to:
- *     a). Update the decoration to show if the cursor is within a current selection.
- *     b). Calls a handler to indicate which is the closest selection (e.g., to update the thread sidebar).
- * 5). Optionally, inserts a markdown footnote when creating a comment thread.
- * 6). Optionally, implements a hoverTooltip to show hints when creating a selection range.
- */
-export const comments = (options: CommentsOptions = {}): Extension => {
-  const handleSelect = debounce((state: CommentsState) => options.onSelect?.(state), 200);
+type TrackedComment = { id: string; from: number; to: number };
+
+const trackPastedComments = (onUpdate: NonNullable<CommentsOptions['onUpdate']>) => {
+  // Tracks indexed selections within text.
+  let tracked: { text: Text; comments: TrackedComment[] } | null = null;
+
+  // Track cut or copy (enables cut-and-paste and copy-delete-paste to restore comment selection).
+  const handleTrack = (event: Event, view: EditorView) => {
+    const comments = view.state.field(commentsState);
+    const { main } = view.state.selection;
+    const selectedRanges = comments.comments.filter(
+      ({ range }) => range.from >= main.from && range.to <= main.to && range.from < range.to,
+    );
+
+    if (!selectedRanges.length) {
+      tracked = null;
+    } else {
+      tracked = {
+        text: view.state.doc.slice(main.from, main.to),
+        comments: selectedRanges.map(({ comment, range }) => ({
+          id: comment.id,
+          from: range.from - main.from,
+          to: range.to - main.from,
+        })),
+      };
+    }
+  };
 
-  /**
-   * Create comment thread action.
-   */
-  const createCommentThread: Command = (view) => {
-    const cursorConverter = view.state.facet(CursorConverter);
+  return [
+    EditorView.domEventHandlers({
+      cut: handleTrack,
+      copy: handleTrack,
+    }),
 
-    invariant(options.onCreate);
-    const { head, from, to } = view.state.selection.main;
-    if (from === to) {
-      return false;
-    }
+    // Track deleted comments.
+    invertedEffects.of((tr) => {
+      const { comments } = tr.startState.field(commentsState);
+      const effects: StateEffect<any>[] = [];
+      tr.changes.iterChangedRanges((fromA, toA) => {
+        for (const {
+          comment: { id },
+          range: { from, to },
+        } of comments) {
+          if (from < to && from >= fromA && to <= toA) {
+            effects.push(restoreCommentEffect.of({ id, from, to }));
+          }
+        }
+      });
 
-    const relPos = getCursorFromRange(cursorConverter, { from, to });
-    if (relPos) {
-      // Create thread via callback.
-      const id = callbackWrapper(options.onCreate)(relPos);
-      if (id) {
-        // Update range.
-        view.dispatch({
-          effects: setSelection.of({ active: id }),
-          selection: { anchor: from },
-        });
+      return effects;
+    }),
+
+    // Handle paste or the undo of comment deletion.
+    EditorView.updateListener.of((update) => {
+      const restore: TrackedComment[] = [];
 
-        // Insert footnote.
-        if (options.footnote) {
-          const tag = `[^${id}]`;
-          view.dispatch({
-            changes: { from: head, insert: tag },
-            selection: { anchor: head + tag.length },
+      for (let i = 0; i < update.transactions.length; i++) {
+        const tr = update.transactions[i];
+        for (let j = 0; j < restore.length; j++) {
+          restore[j] = mapTrackedComment(restore[j], tr.changes);
+        }
+        for (const effect of tr.effects) {
+          if (effect.is(restoreCommentEffect)) {
+            restore.push(effect.value);
+          }
+        }
+      }
+
+      if (tracked) {
+        const paste = update.transactions.find((tr) => tr.isUserEvent('input.paste'));
+        if (paste) {
+          let found = -1;
+          paste.changes.iterChanges((fromA, toA, fromB, toB, text) => {
+            if (text.eq(tracked!.text)) {
+              for (let i = update.transactions.indexOf(paste!) + 1; i < update.transactions.length; i++) {
+                fromB = update.transactions[i].changes.mapPos(fromB);
+              }
+
+              found = fromB;
+            }
           });
+
+          if (found > -1) {
+            for (const moved of tracked.comments) {
+              restore.push({ id: moved.id, from: found + moved.from, to: found + moved.to });
+            }
+          }
+
+          tracked = null;
         }
+      }
 
-        return true;
+      for (const comment of restore) {
+        const { comments } = update.startState.field(commentsState);
+        const exists = comments.some((c) => c.comment.id === comment.id && c.range.from < c.range.to);
+        if (!exists) {
+          const cursor = Cursor.getCursorFromRange(update.state, comment);
+          onUpdate(comment.id, cursor);
+        }
       }
-    }
+    }),
+  ];
+};
+
+const mapTrackedComment = (comment: TrackedComment, changes: ChangeDesc) => ({
+  id: comment.id,
+  from: changes.mapPos(comment.from, 1),
+  to: changes.mapPos(comment.to, 1),
+});
+
+// These are attached to undone/redone transactions in the editor for the purpose of restoring comments
+// that were deleted by the original changes.
+const restoreCommentEffect = StateEffect.define<TrackedComment>({ map: mapTrackedComment });
 
+const optionsFacet = Facet.define<CommentsOptions, CommentsOptions>({
+  combine: (providers) => providers[0],
+});
+
+/**
+ * Create comment thread action.
+ */
+export const createComment: Command = (view) => {
+  const options = view.state.facet(optionsFacet);
+  const { from, to } = view.state.selection.main;
+  if (from === to) {
     return false;
-  };
+  }
 
-  /**
-   * Bookmark widget decoration.
-   */
-  const bookmarksViewPlugin = ViewPlugin.fromClass(
-    class BookmarkViewPlugin {
-      // Match markdown footnotes (option).
-      // https://www.markdownguide.org/extended-syntax/#footnotes
-      static bookmarkMatcher = new MatchDecorator({
-        regexp: /\[\^(\w+)\]/g,
-        decoration: (match, view, pos) => {
-          const id = match[1];
-          return Decoration.replace({
-            id,
-            widget: new BookmarkWidget(pos, id),
-          });
-        },
+  // Don't allow selection at end of document.
+  if (to === view.state.doc.length) {
+    view.dispatch({
+      changes: {
+        from: to,
+        insert: '\n',
+      },
+    });
+  }
+
+  const cursor = Cursor.getCursorFromRange(view.state, { from, to });
+  if (cursor) {
+    // Create thread via callback.
+    const id = options.onCreate?.({ cursor, from, location: view.coordsAtPos(from) });
+    if (id) {
+      // Update range.
+      view.dispatch({
+        effects: setSelection.of({ current: id }),
+        selection: { anchor: to },
       });
 
-      bookmarks: DecorationSet;
-      constructor(view: EditorView) {
-        this.bookmarks = BookmarkViewPlugin.bookmarkMatcher.createDeco(view);
-      }
+      return true;
+    }
+  }
 
-      update(update: ViewUpdate) {
-        this.bookmarks = BookmarkViewPlugin.bookmarkMatcher.updateDeco(update, this.bookmarks);
-      }
-    },
-    {
-      decorations: (instance) => instance.bookmarks,
-      provide: (plugin) =>
-        EditorView.atomicRanges.of((view) => {
-          return view.plugin(plugin)?.bookmarks || Decoration.none;
-        }),
-    },
-  );
+  return false;
+};
+
+/**
+ * Comment threads.
+ * 1). Updates the EditorModel to store relative selections for a set of comments threads.
+ *     Since the selections are relative, they do not need to be updated when the document is edited.
+ * 2). Implements a StateField to track absolute selections corresponding to the comments (i.e., when the document is edited).
+ * 3). Creates decoration marks to apply classes to each selection.
+ * 4). Tracks the current cursor position to:
+ *     a). Update the decoration to show if the cursor is within a current selection.
+ *     b). Calls a handler to indicate which is the closest selection (e.g., to update the thread sidebar).
+ * 5). Optionally, implements a hoverTooltip to show hints when creating a selection range.
+ */
+export const comments = (options: CommentsOptions = {}): Extension => {
+  const { key: shortcut = "meta-'" } = options;
+
+  const handleSelect = debounce((state: CommentsState) => options.onSelect?.(state), 200);
 
   return [
-    bookmarksViewPlugin,
-    commentsStateField,
-    highlightDecorations,
+    optionsFacet.of(options),
+    commentsState,
+    commentsDecorations,
     styles,
 
     //
@@ -302,8 +359,8 @@ export const comments = (options: CommentsOptions = {}): Extension => {
     options.onCreate
       ? keymap.of([
           {
-            key: options?.key ?? "meta-'",
-            run: callbackWrapper(createCommentThread),
+            key: shortcut,
+            run: callbackWrapper(createComment),
           },
         ])
       : [],
@@ -322,9 +379,8 @@ export const comments = (options: CommentsOptions = {}): Extension => {
                 end: selection.to,
                 above: true,
                 create: () => {
-                  // TODO(burdon): Dispatch to react callback to render (or use SSR)?
                   const el = document.createElement('div');
-                  options.onHover?.(el);
+                  options.onHover!(el, shortcut);
                   return { dom: el, offset: { x: 0, y: 8 } };
                 },
               };
@@ -332,89 +388,99 @@ export const comments = (options: CommentsOptions = {}): Extension => {
 
             return null;
           },
-          { hideOnChange: true, hoverTime: 1000 },
+          {
+            // TODO(burdon): Hide on change triggered immediately?
+            // hideOnChange: true,
+            hoverTime: 1_000,
+          },
         )
       : [],
 
     //
-    // Monitor cursor movement and text updates.
-    // TODO(burdon): Is there a better (finer grained) way to do this?
+    // Track deleted ranges and update ranges for decorations.
     //
     EditorView.updateListener.of(({ view, state, changes }) => {
-      const cursorConverter = view.state.facet(CursorConverter);
-
-      //
-      // Test if need to recompute indexed range if document changes before the end of the range.
-      //
-      {
-        let mod = false;
-        const { active, ranges } = state.field(commentsStateField);
-        changes.iterChanges((from, to, from2, to2) => {
-          ranges.forEach((range) => {
-            if (from2 === to2) {
-              const newRange = getRangeFromCursor(cursorConverter, range.cursor);
-              if (!newRange || newRange.to - newRange.from === 0) {
-                // TODO(burdon): Delete range if empty.
-                log.info('deleted comment', { thread: range.id });
-              }
+      let mod = false;
+      const { comments, ...value } = state.field(commentsState);
+      changes.iterChanges((from, to, from2, to2) => {
+        comments.forEach(({ comment, range }) => {
+          // Test if range deleted.
+          if (from2 === to2) {
+            const newRange = Cursor.getRangeFromCursor(view.state, comment.cursor!);
+            if (!newRange || newRange.to - newRange.from === 0) {
+              options.onDelete?.(comment.id);
             }
+          }
 
-            if (from <= range.to) {
-              const newRange = getRangeFromCursor(cursorConverter, range.cursor);
-              Object.assign(range, newRange);
-              mod = true;
-            }
-          });
+          // Update range.
+          if (from <= range.to) {
+            const newRange = Cursor.getRangeFromCursor(view.state, comment.cursor!);
+            Object.assign(range, newRange);
+            mod = true;
+          }
         });
+      });
 
-        if (mod) {
-          view.dispatch({ effects: setCommentState.of({ active, ranges }) });
-        }
+      if (mod) {
+        view.dispatch({ effects: setCommentState.of({ comments, ...value }) });
       }
+    }),
 
-      //
-      // Track the current selection.
-      //
-      {
-        const { head } = state.selection.main;
-
-        let min = Infinity;
-        const { active, closest, ranges } = state.field(commentsStateField);
-        const selected: CommentSelected = { active: undefined, closest: undefined };
-        ranges.forEach((comment) => {
-          const d = Math.min(Math.abs(head - comment.from), Math.abs(head - comment.to));
-          if (head >= comment.from && head <= comment.to) {
-            selected.active = comment.id;
-          }
+    //
+    // Track selection/proximity.
+    //
+    EditorView.updateListener.of(({ view, state }) => {
+      let min = Infinity;
+      const {
+        selection: { current, closest },
+        comments,
+      } = state.field(commentsState);
+
+      const { head } = state.selection.main;
+      const selection: SelectionState = {};
+      comments.forEach(({ comment, range }) => {
+        if (head >= range.from && head <= range.to) {
+          selection.current = comment.id;
+          selection.closest = undefined;
+        }
+
+        if (!selection.current) {
+          const d = Math.min(Math.abs(head - range.from), Math.abs(head - range.to));
           if (d < min) {
-            selected.closest = comment.id;
+            selection.closest = comment.id;
             min = d;
           }
-        });
-
-        if (selected.active !== active || selected.closest !== closest) {
-          view.dispatch({ effects: setSelection.of(selected) });
-
-          // Update callback.
-          handleSelect({
-            ...selected,
-            ranges: ranges.map((range) => ({ ...range, location: view.coordsAtPos(range.from) })),
-          });
         }
+      });
+
+      if (selection.current !== current || selection.closest !== closest) {
+        view.dispatch({ effects: setSelection.of(selection) });
+
+        // Update callback.
+        handleSelect({
+          selection,
+          comments: comments.map(({ comment, range }) => ({
+            comment,
+            range,
+            location: view.coordsAtPos(range.from),
+          })),
+        });
       }
     }),
-  ];
-};
 
-const getCursorFromRange = (cursorConverter: CursorConverter, range: Range) => {
-  const from = cursorConverter.toCursor(range.from);
-  const to = cursorConverter.toCursor(range.to, -1);
-  return [from, to].join(':');
+    options.onUpdate ? trackPastedComments(options.onUpdate) : [],
+  ];
 };
 
-const getRangeFromCursor = (cursorConverter: CursorConverter, cursor: string) => {
-  const parts = cursor.split(':');
-  const from = cursorConverter.fromCursor(parts[0]);
-  const to = cursorConverter.fromCursor(parts[1]);
-  return from !== undefined && to !== undefined ? { from, to } : undefined;
+/**
+ * Update comments state field.
+ */
+export const useComments = (view: EditorView | null, comments: Comment[] = []) => {
+  useEffect(() => {
+    if (view) {
+      view.dispatch({
+        effects: setComments.of(comments),
+      });
+    }
+  }, [view, comments]);
 };