@dxos/react-ui-editor 0.3.11-main.73ee990 → 0.3.11-main.764a9c1

package/src/extensions/automerge/automerge.ts

@@ -4,14 +4,14 @@
 // Ref: https://github.com/automerge/automerge-codemirror
 //
 
-import { StateField, type Extension } from '@codemirror/state';
+import { invertedEffects } from '@codemirror/commands';
+import { StateField, type Extension, type StateEffect } from '@codemirror/state';
 import { EditorView, ViewPlugin } from '@codemirror/view';
 
-import { type Prop, next as _automerge } from '@dxos/automerge/automerge';
-import { invariant } from '@dxos/invariant';
+import { next as A, type Prop } from '@dxos/automerge/automerge';
 
 import { cursorConverter } from './cursor';
-import { effectType, type IDocHandle, isReconcileTx, type State } from './defs';
+import { updateHeadsEffect, type IDocHandle, isReconcile, type State } from './defs';
 import { PatchSemaphore } from './semaphore';
 import { Cursor } from '../cursor';
 
@@ -21,10 +21,10 @@ export type AutomergeOptions = {
 };
 
 export const automerge = ({ handle, path }: AutomergeOptions): Extension => {
-  const state = StateField.define<State>({
+  const syncState = StateField.define<State>({
     create: () => ({
       path: path.slice(),
-      lastHeads: _automerge.getHeads(handle.docSync()!),
+      lastHeads: A.getHeads(handle.docSync()!),
       unreconciledTransactions: [],
     }),
 
@@ -37,7 +37,7 @@ export const automerge = ({ handle, path }: AutomergeOptions): Extension => {
 
       let clearUnreconciled = false;
       for (const effect of tr.effects) {
-        if (effect.is(effectType)) {
+        if (effect.is(updateHeadsEffect)) {
           result.lastHeads = effect.value.newHeads;
           clearUnreconciled = true;
         }
@@ -46,7 +46,7 @@ export const automerge = ({ handle, path }: AutomergeOptions): Extension => {
       if (clearUnreconciled) {
         result.unreconciledTransactions = [];
       } else {
-        if (!isReconcileTx(tr)) {
+        if (!isReconcile(tr)) {
           result.unreconciledTransactions.push(tr);
         }
       }
@@ -55,15 +55,16 @@ export const automerge = ({ handle, path }: AutomergeOptions): Extension => {
     },
   });
 
-  const semaphore = new PatchSemaphore(handle, state);
+  const semaphore = new PatchSemaphore(handle, syncState);
 
   return [
     Cursor.converter.of(cursorConverter(handle, path)),
+    syncState,
+
     // Reconcile external updates.
     ViewPlugin.fromClass(
       class {
         constructor(private readonly _view: EditorView) {
-          invariant(this._view);
           handle.addListener('change', this._handleChange.bind(this));
         }
 
@@ -76,12 +77,27 @@ export const automerge = ({ handle, path }: AutomergeOptions): Extension => {
         }
       },
     ),
+
     // Reconcile local updates.
     EditorView.updateListener.of(({ view, changes }) => {
       if (!changes.empty) {
         semaphore.reconcile(view);
       }
     }),
-    state,
+
+    // TODO(burdon): Record undo transactions.
+    //  See https://github.com/yjs/y-codemirror.next/tree/main
+    // https://codemirror.net/examples/inverted-effect
+    invertedEffects.of((tr) => {
+      // Each change results it three transactions: insert, delete, insert.
+      const effects: StateEffect<any>[] = [];
+      if (!tr.changes.empty) {
+        tr.changes.iterChanges((fromA, toA, fromB, toB, inserted) => {
+          // effects.push(effectType.of({});
+        });
+      }
+
+      return effects;
+    }),
   ];
 };

package/src/extensions/automerge/cursor.ts

@@ -5,7 +5,7 @@
 import get from 'lodash.get';
 
 import type { Prop } from '@dxos/automerge/automerge';
-import { next as automerge } from '@dxos/automerge/automerge';
+import { next as A } from '@dxos/automerge/automerge';
 
 import { type IDocHandle } from './defs';
 import { type CursorConverter } from '../cursor';
@@ -24,7 +24,7 @@ export const cursorConverter = (handle: IDocHandle, path: Prop[]): CursorConvert
     }
 
     // NOTE: Slice is needed because getCursor mutates the array.
-    return automerge.getCursor(doc, path.slice(), pos);
+    return A.getCursor(doc, path.slice(), pos);
   },
 
   fromCursor: (cursor) => {
@@ -47,6 +47,6 @@ export const cursorConverter = (handle: IDocHandle, path: Prop[]): CursorConvert
     }
 
     // NOTE: Slice is needed because getCursor mutates the array.
-    return automerge.getCursorPosition(doc, path.slice(), cursor);
+    return A.getCursorPosition(doc, path.slice(), cursor);
   },
 });

package/src/extensions/automerge/defs.ts

@@ -8,28 +8,28 @@ import { Annotation, StateEffect, type StateField, type EditorState, type Transa
 
 import { type ChangeFn, type ChangeOptions, type Doc, type Heads, type Prop } from '@dxos/automerge/automerge';
 
-// TODO(burdon): Rename.
 export type State = {
   path: Prop[];
   lastHeads: Heads;
   unreconciledTransactions: Transaction[];
 };
 
+export const getPath = (state: EditorState, field: StateField<State>): Prop[] => state.field(field).path;
+export const getLastHeads = (state: EditorState, field: StateField<State>): Heads => state.field(field).lastHeads;
+
 export type UpdateHeads = {
   newHeads: Heads;
 };
 
-export const effectType = StateEffect.define<UpdateHeads>({});
-
-export const reconcileAnnotationType = Annotation.define<unknown>();
+export const updateHeadsEffect = StateEffect.define<UpdateHeads>({});
 
-export const getPath = (state: EditorState, field: StateField<State>): Prop[] => state.field(field).path;
-
-export const getLastHeads = (state: EditorState, field: StateField<State>): Heads => state.field(field).lastHeads;
+export const updateHeads = (newHeads: Heads): StateEffect<UpdateHeads> => updateHeadsEffect.of({ newHeads });
 
-export const updateHeads = (newHeads: Heads): StateEffect<UpdateHeads> => effectType.of({ newHeads });
+export const reconcileAnnotation = Annotation.define<boolean>();
 
-export const isReconcileTx = (tr: Transaction): boolean => !!tr.annotation(reconcileAnnotationType);
+export const isReconcile = (tr: Transaction): boolean => {
+  return !!tr.annotation(reconcileAnnotation);
+};
 
 export type IDocHandle<T = any> = {
   docSync(): Doc<T> | undefined;

package/src/extensions/automerge/semaphore.ts

@@ -7,13 +7,13 @@
 import { type StateField } from '@codemirror/state';
 import { type EditorView } from '@codemirror/view';
 
-import { next as automerge } from '@dxos/automerge/automerge';
+import { next as A } from '@dxos/automerge/automerge';
 
 import {
   getLastHeads,
   getPath,
-  isReconcileTx,
-  reconcileAnnotationType,
+  isReconcile,
+  reconcileAnnotation,
   updateHeads,
   type IDocHandle,
   type State,
@@ -22,7 +22,7 @@ import { updateAutomerge } from './update-automerge';
 import { updateCodeMirror } from './update-codemirror';
 
 /**
- * Implements three-way merge (on each mutation/keystroke).
+ * Implements three-way merge (on each mutation).
  */
 export class PatchSemaphore {
   private _inReconcile = false;
@@ -33,13 +33,15 @@ export class PatchSemaphore {
     private readonly _state: StateField<State>
   ) {}
 
-  // NOTE: Cannot destruct view.state.
   reconcile(view: EditorView) {
-    if (this._inReconcile) {
-      return;
+    if (!this._inReconcile) {
+      this._inReconcile = true;
+      this.doReconcile(view);
+      this._inReconcile = false;
     }
-    this._inReconcile = true;
+  }
 
+  private doReconcile(view: EditorView) {
     const path = getPath(view.state, this._state);
 
     // Get the heads before the unreconciled transactions are applied.
@@ -47,14 +49,14 @@ export class PatchSemaphore {
     let selection = view.state.selection;
 
     // First undo all the unreconciled transactions.
-    const transactions = view.state.field(this._state).unreconciledTransactions.filter((tx) => !isReconcileTx(tx));
+    const transactions = view.state.field(this._state).unreconciledTransactions.filter((tx) => !isReconcile(tx));
     const toInvert = transactions.slice().reverse();
-    for (const tx of toInvert) {
-      const inverted = tx.changes.invert(tx.startState.doc);
+    for (const tr of toInvert) {
+      const inverted = tr.changes.invert(tr.startState.doc);
       selection = selection.map(inverted);
       view.dispatch({
         changes: inverted,
-        annotations: reconcileAnnotationType.of(true),
+        annotations: reconcileAnnotation.of(true),
       });
     }
 
@@ -63,21 +65,17 @@ export class PatchSemaphore {
     let newHeads = updateAutomerge(this._state, this._handle, transactions, view.state);
     if (newHeads === null || newHeads === undefined) {
       // TODO(alexjg): this is the call that's resetting the editor state on click.
-      newHeads = automerge.getHeads(this._handle.docSync()!);
+      newHeads = A.getHeads(this._handle.docSync()!);
     }
 
     // Now get the diff between the updated state of the document and the heads and apply that to the codemirror doc.
-    const diff = automerge.equals(oldHeads, newHeads)
-      ? []
-      : automerge.diff(this._handle.docSync()!, oldHeads, newHeads);
+    const diff = A.equals(oldHeads, newHeads) ? [] : A.diff(this._handle.docSync()!, oldHeads, newHeads);
     updateCodeMirror(view, selection, path, diff);
 
     // Update automerge state.
     view.dispatch({
       effects: updateHeads(newHeads),
-      annotations: reconcileAnnotationType.of({}),
+      annotations: reconcileAnnotation.of(false),
     });
-
-    this._inReconcile = false;
   }
 }

package/src/extensions/automerge/update-automerge.ts

@@ -4,9 +4,9 @@
 // Ref: https://github.com/automerge/automerge-codemirror
 //
 
-import { type EditorState, type StateField, type Transaction } from '@codemirror/state';
+import { type EditorState, type StateField, type Transaction, type Text } from '@codemirror/state';
 
-import { next as automerge, type Heads } from '@dxos/automerge/automerge';
+import { next as A, type Heads } from '@dxos/automerge/automerge';
 
 import { type IDocHandle, type State } from './defs';
 
@@ -14,7 +14,7 @@ export const updateAutomerge = (
   field: StateField<State>,
   handle: IDocHandle,
   transactions: Transaction[],
-  state: EditorState, // TODO(burdon): Just pass in the state field value.
+  state: EditorState, // TODO(burdon): Just pass in the state field value?
 ): Heads | undefined => {
   const { lastHeads, path } = state.field(field);
 
@@ -31,17 +31,17 @@ export const updateAutomerge = (
     return undefined;
   }
 
-  const newHeads = handle.changeAt(lastHeads, (doc: automerge.Doc<unknown>) => {
-    const t: any[] = [];
+  const newHeads = handle.changeAt(lastHeads, (doc: A.Doc<unknown>) => {
+    const invertedTransactions: { from: number; del: number; insert: Text }[] = [];
     for (const tr of transactions) {
       tr.changes.iterChanges((fromA, toA, _fromB, _toB, insert) => {
-        t.push({ fromA, toA, insert });
+        invertedTransactions.push({ from: fromA, del: toA - fromA, insert });
       });
     }
 
-    // Apply in reverse order to properly apply range.
-    t.reverse().forEach(({ fromA, toA, insert }) => {
-      automerge.splice(doc, path.slice(), fromA, toA - fromA, insert.toString());
+    // TODO(burdon): Hack to apply in reverse order to properly apply range.
+    invertedTransactions.reverse().forEach(({ from, del, insert }) => {
+      A.splice(doc, path.slice(), from, del, insert.toString());
     });
   });
 

package/src/extensions/automerge/update-codemirror.ts

@@ -16,7 +16,7 @@ import {
   type SpliceTextPatch,
 } from '@dxos/automerge/automerge';
 
-import { reconcileAnnotationType } from './defs';
+import { reconcileAnnotation } from './defs';
 
 export const updateCodeMirror = (view: EditorView, selection: EditorSelection, target: Prop[], patches: Patch[]) => {
   for (const patch of patches) {
@@ -26,14 +26,14 @@ export const updateCodeMirror = (view: EditorView, selection: EditorSelection, t
       selection = selection.map(changeSet, 1);
       view.dispatch({
         changes: changeSet,
-        annotations: reconcileAnnotationType.of({}),
+        annotations: reconcileAnnotation.of(false),
       });
     }
   }
 
   view.dispatch({
     selection,
-    annotations: reconcileAnnotationType.of({}),
+    annotations: reconcileAnnotation.of(false),
   });
 };
 
@@ -57,7 +57,7 @@ const handleInsert = (target: Prop[], patch: InsertPatch): Array<ChangeSpec> =>
     return [];
   }
 
-  const text = patch.values.map((v) => (v ? v.toString() : '')).join('');
+  const text = patch.values.map((value) => (value ? value.toString() : '')).join('');
   return [{ from: index, to: index, insert: text }];
 };
 
@@ -88,7 +88,7 @@ const handlePut = (target: Prop[], patch: PutPatch, state: EditorState): Array<C
 
   const length = state.doc.length;
   if (typeof patch.value !== 'string') {
-    return []; // TODO(dmaretskyi): How to handle non string values?
+    return []; // TODO(dmaretskyi): How to handle non-string values?
   }
 
   return [{ from: 0, to: length, insert: patch.value as any }];

package/src/extensions/awareness.ts

@@ -38,7 +38,7 @@ const dummyProvider: AwarenessProvider = {
   update: () => {},
 };
 
-export const AwarenessProvider = Facet.define<AwarenessProvider, AwarenessProvider>({
+export const awarenessProvider = Facet.define<AwarenessProvider, AwarenessProvider>({
   combine: (providers) => providers[0] ?? dummyProvider,
 });
 
@@ -68,7 +68,7 @@ export type AwarenessState = {
  */
 export const awareness = (provider = dummyProvider): Extension => {
   return [
-    AwarenessProvider.of(provider),
+    awarenessProvider.of(provider),
     ViewPlugin.fromClass(RemoteSelectionsDecorator, {
       decorations: (value) => value.decorations,
     }),
@@ -91,7 +91,7 @@ export class RemoteSelectionsDecorator implements PluginValue {
 
   constructor(view: EditorView) {
     this._cursorConverter = view.state.facet(Cursor.converter);
-    this._provider = view.state.facet(AwarenessProvider);
+    this._provider = view.state.facet(awarenessProvider);
     this._provider.open();
     this._provider.remoteStateChange.on(this._ctx, () => {
       view.dispatch({ annotations: [RemoteSelectionChangedAnnotation.of([])] });
@@ -207,7 +207,10 @@ export class RemoteSelectionsDecorator implements PluginValue {
 }
 
 class RemoteCaretWidget extends WidgetType {
-  constructor(private readonly _name: string, private readonly _color: string) {
+  constructor(
+    private readonly _name: string,
+    private readonly _color: string,
+  ) {
     super();
   }
 

package/src/extensions/basic.ts

@@ -10,6 +10,7 @@ import { oneDarkHighlightStyle } from '@codemirror/theme-one-dark';
 import { drawSelection, EditorView, highlightActiveLine, placeholder } from '@codemirror/view';
 
 import { type ThemeMode } from '@dxos/react-ui';
+import { isNotFalsy } from '@dxos/util';
 
 import { type TextEditorProps } from '../components';
 
@@ -17,21 +18,22 @@ export type BasicBundleOptions = {
   themeMode?: ThemeMode;
 } & Pick<TextEditorProps, 'placeholder' | 'lineWrapping'>;
 
-export const basicBundle = ({
+export const createBasicBundle = ({
   themeMode,
   placeholder: _placeholder,
   lineWrapping = true,
-}: BasicBundleOptions): Extension[] => [
-  lineWrapping ? EditorView.lineWrapping : [],
+}: BasicBundleOptions = {}): Extension[] =>
+  [
+    lineWrapping && EditorView.lineWrapping,
 
-  // https://codemirror.net/docs/ref/#codemirror.minimalSetup
-  bracketMatching(),
-  closeBrackets(),
-  drawSelection(),
-  highlightActiveLine(),
-  history(),
-  _placeholder ? placeholder(_placeholder) : [],
+    // https://codemirror.net/docs/ref/#codemirror.minimalSetup
+    bracketMatching(),
+    closeBrackets(),
+    drawSelection(),
+    highlightActiveLine(),
+    history(),
+    _placeholder && placeholder(_placeholder),
 
-  // https://github.com/codemirror/theme-one-dark
-  themeMode === 'dark' ? syntaxHighlighting(oneDarkHighlightStyle) : syntaxHighlighting(defaultHighlightStyle),
-];
+    // https://github.com/codemirror/theme-one-dark
+    themeMode === 'dark' ? syntaxHighlighting(oneDarkHighlightStyle) : syntaxHighlighting(defaultHighlightStyle),
+  ].filter(isNotFalsy);

package/src/extensions/blast.ts

@@ -125,7 +125,10 @@ class Blaster {
 
   _lastPoint = { x: 0, y: 0 };
 
-  constructor(private readonly _node: HTMLElement, private readonly _options: BlastOptions) {
+  constructor(
+    private readonly _node: HTMLElement,
+    private readonly _options: BlastOptions,
+  ) {
     this._effect = this._options.effect === 1 ? new Effect1(_options) : new Effect2(_options);
   }
 

package/src/extensions/comments.ts

@@ -2,7 +2,8 @@
 // Copyright 2023 DXOS.org
 //
 
-import { type Extension, Facet, 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';
@@ -17,18 +18,26 @@ import { callbackWrapper } from '../util';
 
 // TODO(burdon): Reconcile with theme.
 const styles = EditorView.baseTheme({
-  '& .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-current': {
+  '&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-current' }),
-};
+const commentMark = Decoration.mark({ class: 'cm-comment' });
+const commentCurrentMark = Decoration.mark({ class: 'cm-comment-current' });
 
 type CommentState = {
   comment: Comment;
@@ -46,7 +55,7 @@ export type CommentsState = {
   selection: SelectionState;
 };
 
-export const setFocus = (view: EditorView, id: string, center = true) => {
+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;
@@ -114,7 +123,7 @@ const commentsState = StateField.define<CommentsState>({
 /**
  * Decorate ranges.
  */
-const highlightDecorations = EditorView.decorations.compute([commentsState], (state) => {
+const commentsDecorations = EditorView.decorations.compute([commentsState], (state) => {
   const {
     selection: { current },
     comments,
@@ -129,9 +138,9 @@ const highlightDecorations = EditorView.decorations.compute([commentsState], (st
       }
 
       if (comment.comment.id === current) {
-        return marks.highlightActive.range(range.from, range.to);
+        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);
@@ -147,7 +156,7 @@ export type CommentsOptions = {
   /**
    * Called to create a new thread and return the thread id.
    */
-  onCreate?: (cursor: string, location?: Rect | null) => string | undefined;
+  onCreate?: (params: { cursor: string; from: number; location?: Rect | null }) => string | undefined;
   /**
    * Selection cut/deleted.
    */
@@ -166,11 +175,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']>) => {
   // 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) => {
@@ -200,16 +209,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;
@@ -218,23 +259,36 @@ const trackPastedComments = (onUpdate: NonNullable<CommentsOptions['onUpdate']>)
 
           if (found > -1) {
             for (const moved of tracked.comments) {
-              const range = {
-                from: found + moved.from,
-                to: found + moved.to,
-              };
-
-              const cursor = Cursor.getCursorFromRange(state, range);
-              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],
 });
@@ -262,12 +316,12 @@ export const createComment: Command = (view) => {
   const cursor = Cursor.getCursorFromRange(view.state, { from, to });
   if (cursor) {
     // Create thread via callback.
-    const id = options.onCreate?.(cursor, view.coordsAtPos(from));
+    const id = options.onCreate?.({ cursor, from, location: view.coordsAtPos(from) });
     if (id) {
       // Update range.
       view.dispatch({
         effects: setSelection.of({ current: id }),
-        selection: { anchor: from },
+        selection: { anchor: to },
       });
 
       return true;
@@ -296,7 +350,7 @@ export const comments = (options: CommentsOptions = {}): Extension => {
   return [
     optionsFacet.of(options),
     commentsState,
-    highlightDecorations,
+    commentsDecorations,
     styles,
 
     //