@dxos/react-ui-editor 0.3.11-main.9bacd9f → 0.3.11-main.9c729f3

package/src/{components/TextEditor/extensions → extensions}/comments.ts

@@ -16,6 +16,7 @@ import {
   WidgetType,
   type Rect,
 } from '@codemirror/view';
+import get from 'lodash.get';
 import sortBy from 'lodash.sortby';
 
 import { debounce } from '@dxos/async';
@@ -23,10 +24,10 @@ import { invariant } from '@dxos/invariant';
 import { log } from '@dxos/log';
 import { nonNullable } from '@dxos/util';
 
-import { callbackWrapper } from './util';
-import { type CommentRange, type EditorModel, modelState, type Range } from '../../../hooks';
+import { type CommentRange, type EditorModel, type Range } from '../hooks';
+import { tokens } from '../styles';
+import { callbackWrapper, CursorConverter } from '../util';
 
-// TODO(burdon): Handle scroll to.
 // 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?
 
@@ -42,10 +43,10 @@ const styles = EditorView.baseTheme({
     backgroundColor: 'orange',
   },
   '& .cm-comment': {
-    backgroundColor: 'yellow',
+    backgroundColor: get(tokens, 'extend.colors.yellow.50'),
   },
   '& .cm-comment-active': {
-    backgroundColor: 'orange',
+    backgroundColor: get(tokens, 'extend.colors.yellow.100'),
   },
 });
 
@@ -71,9 +72,22 @@ export type CommentsState = CommentSelected & {
   ranges: ExtendedCommentRange[];
 };
 
+export const setFocus = (view: EditorView, thread: string) => {
+  const range = view.state.field(commentsStateField).ranges.find((range) => range.id === thread);
+  if (!range) {
+    return;
+  }
+
+  view.dispatch({
+    effects: setSelection.of({ active: thread }),
+    selection: { anchor: range.from },
+    scrollIntoView: true,
+  });
+};
+
 export const setCommentRange = StateEffect.define<{ model: EditorModel; comments: CommentRange[] }>();
 
-const setSelection = StateEffect.define<CommentSelected>();
+export const setSelection = StateEffect.define<CommentSelected>();
 
 const setCommentState = StateEffect.define<CommentsState>();
 
@@ -85,6 +99,8 @@ const setCommentState = StateEffect.define<CommentsState>();
 const commentsStateField = StateField.define<CommentsState>({
   create: () => ({ ranges: [] }),
   update: (value, tr) => {
+    const cursorConverter = tr.state.facet(CursorConverter);
+
     for (const effect of tr.effects) {
       // Update selection.
       if (effect.is(setSelection)) {
@@ -93,11 +109,13 @@ const commentsStateField = StateField.define<CommentsState>({
 
       // Update range from store.
       if (effect.is(setCommentRange)) {
-        const { model, comments } = effect.value;
-        const ranges: ExtendedCommentRange[] = comments.map((comment) => {
-          const range = model.getRangeFromCursor!(comment.cursor)!;
-          return { ...comment, ...range };
-        });
+        const { comments } = effect.value;
+        const ranges: ExtendedCommentRange[] = comments
+          .map((comment) => {
+            const range = getRangeFromCursor(cursorConverter, comment.cursor);
+            return range && { ...comment, ...range };
+          })
+          .filter(nonNullable);
 
         return { ...value, ranges };
       }
@@ -202,14 +220,15 @@ export const comments = (options: CommentsOptions = {}): Extension => {
    * Create comment thread action.
    */
   const createCommentThread: Command = (view) => {
+    const cursorConverter = view.state.facet(CursorConverter);
+
     invariant(options.onCreate);
     const { head, from, to } = view.state.selection.main;
     if (from === to) {
       return false;
     }
 
-    const model = view.state.field(modelState);
-    const relPos = model?.getCursorFromRange?.({ from, to });
+    const relPos = getCursorFromRange(cursorConverter, { from, to });
     if (relPos) {
       // Create thread via callback.
       const id = callbackWrapper(options.onCreate)(relPos);
@@ -322,27 +341,27 @@ export const comments = (options: CommentsOptions = {}): Extension => {
     // Monitor cursor movement and text updates.
     // TODO(burdon): Is there a better (finer grained) way to do this?
     //
-    EditorView.updateListener.of(({ view, state, startState, changes }) => {
+    EditorView.updateListener.of(({ view, state, changes }) => {
+      const cursorConverter = view.state.facet(CursorConverter);
+
       //
       // Test if need to recompute indexed range if document changes before the end of the range.
       //
       {
         let mod = false;
-        const model = state.field(modelState);
         const { active, ranges } = state.field(commentsStateField);
         changes.iterChanges((from, to, from2, to2) => {
-          invariant(model);
           ranges.forEach((range) => {
             if (from2 === to2) {
-              const newRange = model.getRangeFromCursor!(range.cursor);
-              if (newRange.to - newRange.from === 0) {
+              const newRange = getRangeFromCursor(cursorConverter, range.cursor);
+              if (!newRange || newRange.to - newRange.from === 0) {
                 // TODO(burdon): Delete range if empty.
                 log.info('deleted comment', { thread: range.id });
               }
             }
 
             if (from <= range.to) {
-              const newRange = model.getRangeFromCursor!(range.cursor);
+              const newRange = getRangeFromCursor(cursorConverter, range.cursor);
               Object.assign(range, newRange);
               mod = true;
             }
@@ -387,3 +406,16 @@ 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 && to ? { from, to } : undefined;
+};

package/src/{components/TextEditor/extensions → extensions}/hr.ts

@@ -13,7 +13,7 @@ import {
 } from '@codemirror/view';
 import get from 'lodash.get';
 
-import { tokens } from '../../../styles';
+import { tokens } from '../styles';
 
 // TODO(burdon): Reconcile with theme.
 const styles = EditorView.baseTheme({

package/src/{components/TextEditor/extensions → extensions}/index.ts

@@ -3,6 +3,8 @@
 //
 
 export * from './autocomplete';
+export * from './automerge';
+export * from './awareness';
 export * from './basic';
 export * from './blast';
 export * from './code';
@@ -17,3 +19,4 @@ export * from './mermaid';
 export * from './table';
 export * from './tasklist';
 export * from './typewriter';
+export * from './yjs';

package/src/{components/TextEditor/extensions → extensions}/markdown/highlight.ts

@@ -19,7 +19,7 @@ import {
   mark,
   strikethrough,
   tokens,
-} from '../../../../styles';
+} from '../../styles';
 
 /**
  * Custom tags defined and processed by the GFM lezer extension.

package/src/{components/TextEditor/extensions → extensions}/typewriter.ts

@@ -19,7 +19,7 @@ const defaultItems = ['hello world!', 'this is a test.', 'this is [DXOS](https:/
  */
 export const typewriter = ({ delay = 75, items = defaultItems }: DemoOptions = {}): Extension => {
   let t: any;
-  let idx = 0;
+  let idx = 0; // TODO(burdon): Make global.
 
   return [
     keymap.of([

package/src/extensions/yjs/cursor.ts

@@ -0,0 +1,21 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import * as Y from 'yjs';
+
+import { arrayToString, stringToArray } from '@dxos/util';
+
+import { type CursorConverter } from '../../util';
+
+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,13 +2,10 @@
 // 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';
 
@@ -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 { CursorConverter } from '../../util';
+
+export const yjs = (content: YText, awareness?: YP.Awareness) => [
+  CursorConverter.of(cursorConverter(content)),
+  yCollab(content, awareness),
+];

package/src/hooks/automerge.ts

@@ -0,0 +1,52 @@
+//
+// 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, 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/index.ts

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

package/src/hooks/useTextModel.ts

@@ -2,36 +2,22 @@
 // Copyright 2023 DXOS.org
 //
 
-import { type Extension, StateField } from '@codemirror/state';
-import get from 'lodash.get';
+import { StateField, type Extension } from '@codemirror/state';
 import { useEffect, useState } from 'react';
-import { yCollab } from 'y-codemirror.next';
-import type * as awarenessProtocol from 'y-protocols/awareness';
-import * as Y from 'yjs';
+import type * as YP from 'y-protocols/awareness';
 
-import { invariant } from '@dxos/invariant';
-import {
-  type DocAccessor,
-  type Space,
-  type TextObject,
-  type AutomergeTextCompat,
-  getRawDoc,
-  isActualAutomergeObject,
-} from '@dxos/react-client/echo';
+import { isAutomergeObject, type DocAccessor, type Space, type TextObject } from '@dxos/react-client/echo';
 import { type Identity } from '@dxos/react-client/halo';
 import type { YText, YXmlFragment } from '@dxos/text-model';
-import { arrayToString, stringToArray } from '@dxos/util';
 
-import { automergePlugin } from './automerge';
-import { SpaceAwarenessProvider } from './yjs';
+import { createAutomergeModel } from './automerge';
+import { createYjsModel } from './yjs';
 
-// TODO(burdon): Move.
-type Awareness = awarenessProtocol.Awareness;
+// TODO(burdon): Factor out defs.
 
 /**
  * State field makes the model available to other extensions.
  */
-// TODO(burdon): Use facet?
 export const modelState = StateField.define<EditorModel | undefined>({
   create: () => undefined,
   update: (model) => model,
@@ -44,20 +30,25 @@ export type Range = {
 
 export type CommentRange = {
   id: string;
-  // TODO(burdon): Split into begin/end?
   cursor: string;
 };
 
 // TODO(wittjosiah): Factor out to common package? @dxos/react-client?
 export type EditorModel = {
   id: string;
+  text: () => string;
+  extension?: Extension;
+
   // TODO(burdon): Remove.
   content: string | YText | YXmlFragment | DocAccessor;
-  text: () => string;
+  /**
+   * @deprecated Use CursorConverter.
+   */
   getCursorFromRange?: (value: Range) => string;
-  getRangeFromCursor?: (cursor: string) => Range;
-  extension?: Extension;
-  awareness?: Awareness;
+  getRangeFromCursor?: (cursor: string) => Range | undefined;
+  // TODO(burdon): Move into extension.
+  awareness?: YP.Awareness;
+  // TODO(burdon): Remove.
   peer?: {
     id: string;
     name?: string;
@@ -82,75 +73,11 @@ export const useTextModel = (props: UseTextModelProps): EditorModel | undefined
 
 const createModel = (props: UseTextModelProps) => {
   const { text } = props;
-  if (isActualAutomergeObject(text)) {
+  if (isAutomergeObject(text)) {
     return createAutomergeModel(props);
-  } else {
-    if (!text?.doc) {
-      return undefined;
-    }
-
+  } else if (text?.doc) {
     return createYjsModel(props);
+  } else {
+    return undefined;
   }
 };
-
-const createYjsModel = ({ identity, space, text }: UseTextModelProps): EditorModel => {
-  invariant(text?.doc && text?.content);
-  const provider = space
-    ? new SpaceAwarenessProvider({ space, doc: text.doc, channel: `yjs.awareness.${text.id}` })
-    : undefined;
-
-  const model: EditorModel = {
-    id: text.doc.guid,
-    content: text.content,
-    text: () => text.content!.toString(),
-    // https://github.com/yjs/yjs?tab=readme-ov-file#relative-positions
-    getCursorFromRange: (range: Range) => {
-      const from = Y.encodeRelativePosition(Y.createRelativePositionFromTypeIndex(text.content as YText, range.from));
-      const to = Y.encodeRelativePosition(Y.createRelativePositionFromTypeIndex(text.content as YText, range.to, -1));
-      return [arrayToString(from), arrayToString(to)].join(':');
-    },
-    getRangeFromCursor: (cursor: string) => {
-      const parts = cursor.split(':');
-      const from = Y.createAbsolutePositionFromRelativePosition(
-        Y.decodeRelativePosition(stringToArray(parts[0])),
-        text.doc!,
-      );
-      const to = Y.createAbsolutePositionFromRelativePosition(
-        Y.decodeRelativePosition(stringToArray(parts[1])),
-        text.doc!,
-      );
-      return { from: from!.index, to: to!.index };
-    },
-    extension: [yCollab(text.content as YText, provider?.awareness), modelState.init(() => model)],
-    awareness: provider?.awareness,
-    peer: identity
-      ? {
-          id: identity.identityKey.toHex(),
-          name: identity.profile?.displayName,
-        }
-      : undefined,
-  };
-
-  return model;
-};
-
-const createAutomergeModel = ({ identity, text }: UseTextModelProps): EditorModel => {
-  const obj = text as any as AutomergeTextCompat;
-  const doc = getRawDoc(obj, [obj.field]);
-
-  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: [automergePlugin(doc.handle, doc.path), modelState.init(() => model)],
-    peer: identity
-      ? {
-          id: identity.identityKey.toHex(),
-          name: identity.profile?.displayName,
-        }
-      : undefined,
-  };
-
-  return model;
-};