@dxos/react-ui-editor 0.3.11-main.8be6c8a → 0.3.11-main.8feb6a5

package/src/extensions/comments.ts

@@ -2,20 +2,8 @@
 // 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 { type Extension, StateEffect, StateField, type Text } from '@codemirror/state';
+import { hoverTooltip, keymap, type Command, Decoration, EditorView, type Rect } from '@codemirror/view';
 import sortBy from 'lodash.sortby';
 
 import { debounce } from '@dxos/async';
@@ -23,24 +11,16 @@ import { invariant } from '@dxos/invariant';
 import { log } from '@dxos/log';
 import { nonNullable } from '@dxos/util';
 
+import { Cursor } from './cursor';
 import { type CommentRange, type EditorModel, type Range } from '../hooks';
 import { getToken } from '../styles';
-import { callbackWrapper, CursorConverter } from '../util';
+import { callbackWrapper } 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?
 
 // 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': {
     backgroundColor: getToken('extend.colors.yellow.50'),
   },
@@ -98,7 +78,7 @@ const setCommentState = StateEffect.define<CommentsState>();
 const commentsStateField = StateField.define<CommentsState>({
   create: () => ({ ranges: [] }),
   update: (value, tr) => {
-    const cursorConverter = tr.state.facet(CursorConverter);
+    const cursorConverter = tr.state.facet(Cursor.converter);
 
     for (const effect of tr.effects) {
       // Update selection.
@@ -111,7 +91,7 @@ const commentsStateField = StateField.define<CommentsState>({
         const { comments } = effect.value;
         const ranges: ExtendedCommentRange[] = comments
           .map((comment) => {
-            const range = getRangeFromCursor(cursorConverter, comment.cursor);
+            const range = Cursor.getRangeFromCursor(cursorConverter, comment.cursor);
             return range && { ...comment, ...range };
           })
           .filter(nonNullable);
@@ -154,42 +134,17 @@ const highlightDecorations = EditorView.decorations.compute([commentsStateField]
   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?: string;
   footnote?: boolean;
   /**
    * Called to create a new thread and return the thread id.
    */
-  onCreate?: (range: string) => string | undefined;
+  onCreate?: (cursor: string, location?: Rect | null) => string | undefined;
+  /**
+   * Called when a comment is moved.
+   */
+  onMove?: (threadID: string, cursor: string) => void;
   /**
    * Called to notify which thread is currently closest to the cursor.
    */
@@ -197,7 +152,66 @@ export type CommentsOptions = {
   /**
    * Called to render tooltip.
    */
-  onHover?: (el: Element) => void;
+  onHover?: (el: Element, shortcut: string) => void;
+};
+
+const trackPastedComments = (onMove: (threadID: string, cursor: string) => void) => {
+  let tracked: { text: Text; comments: { from: number; to: number; id: string }[] } | null = null;
+
+  const registerCopy = (event: Event, view: EditorView) => {
+    const comments = view.state.field(commentsStateField);
+    const { main } = view.state.selection;
+    const inSel = comments.ranges.filter(
+      (range) => range.from >= main.from && range.to <= main.to && range.from < range.to,
+    );
+    if (!inSel.length) {
+      tracked = null;
+    } else {
+      tracked = {
+        text: view.state.doc.slice(main.from, main.to),
+        comments: inSel.map((range) => ({ from: range.from - main.from, to: range.to - main.from, id: range.id })),
+      };
+    }
+  };
+
+  return [
+    EditorView.domEventHandlers({
+      cut: registerCopy,
+      copy: registerCopy,
+    }),
+
+    EditorView.updateListener.of((update) => {
+      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) {
+            const active = update.view.state.field(commentsStateField).ranges;
+            for (const moved of tracked.comments) {
+              if (active.some((range) => range.id === moved.id && range.from === range.to)) {
+                onMove(
+                  moved.id,
+                  Cursor.getCursorFromRange(update.view.state.facet(Cursor.converter), {
+                    from: found + moved.from,
+                    to: found + moved.to,
+                  }),
+                );
+              }
+            }
+          }
+          tracked = null;
+        }
+      }
+    }),
+  ];
 };
 
 /**
@@ -213,13 +227,15 @@ export type CommentsOptions = {
  * 6). 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);
 
   /**
    * Create comment thread action.
    */
   const createCommentThread: Command = (view) => {
-    const cursorConverter = view.state.facet(CursorConverter);
+    const cursorConverter = view.state.facet(Cursor.converter);
 
     invariant(options.onCreate);
     const { head, from, to } = view.state.selection.main;
@@ -227,10 +243,10 @@ export const comments = (options: CommentsOptions = {}): Extension => {
       return false;
     }
 
-    const relPos = getCursorFromRange(cursorConverter, { from, to });
-    if (relPos) {
+    const cursor = Cursor.getCursorFromRange(cursorConverter, { from, to });
+    if (cursor) {
       // Create thread via callback.
-      const id = callbackWrapper(options.onCreate)(relPos);
+      const id = callbackWrapper(options.onCreate)(cursor, view.coordsAtPos(from));
       if (id) {
         // Update range.
         view.dispatch({
@@ -254,44 +270,7 @@ export const comments = (options: CommentsOptions = {}): Extension => {
     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),
-          });
-        },
-      });
-
-      bookmarks: DecorationSet;
-      constructor(view: EditorView) {
-        this.bookmarks = BookmarkViewPlugin.bookmarkMatcher.createDeco(view);
-      }
-
-      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 [
-    bookmarksViewPlugin,
     commentsStateField,
     highlightDecorations,
     styles,
@@ -302,7 +281,7 @@ export const comments = (options: CommentsOptions = {}): Extension => {
     options.onCreate
       ? keymap.of([
           {
-            key: options?.key ?? "meta-'",
+            key: shortcut,
             run: callbackWrapper(createCommentThread),
           },
         ])
@@ -324,7 +303,7 @@ export const comments = (options: CommentsOptions = {}): Extension => {
                 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 } };
                 },
               };
@@ -341,7 +320,7 @@ export const comments = (options: CommentsOptions = {}): Extension => {
     // TODO(burdon): Is there a better (finer grained) way to do this?
     //
     EditorView.updateListener.of(({ view, state, changes }) => {
-      const cursorConverter = view.state.facet(CursorConverter);
+      const cursorConverter = view.state.facet(Cursor.converter);
 
       //
       // Test if need to recompute indexed range if document changes before the end of the range.
@@ -352,7 +331,7 @@ export const comments = (options: CommentsOptions = {}): Extension => {
         changes.iterChanges((from, to, from2, to2) => {
           ranges.forEach((range) => {
             if (from2 === to2) {
-              const newRange = getRangeFromCursor(cursorConverter, range.cursor);
+              const newRange = Cursor.getRangeFromCursor(cursorConverter, range.cursor);
               if (!newRange || newRange.to - newRange.from === 0) {
                 // TODO(burdon): Delete range if empty.
                 log.info('deleted comment', { thread: range.id });
@@ -360,7 +339,7 @@ export const comments = (options: CommentsOptions = {}): Extension => {
             }
 
             if (from <= range.to) {
-              const newRange = getRangeFromCursor(cursorConverter, range.cursor);
+              const newRange = Cursor.getRangeFromCursor(cursorConverter, range.cursor);
               Object.assign(range, newRange);
               mod = true;
             }
@@ -392,6 +371,8 @@ export const comments = (options: CommentsOptions = {}): Extension => {
           }
         });
 
+        // TODO(burdon): Fire debounced callback if range selected (to show hint).
+
         if (selected.active !== active || selected.closest !== closest) {
           view.dispatch({ effects: setSelection.of(selected) });
 
@@ -403,18 +384,7 @@ export const comments = (options: CommentsOptions = {}): Extension => {
         }
       }
     }),
-  ];
-};
 
-const getCursorFromRange = (cursorConverter: CursorConverter, range: Range) => {
-  const from = cursorConverter.toCursor(range.from);
-  const to = cursorConverter.toCursor(range.to, -1);
-  return [from, to].join(':');
-};
-
-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;
+    options.onMove ? trackPastedComments(options.onMove) : [],
+  ];
 };

package/src/extensions/cursor.ts

@@ -0,0 +1,46 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { Facet } from '@codemirror/state';
+
+import type { Range } from '../hooks';
+
+/**
+ * Converts indexes into the text document into stable peer-independent cursors.
+ *
+ * See:
+ *  - https://automerge.org/automerge/api-docs/js/functions/next.getCursor.html
+ *  - https://github.com/yjs/yjs?tab=readme-ov-file#relative-positions
+ *
+ * @param {assoc} number Negative values will associate the cursor with the previous character
+ *                       while positive - with the next one.
+ */
+export interface CursorConverter {
+  toCursor(position: number, assoc?: -1 | 1 | undefined): string;
+  fromCursor(cursor: string): number;
+}
+
+const defaultCursorConverter: CursorConverter = {
+  toCursor: (position) => position.toString(),
+  fromCursor: (cursor) => parseInt(cursor),
+};
+
+export class Cursor {
+  static readonly converter = Facet.define<CursorConverter, CursorConverter>({
+    combine: (providers) => providers[0] ?? defaultCursorConverter,
+  });
+
+  static readonly getCursorFromRange = (cursorConverter: CursorConverter, range: Range) => {
+    const from = cursorConverter.toCursor(range.from);
+    const to = cursorConverter.toCursor(range.to, -1);
+    return [from, to].join(':');
+  };
+
+  static readonly 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;
+  };
+}

package/src/extensions/hr.ts

@@ -28,11 +28,11 @@ class HorizontalRuleWidget extends WidgetType {
     super();
   }
 
-  override eq(other: WidgetType) {
+  override eq(other: this) {
     return this._pos === (other as any as HorizontalRuleWidget)._pos;
   }
 
-  toDOM(view: EditorView) {
+  override toDOM(view: EditorView) {
     // TODO(burdon): Create <hr> element? Does this clash with markdown parser?
     const el = document.createElement('div');
     el.className = 'cm-hr';

package/src/extensions/image.ts

@@ -72,11 +72,11 @@ class ImageWidget extends WidgetType {
     super();
   }
 
-  override eq(other: WidgetType) {
+  override eq(other: this) {
     return this._url === (other as any as ImageWidget)._url;
   }
 
-  toDOM(view: EditorView) {
+  override toDOM(view: EditorView) {
     const img = document.createElement('img');
     img.setAttribute('src', this._url);
     img.setAttribute('class', 'cm-image');

package/src/extensions/index.ts

@@ -9,6 +9,7 @@ export * from './basic';
 export * from './blast';
 export * from './code';
 export * from './comments';
+export * from './cursor';
 export * from './hr';
 export * from './image';
 export * from './link';

package/src/extensions/link.ts

@@ -93,11 +93,11 @@ class LinkButton extends WidgetType {
     super();
   }
 
-  override eq(other: LinkButton) {
+  override eq(other: this) {
     return this._url === other._url;
   }
 
-  toDOM(view: EditorView) {
+  override toDOM(view: EditorView) {
     const el = document.createElement('span');
     this._onAttach!(el, this._url);
     return el;
@@ -109,11 +109,11 @@ class LinkText extends WidgetType {
     super();
   }
 
-  override eq(other: LinkText) {
+  override eq(other: this) {
     return this._url === other._url;
   }
 
-  toDOM(view: EditorView) {
+  override toDOM(view: EditorView) {
     const link = document.createElement('a');
     link.setAttribute('class', 'cm-link');
     link.textContent = this._text;

package/src/extensions/markdown/highlight.ts

@@ -31,7 +31,6 @@ export const markdownTags = {
   CodeText: Tag.define(),
   EmphasisMark: Tag.define(),
   HeaderMark: Tag.define(),
-  // HorizontalRule: Tag.define(),
   InlineCode: Tag.define(),
   LinkLabel: Tag.define(),
   LinkReference: Tag.define(),
@@ -177,13 +176,6 @@ export const markdownHighlightStyle = (readonly?: boolean) => {
         class: blockquote,
       },
 
-      // TODO(burdon): Replace with extension.
-      // {
-      //   tag: [markdownTags.HorizontalRule],
-      //   class: mx(horizontalRule, readonly && '-indent-[100rem]'),
-      // },
-
-      // TODO(burdon): Only if being edited.
       {
         tag: [markdownTags.TableCell],
         class: 'font-mono',

package/src/extensions/table.ts

@@ -97,14 +97,14 @@ class TableWidget extends WidgetType {
     super();
   }
 
-  override eq(other: TableWidget) {
+  override eq(other: this) {
     return (
       this._table.header?.join() === other._table.header?.join() &&
       this._table.rows?.join() === other._table.rows?.join()
     );
   }
 
-  toDOM(view: EditorView) {
+  override toDOM(view: EditorView) {
     const table = document.createElement('table');
 
     {

package/src/extensions/tasklist.ts

@@ -2,57 +2,39 @@
 // Copyright 2023 DXOS.org
 //
 
-import {
-  EditorView,
-  Decoration,
-  WidgetType,
-  MatchDecorator,
-  ViewPlugin,
-  type DecorationSet,
-  type ViewUpdate,
-} from '@codemirror/view';
-
-// TODO(burdon): Reconcile with theme.
-const styles = EditorView.baseTheme({
-  '& .cm-task-item': {
-    paddingLeft: '4px',
-    paddingRight: '8px',
-  },
-});
+import { syntaxTree } from '@codemirror/language';
+import { RangeSetBuilder } from '@codemirror/state';
+import { EditorView, Decoration, WidgetType, ViewPlugin, type DecorationSet, type ViewUpdate } from '@codemirror/view';
 
 class CheckboxWidget extends WidgetType {
-  constructor(
-    private _checked: boolean,
-    private readonly _indent: number,
-    private readonly _onCheck?: (check: boolean) => void,
-  ) {
+  constructor(private _checked: boolean) {
     super();
   }
 
-  override eq(other: CheckboxWidget) {
-    return this._checked === other._checked && this._indent === other._indent;
+  override eq(other: this) {
+    return this._checked === other._checked;
   }
 
-  toDOM(view: EditorView) {
-    const wrap = document.createElement('span');
-    wrap.className = 'cm-task-item';
-    wrap.setAttribute('aria-hidden', 'true');
-    wrap.style.setProperty('margin-left', this._indent * 24 + 'px');
-
-    const input = wrap.appendChild(document.createElement('input'));
+  override toDOM(view: EditorView) {
+    const input = document.createElement('input');
     input.type = 'checkbox';
     input.checked = this._checked;
-    if (!this._onCheck) {
+    if (view.state.readOnly) {
       input.setAttribute('disabled', 'true');
-    }
-    if (this._onCheck) {
-      input.onchange = (event: Event) => {
-        this._onCheck?.((event.target as any).checked);
-        return true;
+    } else {
+      input.onmousedown = (event: Event) => {
+        const pos = view.posAtDOM(input);
+        const text = view.state.sliceDoc(pos, pos + 3);
+        if (text === (this._checked ? '[x]' : '[ ]')) {
+          view.dispatch({
+            changes: { from: pos + 1, to: pos + 2, insert: this._checked ? ' ' : 'x' },
+          });
+          event.preventDefault();
+        }
       };
     }
 
-    return wrap;
+    return input;
   }
 
   override ignoreEvent() {
@@ -60,60 +42,54 @@ class CheckboxWidget extends WidgetType {
   }
 }
 
+const checkedDeco = Decoration.replace({ widget: new CheckboxWidget(true) });
+const uncheckedDeco = Decoration.replace({ widget: new CheckboxWidget(false) });
+
 export type TasklistOptions = {};
 
 export const tasklist = (options: TasklistOptions = {}) => {
-  // TODO(burdon): Matcher isn't as precise as syntax tree.
-  //  Allows for indents to be greater than AST would allow.
-  const taskMatcher = new MatchDecorator({
-    regexp: /^(\s*)- \[([ xX])\]\s/g,
-    decoration: (match, view, pos) => {
-      const indent = Math.floor(match[1].length / 2);
-      const checked = match[2] === 'x' || match[2] === 'X';
-      return Decoration.replace({
-        widget: new CheckboxWidget(
-          checked,
-          indent,
-          view.state.readOnly
-            ? undefined
-            : (checked) => {
-                const idx = pos + match[0].indexOf('[') + 1;
-                view.dispatch({
-                  changes: {
-                    from: idx,
-                    to: idx + 1,
-                    insert: checked ? 'x' : ' ',
-                  },
-                  // TODO(burdon): Restore cursor position? More useful to move to end of line (can indent).
-                  selection: {
-                    anchor: idx + 3,
-                  },
-                });
-              },
-        ),
-      });
-    },
-  });
-
-  const tasks = ViewPlugin.fromClass(
+  return ViewPlugin.fromClass(
     class {
-      tasks: DecorationSet;
+      decorations: DecorationSet;
+
       constructor(view: EditorView) {
-        this.tasks = taskMatcher.createDeco(view);
+        this.decorations = buildDecorations(view);
       }
 
       update(update: ViewUpdate) {
-        this.tasks = taskMatcher.updateDeco(update, this.tasks);
+        if (update.docChanged || update.viewportChanged || update.selectionSet) {
+          this.decorations = buildDecorations(update.view);
+        }
       }
     },
     {
-      decorations: (value) => value.tasks,
+      decorations: (v) => v.decorations,
       provide: (plugin) =>
         EditorView.atomicRanges.of((view) => {
-          return view.plugin(plugin)?.tasks || Decoration.none;
+          return view.plugin(plugin)?.decorations || Decoration.none;
         }),
     },
   );
+};
+
+const buildDecorations = (view: EditorView): DecorationSet => {
+  const builder = new RangeSetBuilder<Decoration>();
+  const { state } = view;
+  const cursor = state.selection.main.head;
+
+  for (const { from, to } of view.visibleRanges) {
+    syntaxTree(state).iterate({
+      enter: (node) => {
+        // Check if cursor is inside text.
+        if (node.name === 'TaskMarker' && (cursor < node.from || cursor > node.to)) {
+          const checked = state.doc.sliceString(node.from + 1, node.to - 1) === 'x';
+          builder.add(node.from, node.to, checked ? checkedDeco : uncheckedDeco);
+        }
+      },
+      from,
+      to,
+    });
+  }
 
-  return [tasks, styles];
+  return builder.finish();
 };

package/src/extensions/yjs/cursor.ts

@@ -6,12 +6,13 @@ import * as Y from 'yjs';
 
 import { arrayToString, stringToArray } from '@dxos/util';
 
-import { type CursorConverter } from '../../util';
+import { type CursorConverter } from '../cursor';
 
 export const cursorConverter = (text: Y.Text): CursorConverter => ({
   toCursor: (index, assoc) => {
     return arrayToString(Y.encodeRelativePosition(Y.createRelativePositionFromTypeIndex(text, index, assoc)));
   },
+
   fromCursor: (cursor) => {
     return (
       Y.createAbsolutePositionFromRelativePosition(Y.decodeRelativePosition(stringToArray(cursor)), text.doc!)?.index ??

package/src/extensions/yjs/yjs.test.ts

@@ -12,7 +12,7 @@ import { type YText } from '@dxos/text-model';
 describe('YJS', () => {
   // https://docs.yjs.dev/api/shared-types/y.text
   // https://github.com/yjs/yjs?tab=readme-ov-file#relative-positions
-  test('absolute position', () => {
+  test.skip('absolute position', () => {
     const obj = new TextObject('hello world');
     const index = obj.text.indexOf('world');
     const relPos = Y.encodeRelativePosition(Y.createRelativePositionFromTypeIndex(obj.content as YText, index));