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

package/src/extensions/table.ts

@@ -81,7 +81,6 @@ const update = (state: EditorState, options: TableOptions) => {
         table.from,
         table.to,
         Decoration.replace({
-          block: true,
           widget: new TableWidget(table),
         }),
       );
@@ -98,11 +97,14 @@ class TableWidget extends WidgetType {
     super();
   }
 
-  override eq(other: WidgetType) {
-    return this._table.from === (other as any as TableWidget)?._table?.from;
+  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');
 
     {
@@ -129,4 +131,8 @@ class TableWidget extends WidgetType {
 
     return table;
   }
+
+  override ignoreEvent(e: Event) {
+    return !/^mouse/.test(e.type);
+  }
 }

package/src/extensions/tasklist.ts

@@ -2,58 +2,53 @@
 // Copyright 2023 DXOS.org
 //
 
-import {
-  EditorView,
-  Decoration,
-  WidgetType,
-  MatchDecorator,
-  ViewPlugin,
-  type DecorationSet,
-  type ViewUpdate,
-} from '@codemirror/view';
+import { syntaxTree } from '@codemirror/language';
+import { RangeSetBuilder } from '@codemirror/state';
+import { EditorView, Decoration, WidgetType, ViewPlugin, type DecorationSet, type ViewUpdate } from '@codemirror/view';
+
+import { getToken } from '../styles';
 
 // TODO(burdon): Reconcile with theme.
 const styles = EditorView.baseTheme({
-  '& .cm-task-item': {
-    paddingLeft: '4px',
-    paddingRight: '8px',
+  '& .cm-task': {
+    color: getToken('extend.colors.blue.500'),
+  },
+  '& .cm-task-checkbox': {
+    marginLeft: '4px',
+    marginRight: '4px',
   },
 });
 
 class CheckboxWidget extends WidgetType {
-  constructor(
-    private readonly _pos: number,
-    private _checked: boolean,
-    private readonly _indent: number,
-    private readonly _onCheck?: (check: boolean) => void,
-  ) {
+  constructor(private _checked: boolean) {
     super();
   }
 
-  override eq(other: CheckboxWidget) {
-    return this._pos === other._pos && 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.className = 'cm-task-checkbox';
     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() {
@@ -61,61 +56,56 @@ class CheckboxWidget extends WidgetType {
   }
 }
 
+const checkedDecoration = Decoration.replace({ widget: new CheckboxWidget(true) });
+const uncheckedDecoration = Decoration.replace({ widget: new CheckboxWidget(false) });
+
+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) => {
+        if (node.name === 'TaskMarker') {
+          // Check if cursor is inside text.
+          if (cursor < node.from || cursor > node.to) {
+            const checked = state.doc.sliceString(node.from + 1, node.to - 1) === 'x';
+            builder.add(node.from - 2, node.from - 1, Decoration.mark({ class: 'cm-task' }));
+            builder.add(node.from, node.to, checked ? checkedDecoration : uncheckedDecoration);
+          }
+        }
+      },
+      from,
+      to,
+    });
+  }
+
+  return builder.finish();
+};
+
 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(
-          pos,
-          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(
-    class {
-      tasks: DecorationSet;
-      constructor(view: EditorView) {
-        this.tasks = taskMatcher.createDeco(view);
-      }
-
-      update(update: ViewUpdate) {
-        this.tasks = taskMatcher.updateDeco(update, this.tasks);
-      }
-    },
-    {
-      decorations: (value) => value.tasks,
-      provide: (plugin) =>
-        EditorView.atomicRanges.of((view) => {
-          return view.plugin(plugin)?.tasks || Decoration.none;
-        }),
-    },
-  );
-
-  return [tasks, styles];
+  return [
+    ViewPlugin.fromClass(
+      class {
+        decorations: DecorationSet;
+
+        constructor(view: EditorView) {
+          this.decorations = buildDecorations(view);
+        }
+
+        update(update: ViewUpdate) {
+          if (update.docChanged || update.viewportChanged || update.selectionSet) {
+            this.decorations = buildDecorations(update.view);
+          }
+        }
+      },
+      {
+        decorations: (v) => v.decorations,
+      },
+    ),
+    styles,
+  ];
 };

package/src/extensions/yjs/cursor.ts

@@ -0,0 +1,22 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import * as Y from 'yjs';
+
+import { arrayToString, stringToArray } from '@dxos/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 ??
+      0
+    );
+  },
+});

package/src/extensions/yjs/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+export * from './yjs';

package/src/{hooks → extensions}/yjs/yjs.test.ts

@@ -2,20 +2,17 @@
 // Copyright 2024 DXOS.org
 //
 
-import { effect } from '@preact/signals-react';
 import { expect } from 'chai';
 import * as Y from 'yjs';
 
-import { Trigger } from '@dxos/async';
-import { Expando, setGlobalAutomergePreference, TextObject } from '@dxos/echo-schema';
-import { registerSignalFactory } from '@dxos/echo-signals';
+import { TextObject } from '@dxos/echo-schema';
 import { describe, test } from '@dxos/test';
 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));
@@ -35,25 +32,4 @@ describe('YJS', () => {
       expect(obj.text.substring(cursor!.index)).to.equal('world');
     }
   });
-
-  // TODO(burdon): Test deleting end character.
-
-  test.skip('effect', async () => {
-    setGlobalAutomergePreference(true);
-    registerSignalFactory();
-    const obj = new Expando({ comments: [] });
-
-    const trigger = new Trigger();
-    const unsubscribe = effect(() => {
-      // TODO(burdon): BUG: doesn't work with YJS.
-      console.log(obj.comments);
-      if (obj.comments.length > 0) {
-        trigger.wake();
-      }
-    });
-
-    obj.comments.push({ message: 'hello' });
-    await trigger.wait();
-    unsubscribe();
-  });
 });

package/src/extensions/yjs/yjs.ts

@@ -0,0 +1,16 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { yCollab } from 'y-codemirror.next';
+import type * as YP from 'y-protocols/awareness';
+
+import type { YText } from '@dxos/text-model';
+
+import { cursorConverter } from './cursor';
+import { Cursor } from '../cursor';
+
+export const yjs = (content: YText, awareness?: YP.Awareness) => [
+  Cursor.converter.of(cursorConverter(content)),
+  yCollab(content, awareness),
+];

package/src/hooks/automerge.ts

@@ -0,0 +1,53 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import get from 'lodash.get';
+
+import { type AutomergeTextCompat, getRawDoc } from '@dxos/echo-schema';
+import { isNotNullOrUndefined } from '@dxos/util';
+
+import { SpaceAwarenessProvider } from './awareness-provider';
+import { type EditorModel, modelState } from './defs';
+import { type UseTextModelProps } from './useTextModel';
+import { automerge, awareness, AwarenessProvider } from '../extensions';
+import { cursorColor } from '../styles';
+
+export const createAutomergeModel = ({ space, identity, text }: UseTextModelProps): EditorModel => {
+  const obj = text as any as AutomergeTextCompat;
+  const doc = getRawDoc(obj, [obj.field]);
+
+  const awarenessProvider =
+    space &&
+    new SpaceAwarenessProvider({
+      space,
+      channel: `automerge.awareness.${obj.id}`,
+      info: {
+        displayName: identity?.profile?.displayName ?? '',
+        color: cursorColor.color,
+        lightColor: cursorColor.light,
+      },
+      peerId: identity?.identityKey.toHex() ?? 'Anonymous',
+    });
+
+  const model: EditorModel = {
+    id: obj.id,
+    content: doc,
+    text: () => get(doc.handle.docSync(), doc.path),
+    // TODO(burdon): https://automerge.org/automerge/api-docs/js/functions/next.getCursor.html
+    extension: [
+      modelState.init(() => model),
+      automerge({ handle: doc.handle, path: doc.path }),
+      awarenessProvider && AwarenessProvider.of(awarenessProvider),
+      awareness(),
+    ].filter(isNotNullOrUndefined),
+    peer: identity
+      ? {
+          id: identity.identityKey.toHex(),
+          name: identity.profile?.displayName,
+        }
+      : undefined,
+  };
+
+  return model;
+};

package/src/hooks/awareness-provider.ts

@@ -0,0 +1,120 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { DeferredTask, Event, sleep } from '@dxos/async';
+import { Context } from '@dxos/context';
+import { invariant } from '@dxos/invariant';
+import { log } from '@dxos/log';
+import { type Space } from '@dxos/react-client/echo';
+import { type GossipMessage } from '@dxos/react-client/mesh';
+
+import { type AwarenessInfo, type AwarenessPosition, type AwarenessProvider, type AwarenessState } from '../extensions';
+
+type ProtocolMessage =
+  | {
+      kind: 'query';
+    }
+  | {
+      kind: 'post';
+      state: AwarenessState;
+    };
+
+const DEBOUNCE_INTERVAL = 100; // ms
+
+export type AwarenessProviderParams = {
+  space: Space;
+  channel: string;
+  peerId: string;
+  info: AwarenessInfo;
+};
+
+export class SpaceAwarenessProvider implements AwarenessProvider {
+  public readonly remoteStateChange = new Event<void>();
+
+  private readonly _remoteStates = new Map<string, AwarenessState>();
+
+  private readonly _space: Space;
+  private readonly _channel: string;
+  private readonly _peerId: string;
+  private readonly _info: AwarenessInfo;
+
+  private _localState?: AwarenessState;
+  private _postTask?: DeferredTask;
+  private _ctx?: Context;
+
+  constructor(params: AwarenessProviderParams) {
+    this._space = params.space;
+    this._channel = params.channel;
+    this._peerId = params.peerId;
+    this._info = params.info;
+  }
+
+  open() {
+    this._ctx = new Context();
+    this._postTask = new DeferredTask(this._ctx, async () => {
+      if (this._localState) {
+        await this._space.postMessage(this._channel, {
+          kind: 'post',
+          state: this._localState,
+        } satisfies ProtocolMessage);
+
+        await sleep(DEBOUNCE_INTERVAL);
+      }
+    });
+
+    const unsubscribe = this._space.listen(this._channel, (message: GossipMessage) => {
+      switch (message.payload.kind) {
+        case 'query': {
+          this._handleQueryMessage();
+          break;
+        }
+        case 'post': {
+          this._handlePostMessage(message.payload);
+          break;
+        }
+      }
+    });
+    this._ctx.onDispose(unsubscribe);
+
+    void this._space
+      .postMessage(this._channel, {
+        kind: 'query',
+      } satisfies ProtocolMessage)
+      .catch((err) => {
+        log.debug('failed to query awareness', { err });
+      });
+  }
+
+  close() {
+    void this._ctx?.dispose();
+    this._ctx = undefined;
+    this._postTask = undefined;
+  }
+
+  update(position: AwarenessPosition | undefined): void {
+    invariant(this._postTask);
+    this._localState = {
+      peerId: this._peerId,
+      position,
+      info: this._info,
+    };
+
+    this._postTask.schedule();
+  }
+
+  getRemoteStates(): AwarenessState[] {
+    return Array.from(this._remoteStates.values());
+  }
+
+  private _handleQueryMessage() {
+    invariant(this._postTask);
+    this._postTask.schedule();
+  }
+
+  private _handlePostMessage(message: ProtocolMessage) {
+    invariant(message.kind === 'post');
+    this._remoteStates.set(message.state.peerId, message.state);
+    this.remoteStateChange.emit();
+  }
+}

package/src/hooks/defs.ts

@@ -0,0 +1,47 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { type Extension, StateField } from '@codemirror/state';
+import type * as YP from 'y-protocols/awareness';
+
+import { type DocAccessor } from '@dxos/echo-schema';
+import type { YText, YXmlFragment } from '@dxos/text-model';
+
+// Runtime data structure.
+export type Range = {
+  from: number;
+  to: number;
+};
+
+// Persistent data structure.
+export type Comment = {
+  id: string;
+  cursor?: string;
+};
+
+export type EditorModel = {
+  id: string;
+  text: () => string;
+  extension?: Extension;
+
+  // TODO(burdon): Remove.
+  content: string | YText | YXmlFragment | DocAccessor;
+
+  // TODO(burdon): Move into extension.
+  awareness?: YP.Awareness;
+
+  // TODO(burdon): Remove.
+  peer?: {
+    id: string;
+    name?: string;
+  };
+};
+
+/**
+ * State field makes the model available to other extensions.
+ */
+export const modelState = StateField.define<EditorModel | undefined>({
+  create: () => undefined,
+  update: (model) => model,
+});

package/src/hooks/index.ts

@@ -2,5 +2,10 @@
 // Copyright 2023 DXOS.org
 //
 
-export * from './useTextModel';
+export * from './automerge';
+export * from './awareness-provider';
+export * from './defs';
 export * from './yjs';
+
+export * from './useTextEditor';
+export * from './useTextModel';

package/src/hooks/useTextEditor.ts

@@ -0,0 +1,29 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { type EditorView } from '@codemirror/view';
+import { type RefCallback, useState } from 'react';
+
+/**
+ * Hook for accessing the editor view.
+ *
+ * ```tsx
+ * const Test = () => {
+ *   const [editorRef, editorView] = useTextEditor();
+ *   useEffect(() => {
+ *     editorView?.focus();
+ *   }, [editorView]);
+ *   return <TextEditor ref={editorRef} />;
+ * };
+ * ```
+ */
+export const useTextEditor = (): [RefCallback<EditorView | null>, EditorView | null] => {
+  const [view, setView] = useState<EditorView | null>(null);
+  return [
+    (ref: EditorView | null) => {
+      setView(ref);
+    },
+    view,
+  ];
+};