@dxos/react-ui-editor 0.3.11-main.08776d7 → 0.3.11-main.0999ea0

package/src/extensions/comments.ts

@@ -2,16 +2,16 @@
 // Copyright 2023 DXOS.org
 //
 
-import { type Extension, StateEffect, StateField, type Text } from '@codemirror/state';
+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 { nonNullable } from '@dxos/util';
 
 import { Cursor } from './cursor';
-import { syncFacet } from './sync';
 import { type Comment, type Range } from '../hooks';
 import { getToken } from '../styles';
 import { callbackWrapper } from '../util';
@@ -21,15 +21,13 @@ const styles = EditorView.baseTheme({
   '& .cm-comment': {
     backgroundColor: getToken('extend.colors.yellow.50'),
   },
-  '& .cm-comment-active': {
+  '& .cm-comment-current': {
     backgroundColor: getToken('extend.colors.yellow.100'),
   },
 });
 
-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;
@@ -38,7 +36,7 @@ type CommentState = {
 };
 
 type SelectionState = {
-  active?: string;
+  current?: string;
   closest?: string;
 };
 
@@ -47,17 +45,23 @@ export type CommentsState = {
   selection: SelectionState;
 };
 
-export const setFocus = (view: EditorView, thread: string) => {
-  const comment = view.state.field(commentsState).comments.find((range) => range.comment.id === thread);
-  if (!comment) {
+export const setFocus = (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: comment.range.from },
-    scrollIntoView: true, // TODO(burdon): Scroll to y-position (or center of screen?)
-  });
+  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 setComments = StateEffect.define<Comment[]>();
@@ -89,7 +93,6 @@ const commentsState = StateField.define<CommentsState>({
             }
 
             const range = Cursor.getRangeFromCursor(tr.state, comment.cursor);
-            // console.log('update', JSON.stringify({ range, cursor: comment.cursor }, undefined, 2));
             return range && { comment, range };
           })
           .filter(nonNullable);
@@ -110,9 +113,9 @@ const commentsState = StateField.define<CommentsState>({
 /**
  * Decorate ranges.
  */
-const highlightDecorations = EditorView.decorations.compute([commentsState], (state) => {
+const commentsDecorations = EditorView.decorations.compute([commentsState], (state) => {
   const {
-    selection: { active },
+    selection: { current },
     comments,
   } = state.field(commentsState);
 
@@ -124,10 +127,10 @@ const highlightDecorations = EditorView.decorations.compute([commentsState], (st
         return undefined;
       }
 
-      if (comment.comment.id === active) {
-        return marks.highlightActive.range(range.from, range.to);
+      if (comment.comment.id === current) {
+        return commentCurrentMark.range(range.from, range.to);
       } else {
-        return marks.highlight.range(range.from, range.to);
+        return commentMark.range(range.from, range.to);
       }
     })
     .filter(nonNullable);
@@ -162,12 +165,11 @@ export type CommentsOptions = {
   onHover?: (el: Element, shortcut: string) => void;
 };
 
-// TODO(burdon): Handle cut/restore via undo (need to integrate with history?)
+type TrackedComment = { id: string; from: number; to: number };
+
 const trackPastedComments = (onUpdate: NonNullable<CommentsOptions['onUpdate']>) => {
-  // Cut/deleted comments.
   // Tracks indexed selections within text.
-  // TODO(burdon): Move to main state field?
-  let tracked: { text: Text; comments: { id: string; from: number; to: number }[] } | null = null;
+  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) => {
@@ -189,8 +191,6 @@ const trackPastedComments = (onUpdate: NonNullable<CommentsOptions['onUpdate']>)
         })),
       };
     }
-
-    // console.log('track', JSON.stringify({ tracked }, undefined, 2));
   };
 
   return [
@@ -199,16 +199,48 @@ const trackPastedComments = (onUpdate: NonNullable<CommentsOptions['onUpdate']>)
       copy: handleTrack,
     }),
 
-    // Handle paste.
-    EditorView.updateListener.of(({ view, state, transactions }) => {
+    // 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 }));
+          }
+        }
+      });
+
+      return effects;
+    }),
+
+    // Handle paste or the undo of comment deletion.
+    EditorView.updateListener.of((update) => {
+      const restore: TrackedComment[] = [];
+
+      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 = transactions.find((tr) => tr.isUserEvent('input.paste'));
+        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 = transactions.indexOf(paste!) + 1; i < transactions.length; i++) {
-                fromB = transactions[i].changes.mapPos(fromB);
+              for (let i = update.transactions.indexOf(paste!) + 1; i < update.transactions.length; i++) {
+                fromB = update.transactions[i].changes.mapPos(fromB);
               }
 
               found = fromB;
@@ -216,29 +248,79 @@ const trackPastedComments = (onUpdate: NonNullable<CommentsOptions['onUpdate']>)
           });
 
           if (found > -1) {
-            // Sync before recomputing cursor/range.
-            // TODO(burdon): Try to avoid this? See TextEditor dispatch.
-            state.facet(syncFacet)?.reconcile(view);
-
             for (const moved of tracked.comments) {
-              const range = {
-                from: found + moved.from,
-                to: found + moved.to,
-              };
-
-              const cursor = Cursor.getCursorFromRange(state, range);
-              // console.log('paste', JSON.stringify({ moved, range, cursor }, undefined, 2));
-              onUpdate(moved.id, cursor);
+              restore.push({ id: moved.id, from: found + moved.from, to: found + moved.to });
             }
           }
 
           tracked = null;
         }
       }
+
+      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;
+  }
+
+  // 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, view.coordsAtPos(from));
+    if (id) {
+      // Update range.
+      view.dispatch({
+        effects: setSelection.of({ current: id }),
+        selection: { anchor: to },
+      });
+
+      return true;
+    }
+  }
+
+  return false;
+};
+
 /**
  * Comment threads.
  * 1). Updates the EditorModel to store relative selections for a set of comments threads.
@@ -255,47 +337,10 @@ export const comments = (options: CommentsOptions = {}): Extension => {
 
   const handleSelect = debounce((state: CommentsState) => options.onSelect?.(state), 200);
 
-  /**
-   * Create comment thread action.
-   */
-  const createCommentThread: Command = (view) => {
-    invariant(options.onCreate);
-    const { from, to } = view.state.selection.main;
-    if (from === to) {
-      return false;
-    }
-
-    // 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 = callbackWrapper(options.onCreate)(cursor, view.coordsAtPos(from));
-      if (id) {
-        // Update range.
-        view.dispatch({
-          effects: setSelection.of({ active: id }),
-          selection: { anchor: from },
-        });
-
-        return true;
-      }
-    }
-
-    return false;
-  };
-
   return [
+    optionsFacet.of(options),
     commentsState,
-    highlightDecorations,
+    commentsDecorations,
     styles,
 
     //
@@ -305,8 +350,7 @@ export const comments = (options: CommentsOptions = {}): Extension => {
       ? keymap.of([
           {
             key: shortcut,
-            // TODO(burdon): Check if there's a better way?
-            run: callbackWrapper(createCommentThread),
+            run: callbackWrapper(createComment),
           },
         ])
       : [],
@@ -375,10 +419,10 @@ export const comments = (options: CommentsOptions = {}): Extension => {
     //
     // Track selection/proximity.
     //
-    EditorView.updateListener.of(({ view, state, changes }) => {
+    EditorView.updateListener.of(({ view, state }) => {
       let min = Infinity;
       const {
-        selection: { active, closest },
+        selection: { current, closest },
         comments,
       } = state.field(commentsState);
 
@@ -386,11 +430,11 @@ export const comments = (options: CommentsOptions = {}): Extension => {
       const selection: SelectionState = {};
       comments.forEach(({ comment, range }) => {
         if (head >= range.from && head <= range.to) {
-          selection.active = comment.id;
+          selection.current = comment.id;
           selection.closest = undefined;
         }
 
-        if (!selection.active) {
+        if (!selection.current) {
           const d = Math.min(Math.abs(head - range.from), Math.abs(head - range.to));
           if (d < min) {
             selection.closest = comment.id;
@@ -399,7 +443,7 @@ export const comments = (options: CommentsOptions = {}): Extension => {
         }
       });
 
-      if (selection.active !== active || selection.closest !== closest) {
+      if (selection.current !== current || selection.closest !== closest) {
         view.dispatch({ effects: setSelection.of(selection) });
 
         // Update callback.
@@ -417,3 +461,16 @@ export const comments = (options: CommentsOptions = {}): Extension => {
     options.onUpdate ? trackPastedComments(options.onUpdate) : [],
   ];
 };
+
+/**
+ * Update comments state field.
+ */
+export const useComments = (view: EditorView | null, comments: Comment[] = []) => {
+  useEffect(() => {
+    if (view) {
+      view.dispatch({
+        effects: setComments.of(comments),
+      });
+    }
+  }, [view, comments]);
+};

package/src/extensions/index.ts

@@ -7,18 +7,10 @@ export * from './automerge';
 export * from './awareness';
 export * from './basic';
 export * from './blast';
-export * from './code';
 export * from './comments';
 export * from './cursor';
-export * from './hr';
-export * from './image';
-export * from './link';
 export * from './listener';
 export * from './markdown';
 export * from './mention';
 export * from './outliner';
-export * from './sync';
-export * from './table';
-export * from './tasklist';
 export * from './typewriter';
-export * from './yjs';

package/src/extensions/markdown/bundle.ts

@@ -23,34 +23,26 @@ import {
 import type { ThemeMode } from '@dxos/react-ui';
 
 import { markdownHighlightStyle, markdownTagsExtensions } from './highlight';
+import { type TextEditorProps } from '../../components';
 
 export type MarkdownBundleOptions = {
-  readonly?: boolean;
   themeMode?: ThemeMode;
-  placeholder?: string;
-};
+} & Pick<TextEditorProps, 'placeholder'>;
 
 /**
  * Markdown bundle.
  * Refs:
- * https://github.com/codemirror/basic-setup
- * https://github.com/codemirror/basic-setup/blob/main/src/codemirror.ts#L50
  * https://codemirror.net/docs/community
  * https://codemirror.net/docs/ref/#codemirror.basicSetup
  */
 // TODO(burdon): Add Composer here: https://codemirror.net/docs/community
-export const markdownBundle = ({
-  readonly,
-  themeMode,
-  placeholder: _placeholder,
-}: MarkdownBundleOptions): Extension[] => {
+export const markdownBundle = ({ themeMode, placeholder: _placeholder }: MarkdownBundleOptions): Extension[] => {
   return [
     EditorState.allowMultipleSelections.of(true),
     EditorState.tabSize.of(2),
     EditorView.lineWrapping,
 
-    customKeymap(),
-
+    // https://github.com/codemirror/basic-setup
     bracketMatching(),
     closeBrackets(),
     crosshairCursor(),
@@ -59,7 +51,7 @@ export const markdownBundle = ({
     highlightActiveLine(),
     history(),
     indentOnInput(),
-    _placeholder && placeholder(_placeholder),
+    _placeholder ? placeholder(_placeholder) : [],
 
     // Main extension.
     // https://github.com/codemirror/lang-markdown
@@ -86,21 +78,19 @@ export const markdownBundle = ({
     themeMode === 'dark' ? syntaxHighlighting(oneDarkHighlightStyle) : syntaxHighlighting(defaultHighlightStyle),
 
     // Custom styles.
-    syntaxHighlighting(markdownHighlightStyle(readonly)),
-  ].filter(Boolean) as Extension[];
-};
+    syntaxHighlighting(markdownHighlightStyle()),
 
-// https://codemirror.net/docs/ref/#view.keymap
-const customKeymap = () =>
-  keymap.of([
-    // https://codemirror.net/docs/ref/#commands.indentWithTab
-    indentWithTab,
-    // https://codemirror.net/docs/ref/#commands.standardKeymap
-    ...standardKeymap,
-    // https://codemirror.net/docs/ref/#commands.historyKeymap
-    ...historyKeymap,
-    // https://codemirror.net/docs/ref/#autocomplete.closeBracketsKeymap
-    ...closeBracketsKeymap,
-    // https://codemirror.net/docs/ref/#search.searchKeymap
-    ...searchKeymap,
-  ]);
+    keymap.of([
+      // https://codemirror.net/docs/ref/#commands.indentWithTab
+      indentWithTab,
+      // https://codemirror.net/docs/ref/#autocomplete.closeBracketsKeymap
+      ...closeBracketsKeymap,
+      // https://codemirror.net/docs/ref/#commands.historyKeymap
+      ...historyKeymap,
+      // https://codemirror.net/docs/ref/#search.searchKeymap
+      ...searchKeymap,
+      // https://codemirror.net/docs/ref/#commands.standardKeymap
+      ...standardKeymap,
+    ]),
+  ];
+};

package/src/extensions/markdown/code.ts

@@ -0,0 +1,142 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { syntaxTree } from '@codemirror/language';
+import { RangeSetBuilder } from '@codemirror/state';
+import {
+  ViewPlugin,
+  type DecorationSet,
+  EditorView,
+  type ViewUpdate,
+  Decoration,
+  type BlockInfo,
+  WidgetType,
+} from '@codemirror/view';
+
+import { mx } from '@dxos/react-ui-theme';
+
+import { getToken } from '../../styles';
+
+// TODO(burdon): Reconcile with theme.
+const styles = EditorView.baseTheme({
+  '& .cm-code': {
+    paddingInline: '1rem !important',
+    fontFamily: getToken('fontFamily.mono', []).join(','),
+  },
+  '& .cm-codeblock': {
+    display: 'inline-block',
+    width: '100%',
+    position: 'relative',
+    '&::after': {
+      content: '""',
+      position: 'absolute',
+      inset: 0,
+    },
+  },
+  '&light .cm-codeblock': {
+    '&::after': {
+      background: getToken('extend.semanticColors.input.light'),
+      mixBlendMode: 'darken',
+    },
+  },
+  '&dark .cm-codeblock': {
+    '&::after': {
+      background: getToken('extend.semanticColors.input.dark'),
+      mixBlendMode: 'lighten',
+    },
+  },
+  '& .cm-codeblock-first': {
+    '&::after': {
+      borderTopLeftRadius: '.5rem',
+      borderTopRightRadius: '.5rem',
+    },
+  },
+  '& .cm-codeblock-last': {
+    '&::after': {
+      borderBottomLeftRadius: '.5rem',
+      borderBottomRightRadius: '.5rem',
+    },
+  },
+});
+
+// TODO(burdon): Start from EditorView.lineBlockAt(pos).
+const getLineRange = (lines: BlockInfo[], from: number, to: number) => {
+  const start = lines.findIndex((line) => line.from >= from);
+  const end = lines.findIndex((line) => line.to >= to);
+  return [start, end];
+};
+
+class LineWidget extends WidgetType {
+  constructor(private readonly _className: string) {
+    super();
+  }
+
+  override toDOM() {
+    const el = document.createElement('span');
+    el.innerHTML = ' ';
+    el.className = mx('cm-code cm-codeblock', this._className);
+    return el;
+  }
+}
+
+const top = new LineWidget('cm-codeblock-first');
+const bottom = new LineWidget('cm-codeblock-last');
+
+const buildDecorations = (view: EditorView): DecorationSet => {
+  const builder = new RangeSetBuilder<Decoration>();
+  const { state } = view;
+  const blocks = view.viewportLineBlocks;
+  const cursor = state.selection.main.head;
+
+  // TODO(burdon): Add copy to clipboard widget.
+  for (const { from, to } of view.visibleRanges) {
+    syntaxTree(state).iterate({
+      enter: (node) => {
+        if (node.name === 'FencedCode') {
+          const edit = !view.state.readOnly && cursor >= node.from && cursor <= node.to;
+          const range = getLineRange(blocks, node.from, node.to);
+          for (let i = range[0]; i <= range[1]; i++) {
+            const block = blocks[i];
+            if (!edit && (i === range[0] || i === range[1])) {
+              builder.add(block.from, block.to, Decoration.replace({ widget: i === range[0] ? top : bottom }));
+            } else {
+              builder.add(
+                block.from,
+                block.from,
+                Decoration.line({
+                  class: mx('cm-code cm-codeblock'),
+                }),
+              );
+            }
+          }
+        }
+      },
+      from,
+      to,
+    });
+  }
+
+  return builder.finish();
+};
+
+export const code = () => {
+  return [
+    ViewPlugin.fromClass(
+      class {
+        decorations: DecorationSet;
+        constructor(view: EditorView) {
+          this.decorations = buildDecorations(view);
+        }
+
+        update(update: ViewUpdate) {
+          this.decorations = buildDecorations(update.view);
+        }
+      },
+      {
+        decorations: (value) => value.decorations,
+      },
+    ),
+    styles,
+  ];
+};