@dxos/react-ui-editor 0.3.11-main.a996413 → 0.3.11-main.afa73e0

package/src/{hooks → extensions}/automerge/semaphore.ts

@@ -1,50 +1,53 @@
 //
 // Copyright 2023 DXOS.org
+// Copyright 2024 Automerge
+// Ref: https://github.com/automerge/automerge-codemirror
 //
 
-// TODO(burdon): Additional copyright?
-
+import { type StateField } from '@codemirror/state';
 import { type EditorView } from '@codemirror/view';
 
 import { next as automerge } from '@dxos/automerge/automerge';
 
-import { type IDocHandle } from './handle';
-import { type Field, isReconcileTx, getPath, reconcileAnnotationType, updateHeads, getLastHeads } from './plugin';
+import {
+  getLastHeads,
+  getPath,
+  isReconcileTx,
+  reconcileAnnotationType,
+  updateHeads,
+  type IDocHandle,
+  type State,
+} from './defs';
 import { updateAutomerge } from './update-automerge';
 import { updateCodeMirror } from './update-codemirror';
 
-type Doc<T> = automerge.Doc<T>;
-type Heads = automerge.Heads;
-
-type ChangeFn = (atHeads: Heads, change: (doc: Doc<unknown>) => void) => Heads | undefined;
-
 /**
- * TODO(burdon): Comment.
+ * Implements three-way merge (on each mutation/keystroke).
  */
 export class PatchSemaphore {
-  _field!: Field;
-  _inReconcile = false;
-  _queue: Array<ChangeFn> = [];
+  private _inReconcile = false;
 
-  constructor(field?: Field) {
-    if (field !== undefined) {
-      this._field = field;
-    }
-  }
+  // prettier-ignore
+  constructor(
+    private readonly _handle: IDocHandle,
+    private readonly _state: StateField<State>
+  ) {}
 
-  reconcile = (handle: IDocHandle, view: EditorView) => {
+  // NOTE: Cannot destruct view.state.
+  reconcile(view: EditorView) {
     if (this._inReconcile) {
       return;
     }
     this._inReconcile = true;
 
-    const path = getPath(view.state, this._field);
-    const oldHeads = getLastHeads(view.state, this._field);
-    let selection = view.state.selection;
+    const path = getPath(view.state, this._state);
 
-    const transactions = view.state.field(this._field).unreconciledTransactions.filter((tx) => !isReconcileTx(tx));
+    // Get the heads before the unreconciled transactions are applied.
+    const oldHeads = getLastHeads(view.state, this._state);
+    let selection = view.state.selection;
 
     // First undo all the unreconciled transactions.
+    const transactions = view.state.field(this._state).unreconciledTransactions.filter((tx) => !isReconcileTx(tx));
     const toInvert = transactions.slice().reverse();
     for (const tx of toInvert) {
       const inverted = tx.changes.invert(tx.startState.doc);
@@ -56,23 +59,25 @@ export class PatchSemaphore {
     }
 
     // Apply the unreconciled transactions to the document.
-    let newHeads = updateAutomerge(this._field, handle, transactions, view.state);
-
     // NOTE: null and undefined each come from automerge and repo respectively.
+    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(handle.docSync()!);
+      // TODO(alexjg): this is the call that's resetting the editor state on click.
+      newHeads = automerge.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(handle.docSync()!, oldHeads, newHeads);
+    const diff = automerge.equals(oldHeads, newHeads)
+      ? []
+      : automerge.diff(this._handle.docSync()!, oldHeads, newHeads);
     updateCodeMirror(view, selection, path, diff);
 
+    // Update automerge state.
     view.dispatch({
       effects: updateHeads(newHeads),
       annotations: reconcileAnnotationType.of({}),
     });
 
     this._inReconcile = false;
-  };
+  }
 }

package/src/{hooks → extensions}/automerge/update-automerge.ts

@@ -1,18 +1,17 @@
 //
 // Copyright 2023 DXOS.org
+// Copyright 2024 Automerge
+// Ref: https://github.com/automerge/automerge-codemirror
 //
 
-// TODO(burdon): Additional copyright?
-
-import { type EditorState, type Text, type Transaction } from '@codemirror/state';
+import { type EditorState, type StateField, type Text, type Transaction } from '@codemirror/state';
 
 import { next as am, type Heads } from '@dxos/automerge/automerge';
 
-import { type IDocHandle } from './handle';
-import { type Field } from './plugin';
+import { type IDocHandle, type State } from './defs';
 
 export const updateAutomerge = (
-  field: Field,
+  field: StateField<State>,
   handle: IDocHandle,
   transactions: Transaction[],
   state: EditorState,

package/src/{hooks → extensions}/automerge/update-codemirror.ts

@@ -1,9 +1,9 @@
 //
 // Copyright 2023 DXOS.org
+// Copyright 2024 Automerge
+// Ref: https://github.com/automerge/automerge-codemirror
 //
 
-// TODO(burdon): Additional copyright?
-
 import { ChangeSet, type ChangeSpec, type EditorSelection, type EditorState } from '@codemirror/state';
 import { type EditorView } from '@codemirror/view';
 
@@ -16,7 +16,7 @@ import {
   type SpliceTextPatch,
 } from '@dxos/automerge/automerge';
 
-import { reconcileAnnotationType } from './plugin';
+import { reconcileAnnotationType } from './defs';
 
 export const updateCodeMirror = (view: EditorView, selection: EditorSelection, target: Prop[], patches: Patch[]) => {
   for (const patch of patches) {
@@ -56,6 +56,7 @@ const handleInsert = (target: Prop[], patch: InsertPatch): Array<ChangeSpec> =>
   if (index == null) {
     return [];
   }
+
   const text = patch.values.map((v) => (v ? v.toString() : '')).join('');
   return [{ from: index, to: index, insert: text }];
 };
@@ -65,6 +66,7 @@ const handleSplice = (target: Prop[], patch: SpliceTextPatch): Array<ChangeSpec>
   if (index == null) {
     return [];
   }
+
   return [{ from: index, insert: patch.value }];
 };
 
@@ -73,6 +75,7 @@ const handleDel = (target: Prop[], patch: DelPatch): Array<ChangeSpec> => {
   if (index == null) {
     return [];
   }
+
   const length = patch.length || 1;
   return [{ from: index, to: index + length }];
 };
@@ -82,27 +85,32 @@ const handlePut = (target: Prop[], patch: PutPatch, state: EditorState): Array<C
   if (index == null) {
     return [];
   }
+
   const length = state.doc.length;
   if (typeof patch.value !== 'string') {
     return []; // TODO(dmaretskyi): How to handle non string values?
   }
+
   return [{ from: 0, to: length, insert: patch.value as any }];
 };
 
-// If the path of the patch is of the form [path, <index>] then we know this is
-// a path to a character within the sequence given by path
+// If the path of the patch is of the form [path, <index>] then we know this is a path to a character
+// within the sequence given by path.
 const charPath = (textPath: Prop[], candidatePath: Prop[]): number | null => {
   if (candidatePath.length !== textPath.length + 1) {
     return null;
   }
+
   for (let i = 0; i < textPath.length; i++) {
     if (textPath[i] !== candidatePath[i]) {
       return null;
     }
   }
+
   const index = candidatePath[candidatePath.length - 1];
   if (typeof index === 'number') {
     return index;
   }
+
   return null;
 };

package/src/extensions/awareness.ts

@@ -0,0 +1,310 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { Annotation, Facet, type Extension, RangeSet, type Range } from '@codemirror/state';
+import {
+  Decoration,
+  type DecorationSet,
+  EditorView,
+  type PluginValue,
+  ViewPlugin,
+  type ViewUpdate,
+  WidgetType,
+} from '@codemirror/view';
+
+import { Event } from '@dxos/async';
+import { Context } from '@dxos/context';
+
+import { Cursor, type CursorConverter } from './cursor';
+
+export interface AwarenessProvider {
+  remoteStateChange: Event<void>;
+
+  open(): void;
+  close(): void;
+
+  getRemoteStates(): AwarenessState[];
+  update(position: AwarenessPosition | undefined): void;
+}
+
+const dummyProvider: AwarenessProvider = {
+  remoteStateChange: new Event(),
+
+  open: () => {},
+  close: () => {},
+
+  getRemoteStates: () => [],
+  update: () => {},
+};
+
+export const AwarenessProvider = Facet.define<AwarenessProvider, AwarenessProvider>({
+  combine: (providers) => providers[0] ?? dummyProvider,
+});
+
+// TODO(dmaretskyi): Specify the users that actually changed. Currently, we recalculate positions for every user.
+const RemoteSelectionChangedAnnotation = Annotation.define();
+
+export type AwarenessPosition = {
+  anchor?: string;
+  head?: string;
+};
+
+export type AwarenessInfo = {
+  displayName?: string;
+  // TODO(burdon): Rename light/dark.
+  color?: string;
+  lightColor?: string;
+};
+
+export type AwarenessState = {
+  position?: AwarenessPosition;
+  peerId: string;
+  info: AwarenessInfo;
+};
+
+/**
+ * Extension provides presence information about other peers.
+ */
+export const awareness = (provider = dummyProvider): Extension => {
+  return [
+    AwarenessProvider.of(provider),
+    ViewPlugin.fromClass(RemoteSelectionsDecorator, {
+      decorations: (value) => value.decorations,
+    }),
+    styles,
+  ];
+};
+
+/**
+ * Generates selection decorations from remote peers.
+ */
+export class RemoteSelectionsDecorator implements PluginValue {
+  public decorations: DecorationSet = RangeSet.of([]);
+
+  private readonly _ctx = new Context();
+
+  private _cursorConverter: CursorConverter;
+  private _provider: AwarenessProvider;
+  private _lastAnchor?: number = undefined;
+  private _lastHead?: number = undefined;
+
+  constructor(view: EditorView) {
+    this._cursorConverter = view.state.facet(Cursor.converter);
+    this._provider = view.state.facet(AwarenessProvider);
+    this._provider.open();
+    this._provider.remoteStateChange.on(this._ctx, () => {
+      view.dispatch({ annotations: [RemoteSelectionChangedAnnotation.of([])] });
+    });
+  }
+
+  destroy() {
+    void this._ctx.dispose();
+    this._provider.close();
+  }
+
+  update(update: ViewUpdate) {
+    this._updateLocalSelection(update);
+    this._updateRemoteSelections(update);
+  }
+
+  private _updateLocalSelection(update: ViewUpdate) {
+    const hasFocus = update.view.hasFocus && update.view.dom.ownerDocument.hasFocus();
+    const { anchor = undefined, head = undefined } = hasFocus ? update.state.selection.main : {};
+    if (this._lastAnchor === anchor && this._lastHead === head) {
+      return;
+    }
+
+    this._lastAnchor = anchor;
+    this._lastHead = head;
+
+    this._provider.update(
+      anchor !== undefined && head !== undefined
+        ? {
+            anchor: this._cursorConverter.toCursor(anchor),
+            head: this._cursorConverter.toCursor(head),
+          }
+        : undefined,
+    );
+  }
+
+  private _updateRemoteSelections(update: ViewUpdate) {
+    const decorations: Range<Decoration>[] = [];
+    const awarenessStates = this._provider.getRemoteStates();
+    for (const state of awarenessStates) {
+      const anchor = state.position?.anchor ? this._cursorConverter.fromCursor(state.position.anchor) : null;
+      const head = state.position?.head ? this._cursorConverter.fromCursor(state.position.head) : null;
+      if (anchor == null || head == null) {
+        continue;
+      }
+
+      const start = Math.min(Math.min(anchor, head), update.view.state.doc.length);
+      const end = Math.min(Math.max(anchor, head), update.view.state.doc.length);
+
+      const startLine = update.view.state.doc.lineAt(start);
+      const endLine = update.view.state.doc.lineAt(end);
+
+      // TODO(burdon): Factor out styles.
+      const color = state.info.color ?? '#30bced';
+      const lightColor = state.info.lightColor ?? color + '33';
+
+      if (startLine.number === endLine.number) {
+        // Selected content in a single line.
+        decorations.push({
+          from: start,
+          to: end,
+          value: Decoration.mark({
+            attributes: { style: `background-color: ${lightColor}` },
+            class: 'cm-collab-selection',
+          }),
+        });
+      } else {
+        // Selected content in multiple lines; first, render text-selection in the first line.
+        decorations.push({
+          from: start,
+          to: startLine.from + startLine.length,
+          value: Decoration.mark({
+            attributes: { style: `background-color: ${color}` },
+            class: 'cm-collab-selection',
+          }),
+        });
+
+        // Render text-selection in the last line.
+        decorations.push({
+          from: endLine.from,
+          to: end,
+          value: Decoration.mark({
+            attributes: { style: `background-color: ${color}` },
+            class: 'cm-collab-selection',
+          }),
+        });
+
+        for (let i = startLine.number + 1; i < endLine.number; i++) {
+          const linePos = update.view.state.doc.line(i).from;
+          decorations.push({
+            from: linePos,
+            to: linePos,
+            value: Decoration.line({
+              attributes: { style: `background-color: ${color}`, class: 'cm-collab-selectionLine' },
+            }),
+          });
+        }
+      }
+
+      decorations.push({
+        from: head,
+        to: head,
+        value: Decoration.widget({
+          side: head - anchor > 0 ? -1 : 1, // The local cursor should be rendered outside the remote selection.
+          block: false,
+          widget: new RemoteCaretWidget(state.info.displayName ?? 'Anonymous', color),
+        }),
+      });
+    }
+
+    this.decorations = Decoration.set(decorations, true);
+  }
+}
+
+class RemoteCaretWidget extends WidgetType {
+  constructor(private readonly _name: string, private readonly _color: string) {
+    super();
+  }
+
+  override toDOM(): HTMLElement {
+    const span = document.createElement('span');
+    span.className = 'cm-collab-selectionCaret';
+    span.style.backgroundColor = this._color;
+    span.style.borderColor = this._color;
+
+    const dot = document.createElement('div');
+    dot.className = 'cm-collab-selectionCaretDot';
+
+    const info = document.createElement('div');
+    info.className = 'cm-collab-selectionInfo';
+    info.innerText = this._name;
+
+    span.appendChild(document.createTextNode('\u2060'));
+    span.appendChild(dot);
+    span.appendChild(document.createTextNode('\u2060'));
+    span.appendChild(info);
+    span.appendChild(document.createTextNode('\u2060'));
+
+    return span;
+  }
+
+  override updateDOM() {
+    return false;
+  }
+
+  override eq(widget: this) {
+    return widget._color === this._color;
+  }
+
+  override get estimatedHeight() {
+    return -1;
+  }
+
+  override ignoreEvent() {
+    return true;
+  }
+}
+
+const styles = EditorView.baseTheme({
+  '.cm-collab-selection': {},
+  '.cm-collab-selectionLine': {
+    padding: 0,
+    margin: '0px 2px 0px 4px',
+  },
+  '.cm-collab-selectionCaret': {
+    position: 'relative',
+    borderLeft: '1px solid black',
+    borderRight: '1px solid black',
+    marginLeft: '-1px',
+    marginRight: '-1px',
+    boxSizing: 'border-box',
+    display: 'inline',
+    cursor: 'pointer',
+  },
+  '.cm-collab-selectionCaretDot': {
+    borderRadius: '50%',
+    position: 'absolute',
+    width: '.5em',
+    height: '.5em',
+    top: '-.25em',
+    left: '-.25em',
+    backgroundColor: 'inherit',
+    transition: 'transform .3s ease-in-out',
+    boxSizing: 'border-box',
+  },
+  '.cm-collab-selectionCaret:hover > .cm-collab-selectionCaretDot': {
+    transform: 'scale(0)',
+    transformOrigin: 'center',
+  },
+  '.cm-collab-selectionInfo': {
+    position: 'absolute',
+    transform: 'translate(-50%, 0)',
+    top: '-20px',
+    left: 0,
+    fontSize: '.75em',
+    fontFamily: 'sans-serif',
+    fontStyle: 'normal',
+    fontWeight: 'normal',
+    lineHeight: 'normal',
+    userSelect: 'none',
+    color: 'white',
+    padding: '2px',
+    zIndex: 101,
+    transition: 'opacity .3s ease-in-out',
+    backgroundColor: 'inherit',
+    borderRadius: '2px',
+    // These should be separate.
+    opacity: 0,
+    transitionDelay: '0s',
+    whiteSpace: 'nowrap',
+  },
+  '.cm-collab-selectionCaret:hover > .cm-collab-selectionInfo': {
+    opacity: 1,
+    transitionDelay: '0s',
+  },
+});

package/src/extensions/basic.ts

@@ -3,30 +3,35 @@
 //
 
 import { closeBrackets } from '@codemirror/autocomplete';
+import { history } from '@codemirror/commands';
 import { bracketMatching, defaultHighlightStyle, syntaxHighlighting } from '@codemirror/language';
 import { type Extension } from '@codemirror/state';
 import { oneDarkHighlightStyle } from '@codemirror/theme-one-dark';
-import { drawSelection, EditorView, placeholder } from '@codemirror/view';
+import { drawSelection, EditorView, highlightActiveLine, placeholder } from '@codemirror/view';
 
-import type { ThemeMode } from '@dxos/react-ui';
+import { type ThemeMode } from '@dxos/react-ui';
+
+import { type TextEditorProps } from '../components';
 
 export type BasicBundleOptions = {
-  readonly?: boolean;
   themeMode?: ThemeMode;
-  placeholder?: string;
-};
+} & Pick<TextEditorProps, 'placeholder' | 'lineWrapping'>;
 
-export const basicBundle = ({ readonly, themeMode, placeholder: _placeholder }: BasicBundleOptions): Extension[] =>
-  [
-    EditorView.lineWrapping,
+export const basicBundle = ({
+  themeMode,
+  placeholder: _placeholder,
+  lineWrapping = true,
+}: BasicBundleOptions): Extension[] => [
+  lineWrapping ? EditorView.lineWrapping : [],
 
-    // TODO(burdon): Compare with minimalSetup.
-    // https://codemirror.net/docs/ref/#codemirror.minimalSetup
-    bracketMatching(),
-    closeBrackets(),
-    drawSelection(),
-    _placeholder && placeholder(_placeholder),
+  // https://codemirror.net/docs/ref/#codemirror.minimalSetup
+  bracketMatching(),
+  closeBrackets(),
+  drawSelection(),
+  highlightActiveLine(),
+  history(),
+  _placeholder ? placeholder(_placeholder) : [],
 
-    // TODO(burdon): Is this required?
-    themeMode === 'dark' ? syntaxHighlighting(oneDarkHighlightStyle) : syntaxHighlighting(defaultHighlightStyle),
-  ].filter(Boolean) as Extension[];
+  // https://github.com/codemirror/theme-one-dark
+  themeMode === 'dark' ? syntaxHighlighting(oneDarkHighlightStyle) : syntaxHighlighting(defaultHighlightStyle),
+];