@dxos/react-ui-editor 0.8.4-main.5ea62a8 → 0.8.4-main.66e292d

package/src/extensions/blocks.ts

@@ -0,0 +1,131 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { RangeSetBuilder } from '@codemirror/state';
+import { Decoration, type DecorationSet, EditorView, ViewPlugin, type ViewUpdate } from '@codemirror/view';
+
+import { mx } from '@dxos/react-ui-theme';
+
+const paragraphBlockPlugin = ViewPlugin.fromClass(
+  class {
+    decorations: DecorationSet;
+
+    constructor(view: EditorView) {
+      this.decorations = this.build(view);
+    }
+
+    update(update: ViewUpdate) {
+      if (update.docChanged || update.viewportChanged) {
+        this.decorations = this.build(update.view);
+      }
+    }
+
+    build({ state }: EditorView) {
+      const builder = new RangeSetBuilder<Decoration>();
+
+      // Helper: commit a block from blockStart to endLine (inclusive).
+      const pushBlock = (fromLine: number, toLine: number) => {
+        // Add line decorations for each line in the block.
+        for (let lineNum = fromLine; lineNum <= toLine; lineNum++) {
+          const line = state.doc.line(lineNum);
+          builder.add(
+            line.from,
+            line.from,
+            Decoration.line({
+              class: mx(
+                'block-line',
+                fromLine === toLine && 'block-single',
+                lineNum === fromLine && 'block-first',
+                lineNum > fromLine && lineNum < toLine && 'block-middle',
+                lineNum === toLine && 'block-last',
+              ),
+            }),
+          );
+        }
+      };
+
+      let blockStart: number | null = null;
+      let consecutiveBlankLines = 0;
+      const totalLines = state.doc.lines;
+      for (let i = 1; i <= totalLines; i++) {
+        const line = state.doc.line(i);
+        const isBlank = /^\s*$/.test(line.text);
+
+        if (!isBlank) {
+          // Reset blank line counter.
+          consecutiveBlankLines = 0;
+          // Start a new block if we're not already in one.
+          if (blockStart === null) {
+            blockStart = i;
+          }
+        } else {
+          // Increment blank line counter.
+          consecutiveBlankLines++;
+
+          // End the current block if we have 2+ consecutive blank lines.
+          if (consecutiveBlankLines >= 2 && blockStart !== null) {
+            pushBlock(blockStart, i - consecutiveBlankLines);
+            blockStart = null;
+          }
+        }
+      }
+
+      // Handle any remaining block at the end of the document.
+      if (blockStart !== null) {
+        // Find the last non-blank line for the block end.
+        let lastNonBlankLine = totalLines;
+        while (lastNonBlankLine >= blockStart) {
+          const line = state.doc.line(lastNonBlankLine);
+          if (!/^\s*$/.test(line.text)) {
+            break;
+          }
+          lastNonBlankLine--;
+        }
+        if (lastNonBlankLine >= blockStart) {
+          pushBlock(blockStart, lastNonBlankLine);
+        }
+      }
+
+      return builder.finish();
+    }
+  },
+  {
+    decorations: (v) => v.decorations,
+  },
+);
+
+export const blocks = () => [
+  paragraphBlockPlugin,
+  EditorView.baseTheme({
+    '.cm-line.block-line': {
+      paddingLeft: '0.75rem',
+      paddingRight: '0.75rem',
+      borderLeft: '1px solid var(--dx-subduedSeparator)',
+      borderRight: '1px solid var(--dx-subduedSeparator)',
+    },
+    '.cm-line.block-single': {
+      border: '1px solid var(--dx-subduedSeparator)',
+      borderRadius: '6px',
+      paddingTop: '0.5rem',
+      paddingBottom: '0.5rem',
+      marginTop: '0.5rem',
+      marginBottom: '0.5rem',
+    },
+    '.cm-line.block-first': {
+      borderTop: '1px solid var(--dx-subduedSeparator)',
+      borderTopLeftRadius: '6px',
+      borderTopRightRadius: '6px',
+      paddingTop: '0.5rem',
+      marginTop: '0.5rem',
+    },
+    '.cm-line.block-middle': {},
+    '.cm-line.block-last': {
+      borderBottom: '1px solid var(--dx-subduedSeparator)',
+      borderBottomLeftRadius: '6px',
+      borderBottomRightRadius: '6px',
+      paddingBottom: '0.5rem',
+      marginBottom: '0.5rem',
+    },
+  }),
+];

package/src/extensions/bookmarks.ts

@@ -0,0 +1,75 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type Extension, Prec, StateEffect, StateField } from '@codemirror/state';
+import { keymap } from '@codemirror/view';
+
+type Bookmark = {
+  id: string;
+  pos: number;
+  name: string;
+};
+
+export const addBookmark = StateEffect.define<Bookmark>();
+export const removeBookmark = StateEffect.define<string>();
+export const clearBookmarks = StateEffect.define<void>();
+
+export const bookmarks = (): Extension => {
+  return [
+    bookmarksField,
+    Prec.highest(
+      keymap.of([
+        {
+          key: 'Mod-ArrowUp',
+          run: (view) => {
+            const bookmarks = view.state.field(bookmarksField);
+            console.log('up', bookmarks);
+            return true;
+          },
+        },
+        {
+          key: 'Mod-ArrowDown',
+          run: (view) => {
+            const bookmarks = view.state.field(bookmarksField);
+            console.log('down', bookmarks);
+            return true;
+          },
+        },
+      ]),
+    ),
+  ];
+};
+
+type BookmarkFieldState = {
+  bookmarks: Bookmark[];
+};
+
+const bookmarksField = StateField.define<BookmarkFieldState>({
+  create: (): BookmarkFieldState => ({
+    bookmarks: [],
+  }),
+
+  update: (value: BookmarkFieldState, tr): BookmarkFieldState => {
+    // Map bookmark positions through document changes.
+    let bookmarks = value.bookmarks.map((bookmark) => ({
+      ...bookmark,
+      pos: tr.changes.mapPos(bookmark.pos),
+    }));
+
+    // Process effects.
+    for (const effect of tr.effects) {
+      if (effect.is(addBookmark)) {
+        bookmarks = [...bookmarks, effect.value];
+      } else if (effect.is(removeBookmark)) {
+        bookmarks = bookmarks.filter((b) => b.id !== effect.value);
+      } else if (effect.is(clearBookmarks)) {
+        bookmarks = [];
+      }
+    }
+
+    // Sort bookmarks by position.
+    bookmarks.sort(({ pos: a }, { pos: b }) => a - b);
+    return { bookmarks };
+  },
+});

package/src/extensions/comments.ts

@@ -58,7 +58,11 @@ const setCommentState = StateEffect.define<CommentsState>();
  * The ranges are tracked as Automerge cursors from which the absolute indexed ranges can be computed.
  */
 export const commentsState = StateField.define<CommentsState>({
-  create: (state) => ({ id: state.facet(documentId), comments: [], selection: {} }),
+  create: (state) => ({
+    id: state.facet(documentId),
+    comments: [],
+    selection: {},
+  }),
   update: (value, tr) => {
     for (const effect of tr.effects) {
       // Update selection.
@@ -100,13 +104,14 @@ export const commentsState = StateField.define<CommentsState>({
 const styles = EditorView.theme({
   '.cm-comment, .cm-comment-current': {
     padding: '3px 0',
+    color: 'var(--dx-cmCommentText)',
     backgroundColor: 'var(--dx-cmCommentSurface)',
   },
   '.cm-comment > span, .cm-comment-current > span': {
     boxDecorationBreak: 'clone',
     boxShadow: '0 0 1px 3px var(--dx-cmCommentSurface)',
     backgroundColor: 'var(--dx-cmCommentSurface)',
-    color: 'var(--dx-cmComment)',
+    color: 'var(--dx-cmCommentText)',
     cursor: 'pointer',
   },
 });

package/src/extensions/factories.ts

@@ -4,10 +4,9 @@
 
 import { closeBrackets, closeBracketsKeymap } from '@codemirror/autocomplete';
 import { defaultKeymap, history, historyKeymap, indentWithTab, standardKeymap } from '@codemirror/commands';
-import { bracketMatching, defaultHighlightStyle, syntaxHighlighting } from '@codemirror/language';
+import { HighlightStyle, bracketMatching, syntaxHighlighting } from '@codemirror/language';
 import { searchKeymap } from '@codemirror/search';
-import { EditorState, type Extension } from '@codemirror/state';
-import { oneDarkHighlightStyle } from '@codemirror/theme-one-dark';
+import { type ChangeSpec, EditorState, type Extension, type TransactionSpec } from '@codemirror/state';
 import {
   EditorView,
   type KeyBinding,
@@ -20,16 +19,18 @@ import {
   placeholder,
   scrollPastEnd,
 } from '@codemirror/view';
+import { vscodeDarkStyle, vscodeLightStyle } from '@uiw/codemirror-theme-vscode';
 import defaultsDeep from 'lodash.defaultsdeep';
 import merge from 'lodash.merge';
 
 import { generateName } from '@dxos/display-name';
+import { type DocAccessor } from '@dxos/echo-db';
 import { log } from '@dxos/log';
-import { type DocAccessor, type Space } from '@dxos/react-client/echo';
-import { type Identity } from '@dxos/react-client/halo';
+import { type Messenger } from '@dxos/protocols';
+import { type Identity } from '@dxos/protocols/proto/dxos/client/services';
 import { type ThemeMode } from '@dxos/react-ui';
 import { type HuePalette } from '@dxos/react-ui-theme';
-import { hexToHue, isNotFalsy } from '@dxos/util';
+import { hexToHue, isTruthy } from '@dxos/util';
 
 import { editorGutter, editorMonospace } from '../defaults';
 import { type ThemeStyles, defaultTheme } from '../styles';
@@ -42,12 +43,38 @@ import { focus } from './focus';
 // Basic
 //
 
-export const preventNewline = EditorState.transactionFilter.of((tr) => (tr.newDoc.lines > 1 ? [] : tr));
+export const filterChars = (chars: RegExp) => {
+  return EditorState.transactionFilter.of((transaction) => {
+    if (!transaction.docChanged) {
+      return transaction;
+    }
+
+    const changes: ChangeSpec[] = [];
+    transaction.changes.iterChanges((fromA, toA, fromB, toB, text) => {
+      const inserted = text.toString();
+      const filtered = inserted.replace(chars, '');
+      if (inserted !== filtered) {
+        changes.push({
+          from: fromB,
+          to: toB,
+          insert: filtered,
+        });
+      }
+    });
+
+    if (changes.length) {
+      return [transaction, { changes, sequential: true } as TransactionSpec];
+    }
+
+    return transaction;
+  });
+};
 
 /**
  * https://codemirror.net/docs/extensions
  * https://github.com/codemirror/basic-setup
  * https://github.com/codemirror/basic-setup/blob/main/src/codemirror.ts
+ * https://github.com/codemirror/theme-one-dark
  */
 export type BasicExtensionsOptions = {
   allowMultipleSelections?: boolean;
@@ -64,11 +91,11 @@ export type BasicExtensionsOptions = {
   lineNumbers?: boolean;
   /** If false then do not set a max-width or side margin on the editor. */
   lineWrapping?: boolean;
-  monospace?: boolean;
   placeholder?: string;
   /** If true user cannot edit the text, but they can still select and copy it. */
   readOnly?: boolean;
   search?: boolean;
+  /** NOTE: Do not use with stack sections. */
   scrollPastEnd?: boolean;
   standardKeymap?: boolean;
   tabSize?: number;
@@ -112,7 +139,6 @@ export const createBasicExtensions = (_props?: BasicExtensionsOptions): Extensio
     props.history && history(),
     props.lineNumbers && [lineNumbers(), editorGutter],
     props.lineWrapping && EditorView.lineWrapping,
-    props.monospace && editorMonospace,
     props.placeholder && placeholder(props.placeholder),
     props.readOnly !== undefined && EditorState.readOnly.of(props.readOnly),
     props.scrollPastEnd && scrollPastEnd(),
@@ -138,9 +164,9 @@ export const createBasicExtensions = (_props?: BasicExtensionsOptions): Extensio
           preventDefault: true,
           run: () => true,
         },
-      ].filter(isNotFalsy),
+      ].filter(isTruthy),
     ),
-  ].filter(isNotFalsy);
+  ].filter(isTruthy);
 };
 
 //
@@ -149,6 +175,7 @@ export const createBasicExtensions = (_props?: BasicExtensionsOptions): Extensio
 
 export type ThemeExtensionsOptions = {
   themeMode?: ThemeMode;
+  monospace?: boolean;
   styles?: ThemeStyles;
   syntaxHighlighting?: boolean;
   slots?: {
@@ -156,9 +183,7 @@ export type ThemeExtensionsOptions = {
       className?: string;
     };
     scroll?: {
-      className?: string;
-    };
-    scroller?: {
+      // NOTE: Do not apply vertical padding to scroll container.
       className?: string;
     };
     content?: {
@@ -169,7 +194,7 @@ export type ThemeExtensionsOptions = {
 
 export const grow: ThemeExtensionsOptions['slots'] = {
   editor: {
-    className: 'is-full bs-full',
+    className: 'bs-full is-full',
   },
 } as const;
 
@@ -181,41 +206,39 @@ export const fullWidth: ThemeExtensionsOptions['slots'] = {
 
 export const defaultThemeSlots = grow;
 
+export const defaultStyles = {
+  dark: vscodeDarkStyle,
+  light: vscodeLightStyle,
+};
+
 /**
  * https://codemirror.net/examples/styling
  */
 export const createThemeExtensions = ({
   themeMode,
+  monospace,
   styles,
-  syntaxHighlighting: _syntaxHighlighting,
-  slots: _slots,
+  syntaxHighlighting: syntaxHighlightingProp,
+  slots: slotsParam,
 }: ThemeExtensionsOptions = {}): Extension => {
-  const slots = defaultsDeep({}, _slots, defaultThemeSlots);
+  const slots = defaultsDeep({}, slotsParam, defaultThemeSlots);
   return [
     EditorView.darkTheme.of(themeMode === 'dark'),
     EditorView.baseTheme(styles ? merge({}, defaultTheme, styles) : defaultTheme),
-    // https://github.com/codemirror/theme-one-dark
-    _syntaxHighlighting &&
-      (themeMode === 'dark' ? syntaxHighlighting(oneDarkHighlightStyle) : syntaxHighlighting(defaultHighlightStyle)),
+    monospace && editorMonospace,
+    syntaxHighlightingProp &&
+      syntaxHighlighting(HighlightStyle.define(themeMode === 'dark' ? defaultStyles.dark : defaultStyles.light)),
     slots.editor?.className && EditorView.editorAttributes.of({ class: slots.editor.className }),
     slots.content?.className && EditorView.contentAttributes.of({ class: slots.content.className }),
     slots.scroll?.className &&
       ViewPlugin.fromClass(
         class {
           constructor(view: EditorView) {
-            view.scrollDOM.classList.add(slots.scroll.className);
+            view.scrollDOM.classList.add(...slots.scroll.className.split(/\s+/));
           }
         },
       ),
-    slots.scroller?.className &&
-      ViewPlugin.fromClass(
-        class {
-          constructor(view: EditorView) {
-            view.dom.querySelector('.cm-scroller')?.classList.add(...slots.scroller.className.split(' '));
-          }
-        },
-      ),
-  ].filter(isNotFalsy);
+  ].filter(isTruthy);
 };
 
 //
@@ -225,31 +248,30 @@ export const createThemeExtensions = ({
 export type DataExtensionsProps<T> = {
   id: string;
   text?: DocAccessor<T>;
-  space?: Space;
+  messenger?: Messenger;
   identity?: Identity | null;
 };
 
-// TODO(burdon): Move out of react-ui-editor (remove echo deps).
-export const createDataExtensions = <T>({ id, text, space, identity }: DataExtensionsProps<T>): Extension[] => {
+// TODO(burdon): Move out of react-ui-editor?
+export const createDataExtensions = <T>({ id, text, messenger, identity }: DataExtensionsProps<T>): Extension[] => {
   const extensions: Extension[] = [];
   if (text) {
     extensions.push(automerge(text));
   }
 
-  if (space && identity) {
+  if (messenger && identity) {
     const peerId = identity?.identityKey.toHex();
     const hue = (identity?.profile?.data?.hue as HuePalette | undefined) ?? hexToHue(peerId ?? '0');
-
     extensions.push(
       awareness(
         new SpaceAwarenessProvider({
-          space,
+          messenger,
           channel: `awareness.${id}`,
           peerId: identity.identityKey.toHex(),
           info: {
-            displayName: identity.profile?.displayName ?? generateName(identity.identityKey.toHex()),
             darkColor: `var(--dx-${hue}Cursor)`,
             lightColor: `var(--dx-${hue}Cursor)`,
+            displayName: identity.profile?.displayName ?? generateName(identity.identityKey.toHex()),
           },
         }),
       ),

package/src/extensions/focus.ts

@@ -15,6 +15,7 @@ export const focusField = StateField.define<boolean>({
         return effect.value;
       }
     }
+
     return value;
   },
 });
@@ -25,11 +26,11 @@ export const focusField = StateField.define<boolean>({
 export const focus = [
   focusField,
   EditorView.domEventHandlers({
-    focus: (event, view) => {
-      setTimeout(() => view.dispatch({ effects: focusEffect.of(true) }));
+    focus: (_event, view) => {
+      requestAnimationFrame(() => view.dispatch({ effects: focusEffect.of(true) }));
     },
-    blur: (event, view) => {
-      setTimeout(() => view.dispatch({ effects: focusEffect.of(false) }));
+    blur: (_event, view) => {
+      requestAnimationFrame(() => view.dispatch({ effects: focusEffect.of(false) }));
     },
   }),
 ];

package/src/extensions/folding.tsx

@@ -7,16 +7,15 @@ import { type Extension } from '@codemirror/state';
 import { EditorView } from '@codemirror/view';
 import React from 'react';
 
-import { Icon } from '@dxos/react-ui';
+import { Domino, Icon } from '@dxos/react-ui';
 
-import { createElement, renderRoot } from '../util';
+import { renderRoot } from '../util';
 
 export type FoldingOptions = {};
 
 /**
  * https://codemirror.net/examples/gutter
  */
-// TODO(burdon): Remember folding state (to state).
 export const folding = (_props: FoldingOptions = {}): Extension => [
   codeFolding({
     placeholderDOM: () => {
@@ -25,10 +24,8 @@ export const folding = (_props: FoldingOptions = {}): Extension => [
   }),
   foldGutter({
     markerDOM: (open) => {
-      // TODO(burdon): Use sprite directly.
-      const el = createElement('div', { className: 'flex h-full items-center' });
       return renderRoot(
-        el,
+        Domino.of('div').classNames('flex bs-full items-center').build(),
         <Icon icon='ph--caret-right--bold' size={3} classNames={['mx-3 cursor-pointer', open && 'rotate-90']} />,
       );
     },

package/src/extensions/hashtag.tsx

@@ -13,7 +13,7 @@ import {
   WidgetType,
 } from '@codemirror/view';
 
-import { getHashColor, mx } from '@dxos/react-ui-theme';
+import { getHashStyles, mx } from '@dxos/react-ui-theme';
 
 class TagWidget extends WidgetType {
   constructor(private _text: string) {
@@ -22,7 +22,7 @@ class TagWidget extends WidgetType {
 
   toDOM(): HTMLSpanElement {
     const span = document.createElement('span');
-    span.className = mx('cm-tag', getHashColor(this._text).tag);
+    span.className = mx('cm-tag', getHashStyles(this._text).surface);
     span.textContent = this._text;
     return span;
   }

package/src/extensions/index.ts

@@ -4,10 +4,12 @@
 
 export * from './annotations';
 export * from './autocomplete';
+export * from './autoscroll';
 export * from './automerge';
 export * from './awareness';
 export * from './blast';
-export * from './command';
+export * from './blocks';
+export * from './bookmarks';
 export * from './comments';
 export * from './debug';
 export * from './dnd';
@@ -19,8 +21,15 @@ export * from './json';
 export * from './listener';
 export * from './markdown';
 export * from './mention';
+export * from './modal';
 export * from './modes';
 export * from './outliner';
 export * from './preview';
+export * from './replacer';
 export * from './selection';
+export * from './scrolling';
+export * from './state';
+export * from './submit';
+export * from './tab';
+export * from './tags';
 export * from './typewriter';

package/src/extensions/json.ts

@@ -7,7 +7,7 @@ import { type LintSource, linter } from '@codemirror/lint';
 import { type Extension } from '@codemirror/state';
 import Ajv, { type ValidateFunction } from 'ajv';
 
-import { type JsonSchemaType } from '@dxos/echo-schema';
+import { type JsonSchemaType } from '@dxos/echo/internal';
 
 export type JsonExtensionsOptions = {
   schema?: JsonSchemaType;

package/src/extensions/listener.ts

@@ -5,34 +5,28 @@
 import { type Extension } from '@codemirror/state';
 import { EditorView } from '@codemirror/view';
 
+import { isNonNullable } from '@dxos/util';
+
 import { documentId } from './selection';
 
 export type ListenerOptions = {
-  onFocus?: (focusing: boolean) => void;
-  onChange?: (text: string, id: string) => void;
+  onFocus?: (event: { id: string; focusing: boolean }) => void;
+  onChange?: (event: { id: string; text: string }) => void;
 };
 
-/**
- * Event listener.
- * @deprecated Use EditorView.updateListener and listen for specific update events.
- */
 export const listener = ({ onFocus, onChange }: ListenerOptions): Extension => {
-  const extensions: Extension[] = [];
-
-  onFocus &&
-    extensions.push(
-      EditorView.focusChangeEffect.of((_, focusing) => {
-        onFocus(focusing);
+  return [
+    onFocus &&
+      EditorView.focusChangeEffect.of((state, focusing) => {
+        onFocus({ id: state.facet(documentId), focusing });
         return null;
       }),
-    );
 
-  onChange &&
-    extensions.push(
-      EditorView.updateListener.of((update) => {
-        onChange(update.state.doc.toString(), update.state.facet(documentId));
+    onChange &&
+      EditorView.updateListener.of(({ state, docChanged }) => {
+        if (docChanged) {
+          onChange({ id: state.facet(documentId), text: state.doc.toString() });
+        }
       }),
-    );
-
-  return extensions;
+  ].filter(isNonNullable);
 };