@dxos/react-ui-editor 0.3.11-main.c8e9429 → 0.3.11-main.cb5abf5

package/src/extensions/{tasklist.ts → markdown/tasklist.ts}

@@ -6,6 +6,19 @@ 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': {
+    color: getToken('extend.colors.blue.500'),
+  },
+  '& .cm-task-checkbox': {
+    marginLeft: '4px',
+    marginRight: '4px',
+  },
+});
+
 class CheckboxWidget extends WidgetType {
   constructor(private _checked: boolean) {
     super();
@@ -17,6 +30,7 @@ class CheckboxWidget extends WidgetType {
 
   override toDOM(view: EditorView) {
     const input = document.createElement('input');
+    input.className = 'cm-task-checkbox';
     input.type = 'checkbox';
     input.checked = this._checked;
     if (view.state.readOnly) {
@@ -42,36 +56,8 @@ class CheckboxWidget extends WidgetType {
   }
 }
 
-const checkedDeco = Decoration.replace({ widget: new CheckboxWidget(true) });
-const uncheckedDeco = Decoration.replace({ widget: new CheckboxWidget(false) });
-
-export type TasklistOptions = {};
-
-export const tasklist = (options: TasklistOptions = {}) => {
-  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,
-      // TODO(burdon): Is this still required?
-      provide: (plugin) =>
-        EditorView.atomicRanges.of((view) => {
-          return view.plugin(plugin)?.decorations || Decoration.none;
-        }),
-    },
-  );
-};
+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>();
@@ -81,10 +67,13 @@ const buildDecorations = (view: EditorView): DecorationSet => {
   for (const { from, to } of view.visibleRanges) {
     syntaxTree(state).iterate({
       enter: (node) => {
-        // Check if cursor is inside text.
-        if (node.name === 'TaskMarker' && (cursor < node.from || cursor > node.to)) {
-          const checked = state.doc.sliceString(node.from + 1, node.to - 1) === 'x';
-          builder.add(node.from, node.to, checked ? checkedDeco : uncheckedDeco);
+        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,
@@ -94,3 +83,28 @@ const buildDecorations = (view: EditorView): DecorationSet => {
 
   return builder.finish();
 };
+
+export type TasklistOptions = {};
+
+export const tasklist = (options: TasklistOptions = {}) => {
+  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: (value) => value.decorations,
+      },
+    ),
+    styles,
+  ];
+};

package/src/extensions/mention.ts

@@ -9,18 +9,25 @@ export type MentionOptions = {
   onSearch: (text: string) => string[];
 };
 
+// TODO(burdon): Can only have a single autocompletion. Merge configuration with autocomplete.
 export const mention = ({ onSearch }: MentionOptions): Extension => {
   return autocompletion({
+    // TODO(burdon): Not working.
+    activateOnTyping: true,
+    // activateOnTypingDelay: 100,
+    // selectOnOpen: true,
     closeOnBlur: false, // For debugging.
+    // defaultKeymap: false,
+    icons: false,
     override: [
       (context: CompletionContext): CompletionResult | null => {
+        console.log(context);
+
         const match = context.matchBefore(/@(\w+)?/);
         if (!match || (match.from === match.to && !context.explicit)) {
           return null;
         }
 
-        console.log(match);
-
         return {
           from: match.from,
           options: onSearch(match.text.slice(1).toLowerCase()).map((value) => ({ label: `@${value}` })),

package/src/extensions/outliner.ts

@@ -0,0 +1,12 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { type Extension } from '@codemirror/state';
+
+export type OutlinerOptions = {};
+
+// TODO(burdon): Experimental component: multiple hierarchical draggable editor sections.
+export const outliner = (options: OutlinerOptions = {}): Extension => {
+  return [];
+};

package/src/hooks/awareness-provider.ts

@@ -29,9 +29,10 @@ export type AwarenessProviderParams = {
   info: AwarenessInfo;
 };
 
+/**
+ * Receives and broadcasts profile and cursor position.
+ */
 export class SpaceAwarenessProvider implements AwarenessProvider {
-  public readonly remoteStateChange = new Event<void>();
-
   private readonly _remoteStates = new Map<string, AwarenessState>();
 
   private readonly _space: Space;
@@ -39,9 +40,11 @@ export class SpaceAwarenessProvider implements AwarenessProvider {
   private readonly _peerId: string;
   private readonly _info: AwarenessInfo;
 
-  private _localState?: AwarenessState;
-  private _postTask?: DeferredTask;
   private _ctx?: Context;
+  private _postTask?: DeferredTask;
+  private _localState?: AwarenessState;
+
+  public readonly remoteStateChange = new Event<void>();
 
   constructor(params: AwarenessProviderParams) {
     this._space = params.space;
@@ -63,19 +66,20 @@ export class SpaceAwarenessProvider implements AwarenessProvider {
       }
     });
 
-    const unsubscribe = this._space.listen(this._channel, (message: GossipMessage) => {
-      switch (message.payload.kind) {
-        case 'query': {
-          this._handleQueryMessage();
-          break;
+    this._ctx.onDispose(
+      this._space.listen(this._channel, (message: GossipMessage) => {
+        switch (message.payload.kind) {
+          case 'query': {
+            this._handleQueryMessage();
+            break;
+          }
+          case 'post': {
+            this._handlePostMessage(message.payload);
+            break;
+          }
         }
-        case 'post': {
-          this._handlePostMessage(message.payload);
-          break;
-        }
-      }
-    });
-    this._ctx.onDispose(unsubscribe);
+      }),
+    );
 
     void this._space
       .postMessage(this._channel, {
@@ -92,6 +96,10 @@ export class SpaceAwarenessProvider implements AwarenessProvider {
     this._postTask = undefined;
   }
 
+  getRemoteStates(): AwarenessState[] {
+    return Array.from(this._remoteStates.values());
+  }
+
   update(position: AwarenessPosition | undefined): void {
     invariant(this._postTask);
     this._localState = {
@@ -103,10 +111,6 @@ export class SpaceAwarenessProvider implements AwarenessProvider {
     this._postTask.schedule();
   }
 
-  getRemoteStates(): AwarenessState[] {
-    return Array.from(this._remoteStates.values());
-  }
-
   private _handleQueryMessage() {
     invariant(this._postTask);
     this._postTask.schedule();

package/src/hooks/defs.ts

@@ -0,0 +1,42 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { type Extension, StateField } from '@codemirror/state';
+
+import { type DocAccessor } from '@dxos/echo-schema';
+
+// 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 | DocAccessor;
+
+  // 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,8 +2,10 @@
 // Copyright 2023 DXOS.org
 //
 
-export * from './automerge';
 export * from './awareness-provider';
-export * from './yjs';
+export * from './defs';
 
+export * from './useActionHandler';
+export * from './useEditorView';
+export * from './useTextEditor';
 export * from './useTextModel';

package/src/hooks/useActionHandler.ts

@@ -0,0 +1,62 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import type { EditorView } from '@codemirror/view';
+
+import type { ToolbarProps } from '../components';
+import {
+  createComment,
+  insertCodeblock,
+  insertTable,
+  setHeading,
+  toggleBold,
+  toggleItalic,
+  toggleList,
+  toggleStrikethrough,
+} from '../extensions';
+
+export const useActionHandler = (view?: EditorView | null): ToolbarProps['onAction'] => {
+  return (action) => {
+    if (!view) {
+      return;
+    }
+
+    switch (action.type) {
+      case 'heading':
+        setHeading(parseInt(action.data))(view);
+        break;
+
+      case 'bold':
+        toggleBold(view);
+        break;
+      case 'italic':
+        toggleItalic(view);
+        break;
+      case 'strikethrough':
+        toggleStrikethrough(view);
+        break;
+
+      case 'list':
+        toggleList(view);
+        break;
+
+      case 'codeblock':
+        insertCodeblock(view);
+        break;
+      case 'table':
+        insertTable(view);
+        break;
+
+      case 'comment':
+        createComment(view);
+        break;
+    }
+
+    // TODO(burdon): Hack otherwise remains on heading selector.
+    setTimeout(() => {
+      view.focus();
+      view.dispatch({ selection: view.state.selection });
+    });
+  };
+};

package/src/hooks/useEditorView.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] = useEditorView();
+ *   useEffect(() => {
+ *     editorView?.focus();
+ *   }, [editorView]);
+ *   return <TextEditor ref={editorRef} />;
+ * };
+ * ```
+ */
+export const useEditorView = (): [RefCallback<EditorView | null>, EditorView | null] => {
+  const [view, setView] = useState<EditorView | null>(null);
+  return [
+    (ref: EditorView | null) => {
+      setView(ref);
+    },
+    view,
+  ];
+};

package/src/hooks/useTextEditor.ts

@@ -0,0 +1,153 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import {
+  EditorSelection,
+  EditorState,
+  type EditorStateConfig,
+  type Extension,
+  type StateEffect,
+} from '@codemirror/state';
+import { EditorView } from '@codemirror/view';
+import { type RefObject, useEffect, useRef, useState } from 'react';
+
+import { log } from '@dxos/log';
+import { type ThemeMode } from '@dxos/react-ui';
+import { isNotFalsy } from '@dxos/util';
+
+import { type ThemeStyles } from '..//styles';
+import { defaultTheme } from '../themes';
+import { logChanges } from '../util';
+
+export type UseTextEditorOptions = {
+  autoFocus?: boolean;
+  scrollTo?: StateEffect<any>;
+  debug?: boolean;
+} & EditorStateConfig;
+
+export type UseTextEditor = {
+  parentRef: RefObject<HTMLDivElement>;
+  view?: EditorView;
+};
+
+/**
+ * Hook for creating editor.
+ */
+export const useTextEditor = ({
+  autoFocus,
+  scrollTo,
+  debug,
+  doc,
+  selection,
+  extensions,
+}: UseTextEditorOptions = {}): UseTextEditor => {
+  const onUpdate = useRef<() => void>();
+  const [view, setView] = useState<EditorView>();
+  const parentRef = useRef<HTMLDivElement>(null);
+  useEffect(() => {
+    if (parentRef.current) {
+      // https://codemirror.net/docs/ref/#state.EditorStateConfig
+      const state = EditorState.create({
+        doc,
+        selection,
+        extensions: [
+          // TODO(burdon): Doesn't catch errors in keymap functions.
+          EditorView.exceptionSink.of((err) => {
+            log.catch(err);
+          }),
+          extensions,
+          EditorView.updateListener.of(() => {
+            onUpdate.current?.();
+          }),
+        ].filter(isNotFalsy),
+      });
+
+      // https://codemirror.net/docs/ref/#view.EditorViewConfig
+      const view = new EditorView({
+        parent: parentRef.current,
+        scrollTo,
+        state,
+        // NOTE: Uncomment to debug/monitor all transactions.
+        // https://codemirror.net/docs/ref/#view.EditorView.dispatch
+        dispatchTransactions: (trs, view) => {
+          if (debug) {
+            logChanges(trs);
+          }
+          view.update(trs);
+        },
+      });
+
+      setView(view);
+    }
+
+    return () => {
+      view?.destroy();
+    };
+  }, [parentRef]);
+
+  useEffect(() => {
+    if (view) {
+      // Select end of line if not specified.
+      if (!selection && !view.state.selection.main.anchor) {
+        selection = EditorSelection.single(view.state.doc.line(1).to);
+      }
+
+      // Set selection after first update (since content may rerender on focus).
+      // TODO(burdon): BUG on first render may appear in middle of formatted heading.
+      // TODO(burdon): Make invisible until first render?
+      if (selection || scrollTo) {
+        onUpdate.current = () => {
+          onUpdate.current = undefined;
+          view.dispatch({ selection, effects: scrollTo && [scrollTo], scrollIntoView: !scrollTo });
+        };
+      }
+
+      if (autoFocus) {
+        view.focus();
+      }
+    }
+  }, [view, autoFocus, selection, scrollTo]);
+
+  return { parentRef, view };
+};
+
+// TODO(burdon): Factor out extension factories.
+
+export type DataExtensionsOptions = {
+  readonly?: boolean;
+};
+
+// TODO(burdon): Pass in TextObject (remove model).
+export const createDataExtensions = ({ readonly = false } = {}): Extension => {
+  return [
+    //
+    EditorState.readOnly.of(readonly),
+    EditorView.editable.of(!readonly),
+  ];
+};
+
+export type ThemeExtensionsOptions = {
+  theme?: ThemeStyles;
+  themeMode?: ThemeMode;
+  lineWrap?: boolean;
+  slots?: {
+    editor?: {
+      className?: string;
+    };
+    content?: {
+      className?: string;
+    };
+  };
+};
+
+export const createThemeExtensions = ({ theme, themeMode, slots }: ThemeExtensionsOptions = {}): Extension => {
+  return [
+    //
+    EditorView.baseTheme(defaultTheme),
+    theme && EditorView.theme(theme),
+    EditorView.darkTheme.of(themeMode === 'dark'),
+    EditorView.editorAttributes.of({ class: slots?.editor?.className ?? '' }),
+    EditorView.contentAttributes.of({ class: slots?.content?.className ?? '' }),
+  ].filter(isNotFalsy);
+};

package/src/hooks/useTextModel.ts

@@ -2,55 +2,19 @@
 // Copyright 2023 DXOS.org
 //
 
-import { StateField, type Extension } from '@codemirror/state';
-import { useEffect, useState } from 'react';
-import type * as YP from 'y-protocols/awareness';
+import get from 'lodash.get';
+import { type Dispatch, type SetStateAction, useEffect, useState } from 'react';
 
-import { isAutomergeObject, type DocAccessor, type Space, type TextObject } from '@dxos/react-client/echo';
+import { generateName } from '@dxos/display-name';
+import { type AutomergeTextCompat, getRawDoc } from '@dxos/echo-schema';
+import { invariant } from '@dxos/invariant';
+import { isAutomergeObject, 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 { createAutomergeModel } from './automerge';
-import { createYjsModel } from './yjs';
-
-// TODO(burdon): Factor out defs.
-
-/**
- * State field makes the model available to other extensions.
- */
-export const modelState = StateField.define<EditorModel | undefined>({
-  create: () => undefined,
-  update: (model) => model,
-});
-
-export type Range = {
-  from: number;
-  to: number;
-};
-
-export type CommentRange = {
-  id: string;
-  cursor: string; // TODO(burdon): Rename range.
-};
-
-// 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;
-
-  // TODO(burdon): Move into extension.
-  awareness?: YP.Awareness;
-
-  // TODO(burdon): Remove.
-  peer?: {
-    id: string;
-    name?: string;
-  };
-};
+import { SpaceAwarenessProvider } from './awareness-provider';
+import { type EditorModel, modelState } from './defs';
+import { automerge, awareness } from '../extensions';
+import { cursorColor } from '../styles';
 
 // TODO(burdon): Remove space/identity dependency. Define interface for the framework re content and presence.
 export type UseTextModelProps = {
@@ -59,8 +23,6 @@ export type UseTextModelProps = {
   text?: TextObject;
 };
 
-// TODO(burdon): Remove YJS/Automerge deps (from UI component -- create abstraction; incl. all ECHO/Space deps).
-// TODO(wittjosiah): Factor out to common package? @dxos/react-client?
 export const useTextModel = (props: UseTextModelProps): EditorModel | undefined => {
   const { identity, space, text } = props;
   const [model, setModel] = useState<EditorModel | undefined>();
@@ -68,13 +30,61 @@ export const useTextModel = (props: UseTextModelProps): EditorModel | undefined
   return model;
 };
 
-const createModel = (props: UseTextModelProps) => {
-  const { text } = props;
-  if (isAutomergeObject(text)) {
-    return createAutomergeModel(props);
-  } else if (text?.doc) {
-    return createYjsModel(props);
-  } else {
-    return undefined;
+/**
+ * For use primarily in stories & tests so the dependence on TextObject can be avoided.
+ * @param id
+ * @param defaultContent
+ */
+export const useInMemoryTextModel = ({
+  id,
+  defaultContent,
+}: {
+  id: string;
+  defaultContent?: string;
+}): EditorModel & { setContent: Dispatch<SetStateAction<string>> } => {
+  const [content, setContent] = useState(defaultContent ?? '');
+  return { id, content, setContent, text: () => content };
+};
+
+const createModel = ({ space, identity, text }: UseTextModelProps) => {
+  invariant(isAutomergeObject(text));
+  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 ? identity.profile?.displayName ?? generateName(identity.identityKey.toHex()) : undefined,
+        color: cursorColor.color,
+        lightColor: cursorColor.light,
+      },
+      peerId: identity?.identityKey.toHex() ?? 'Anonymous',
+    });
+
+  const extensions = [
+    //
+    modelState.init(() => model),
+    automerge({ handle: doc.handle, path: doc.path }),
+  ];
+  if (awarenessProvider) {
+    extensions.push(awareness(awarenessProvider));
   }
+
+  const model: EditorModel = {
+    id: obj.id,
+    content: doc,
+    text: () => get(doc.handle.docSync(), doc.path),
+    extension: extensions,
+    peer: identity
+      ? {
+          id: identity.identityKey.toHex(),
+          name: identity.profile?.displayName,
+        }
+      : undefined,
+  };
+
+  return model;
 };

package/src/index.ts

@@ -5,7 +5,7 @@
 export { TextKind } from '@dxos/protocols/proto/dxos/echo/model/text';
 export { Doc, YText, YXmlFragment } from '@dxos/text-model';
 export { type Extension } from '@codemirror/state';
-export { type EditorView } from '@codemirror/view';
+export { type EditorView, keymap } from '@codemirror/view';
 
 export * from './components';
 export * from './extensions';