@dxos/react-ui-editor 0.8.4-main.406dc2a → 0.8.4-main.548089c

package/src/extensions/autoscroll.ts

@@ -5,101 +5,117 @@
 import { StateEffect } from '@codemirror/state';
 import { EditorView, ViewPlugin } from '@codemirror/view';
 
+import { debounce } from '@dxos/async';
 import { Domino } from '@dxos/react-ui';
 
-const lineHeight = 24;
+import { scrollToLineEffect } from './scrolling';
 
-export const scrollToBottomEffect = StateEffect.define<any>();
+// TODO(burdon): Reconcile with scrollToLineEffect (scrolling).
+export const scrollToBottomEffect = StateEffect.define<ScrollBehavior | undefined>();
 
 export type AutoScrollOptions = {
-  overscroll?: number;
-  throttle?: number;
+  /** Auto-scroll when reaches the bottom. */
+  autoScroll?: boolean;
+  /** Threshold in px to trigger scroll from bottom. */
+  threshold?: number;
+  /** Throttle time in ms. */
+  throttleDelay?: number;
+  /** Callback when auto-scrolling. */
+  onAutoScroll?: (props: { view: EditorView; distanceFromBottom: number }) => boolean | void;
 };
 
 /**
  * Extension that supports pinning the scroll position and automatically scrolls to the bottom when content is added.
  */
 // TODO(burdon): Reconcile with transcript-extension.
-export const autoScroll = ({ overscroll = 4 * lineHeight, throttle = 2_000 }: Partial<AutoScrollOptions> = {}) => {
-  let isThrottled = false;
-  let isPinned = true;
-  let timeout: NodeJS.Timeout | undefined;
+export const autoScroll = ({
+  autoScroll = true,
+  threshold = 100,
+  throttleDelay = 1_000,
+  onAutoScroll,
+}: Partial<AutoScrollOptions> = {}) => {
   let buttonContainer: HTMLDivElement | undefined;
+  let hideTimeout: NodeJS.Timeout | undefined;
   let lastScrollTop = 0;
-  let scrollCounter = 0;
+  let isPinned = true;
+
+  const setPinned = (pin: boolean) => {
+    isPinned = pin;
+    buttonContainer?.classList.toggle('opacity-0', pin);
+  };
 
+  // Temporarily hide the scrollbar while auto-scrolling.
   const hideScrollbar = (view: EditorView) => {
     view.scrollDOM.classList.add('cm-hide-scrollbar');
-    clearTimeout(timeout);
-    timeout = setTimeout(() => {
+    clearTimeout(hideTimeout);
+    hideTimeout = setTimeout(() => {
       view.scrollDOM.classList.remove('cm-hide-scrollbar');
     }, 1_000);
   };
 
-  const scrollToBottom = (view: EditorView) => {
-    isPinned = true;
-    scrollCounter = 0;
-    buttonContainer?.classList.add('opacity-0');
-    requestAnimationFrame(() => {
-      hideScrollbar(view);
-      view.scrollDOM.scrollTo({
-        top: view.scrollDOM.scrollHeight,
-        behavior: 'smooth',
-      });
+  // Throttled scroll to bottom.
+  const scrollToBottom = (view: EditorView, behavior?: ScrollBehavior) => {
+    setPinned(true);
+    hideScrollbar(view);
+    const line = view.state.doc.lineAt(view.state.doc.length);
+    view.dispatch({
+      selection: { anchor: line.to, head: line.to },
+      effects: scrollToLineEffect.of({ line: line.number, options: { position: 'end', offset: threshold, behavior } }),
     });
   };
 
+  // Throttled check for distance from bottom (for downward scrolls only).
+  const checkDistance = debounce((view: EditorView) => {
+    const scrollerRect = view.scrollDOM.getBoundingClientRect();
+    const coords = view.coordsAtPos(view.state.doc.length);
+    const distanceFromBottom = coords ? coords.bottom - scrollerRect.bottom : 0;
+    setPinned(distanceFromBottom < 0);
+  }, 1_000);
+
+  // Debounce scroll updates so rapid edits don't cause clunky scrolling.
+  const triggerUpdate = debounce((view: EditorView) => scrollToBottom(view), throttleDelay);
+
   return [
     // Update listener for logging when scrolling is needed.
-    EditorView.updateListener.of((update) => {
-      // Listen for effects.
-      update.transactions.forEach((transaction) => {
+    EditorView.updateListener.of(({ view, transactions, heightChanged }) => {
+      // TODO(burdon): Remove and use scrollToLineEffect instead.
+      transactions.forEach((transaction) => {
         for (const effect of transaction.effects) {
           if (effect.is(scrollToBottomEffect)) {
-            scrollToBottom(update.view);
+            scrollToBottom(view, effect.value);
           }
         }
       });
 
       // Maybe scroll if doc changed and pinned.
-      if (update.docChanged && isPinned && !isThrottled) {
-        const distanceFromBottom = calcDistance(update.view.scrollDOM);
-        if (distanceFromBottom >= overscroll) {
-          isThrottled = true;
-          requestAnimationFrame(() => {
-            scrollToBottom(update.view);
-          });
-
-          // Reset throttle.
-          setTimeout(() => {
-            isThrottled = false;
-            scrollToBottom(update.view);
-          }, throttle);
+      // NOTE: Geometry changed is triggered when widgets change height (e.g., toggle tool block).
+      if (heightChanged && isPinned) {
+        const coords = view.coordsAtPos(view.state.doc.length);
+        const scrollerRect = view.scrollDOM.getBoundingClientRect();
+        const distanceFromBottom = coords ? scrollerRect.bottom - coords.bottom : 0;
+        if (autoScroll && distanceFromBottom < threshold) {
+          const shouldScroll = onAutoScroll?.({ view, distanceFromBottom }) ?? true;
+          if (shouldScroll) {
+            triggerUpdate(view);
+          }
+        } else if (distanceFromBottom < 0) {
+          setPinned(false);
         }
       }
     }),
 
     // Detect user scroll.
-    // NOTE: Multiple scroll events are triggered during programmatic smooth scrolling.
     EditorView.domEventHandlers({
       scroll: (event, view) => {
-        const scroller = view.scrollDOM;
-        // Suspect delta goes positive when rendering widgets, so count positive deltas.
-        // TODO(burdon): Detect user scroll directly (wheel, touch, keys, etc.)
-        if (lastScrollTop > scroller.scrollTop) {
-          scrollCounter++;
-        }
-        lastScrollTop = scroller.scrollTop;
-        const distanceFromBottom = calcDistance(scroller);
-        if (distanceFromBottom === 0) {
-          // Pin to bottom.
-          isPinned = true;
-          buttonContainer?.classList.add('opacity-0');
-          scrollCounter = 0;
-        } else if (scrollCounter > 3) {
-          // Break pin if user scrolls up.
-          isPinned = false;
-          buttonContainer?.classList.remove('opacity-0');
+        const currentScrollTop = view.scrollDOM.scrollTop;
+        const scrollingUp = currentScrollTop < lastScrollTop;
+        lastScrollTop = currentScrollTop;
+
+        // If user scrolls up, immediately unpin auto-scroll.
+        if (scrollingUp) {
+          setPinned(false);
+        } else {
+          checkDistance(view);
         }
       },
     }),
@@ -108,7 +124,6 @@ export const autoScroll = ({ overscroll = 4 * lineHeight, throttle = 2_000 }: Pa
     ViewPlugin.fromClass(
       class {
         constructor(view: EditorView) {
-          const scroller = view.scrollDOM.parentElement;
           buttonContainer = Domino.of('div')
             .classNames(true && 'cm-scroll-button transition-opacity duration-300 opacity-0')
             .children(
@@ -121,7 +136,8 @@ export const autoScroll = ({ overscroll = 4 * lineHeight, throttle = 2_000 }: Pa
                 }),
             )
             .build();
-          scroller?.appendChild(buttonContainer);
+
+          view.scrollDOM.parentElement!.appendChild(buttonContainer);
         }
       },
     ),
@@ -129,7 +145,6 @@ export const autoScroll = ({ overscroll = 4 * lineHeight, throttle = 2_000 }: Pa
     // Styles.
     EditorView.theme({
       '.cm-scroller': {
-        paddingBottom: `${overscroll}px`,
         scrollbarWidth: 'thin',
       },
       '.cm-scroller.cm-hide-scrollbar': {
@@ -138,7 +153,6 @@ export const autoScroll = ({ overscroll = 4 * lineHeight, throttle = 2_000 }: Pa
       '.cm-scroller.cm-hide-scrollbar::-webkit-scrollbar': {
         display: 'none',
       },
-
       '.cm-scroll-button': {
         position: 'absolute',
         bottom: '0.5rem',
@@ -147,11 +161,3 @@ export const autoScroll = ({ overscroll = 4 * lineHeight, throttle = 2_000 }: Pa
     }),
   ];
 };
-
-const calcDistance = (scroller: HTMLElement) => {
-  const scrollTop = scroller.scrollTop;
-  const scrollHeight = scroller.scrollHeight;
-  const clientHeight = scroller.clientHeight;
-  const distanceFromBottom = scrollHeight - (scrollTop + clientHeight);
-  return distanceFromBottom;
-};

package/src/extensions/awareness/awareness-provider.ts

@@ -3,11 +3,11 @@
 //
 
 import { DeferredTask, Event, sleep } from '@dxos/async';
+import { type Space } from '@dxos/client/echo';
+import { type GossipMessage } from '@dxos/client/mesh';
 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 './awareness';
 

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

@@ -104,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

@@ -23,10 +23,10 @@ import { vscodeDarkStyle, vscodeLightStyle } from '@uiw/codemirror-theme-vscode'
 import defaultsDeep from 'lodash.defaultsdeep';
 import merge from 'lodash.merge';
 
+import { type DocAccessor, type Space } from '@dxos/client/echo';
+import { type Identity } from '@dxos/client/halo';
 import { generateName } from '@dxos/display-name';
 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 ThemeMode } from '@dxos/react-ui';
 import { type HuePalette } from '@dxos/react-ui-theme';
 import { hexToHue, isTruthy } from '@dxos/util';
@@ -87,7 +87,6 @@ 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;
@@ -136,7 +135,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(),
@@ -173,6 +171,7 @@ export const createBasicExtensions = (_props?: BasicExtensionsOptions): Extensio
 
 export type ThemeExtensionsOptions = {
   themeMode?: ThemeMode;
+  monospace?: boolean;
   styles?: ThemeStyles;
   syntaxHighlighting?: boolean;
   slots?: {
@@ -180,6 +179,7 @@ export type ThemeExtensionsOptions = {
       className?: string;
     };
     scroll?: {
+      // NOTE: Do not apply vertical padding to scroll container.
       className?: string;
     };
     content?: {
@@ -212,6 +212,7 @@ export const defaultStyles = {
  */
 export const createThemeExtensions = ({
   themeMode,
+  monospace,
   styles,
   syntaxHighlighting: syntaxHighlightingProp,
   slots: slotsParam,
@@ -220,6 +221,7 @@ export const createThemeExtensions = ({
   return [
     EditorView.darkTheme.of(themeMode === 'dark'),
     EditorView.baseTheme(styles ? merge({}, defaultTheme, styles) : defaultTheme),
+    monospace && editorMonospace,
     syntaxHighlightingProp &&
       syntaxHighlighting(HighlightStyle.define(themeMode === 'dark' ? defaultStyles.dark : defaultStyles.light)),
     slots.editor?.className && EditorView.editorAttributes.of({ class: slots.editor.className }),

package/src/extensions/folding.tsx

@@ -25,8 +25,7 @@ export const folding = (_props: FoldingOptions = {}): Extension => [
   foldGutter({
     markerDOM: (open) => {
       return renderRoot(
-        Domino.of('div').classNames('flex h-full items-center').build(),
-        // TODO(burdon): Use sprite directly.
+        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/index.ts

@@ -8,6 +8,8 @@ export * from './autoscroll';
 export * from './automerge';
 export * from './awareness';
 export * from './blast';
+export * from './blocks';
+export * from './bookmarks';
 export * from './comments';
 export * from './debug';
 export * from './dnd';
@@ -23,7 +25,9 @@ export * from './modes';
 export * from './outliner';
 export * from './popover';
 export * from './preview';
+export * from './replacer';
 export * from './selection';
+export * from './scrolling';
 export * from './state';
 export * from './tags';
 export * from './typewriter';

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);
 };

package/src/extensions/markdown/bundle.ts

@@ -4,8 +4,10 @@
 
 import { completionKeymap } from '@codemirror/autocomplete';
 import { defaultKeymap, indentWithTab } from '@codemirror/commands';
+import { jsonLanguage } from '@codemirror/lang-json';
 import { markdown, markdownLanguage } from '@codemirror/lang-markdown';
-import { syntaxHighlighting } from '@codemirror/language';
+import { xml } from '@codemirror/lang-xml';
+import { LanguageDescription, syntaxHighlighting } from '@codemirror/language';
 import { languages } from '@codemirror/language-data';
 import { type Extension } from '@codemirror/state';
 import { keymap } from '@codemirror/view';
@@ -43,6 +45,7 @@ export const createMarkdownExtensions = (options: MarkdownBundleOptions = {}): E
       base: markdownLanguage,
 
       // Languages for syntax highlighting fenced code blocks.
+      defaultCodeLanguage: jsonLanguage,
       codeLanguages: languages,
 
       // Don't complete HTML tags.
@@ -74,6 +77,13 @@ export const createMarkdownExtensions = (options: MarkdownBundleOptions = {}): E
   ];
 };
 
+const xmlLanguageDesc = LanguageDescription.of({
+  name: 'xml',
+  alias: ['html', 'xhtml'],
+  extensions: ['xml', 'xhtml'],
+  load: async () => xml(),
+});
+
 /**
  * Default customizations.
  * https://github.com/lezer-parser/markdown/blob/main/src/markdown.ts
@@ -91,5 +101,5 @@ const noSetExtHeading: MarkdownConfig = {
  * Remove HTML and XML parsing.
  */
 const noHtml: MarkdownConfig = {
-  remove: ['HTMLBlock', 'HTMLTag'],
+  // remove: ['HTMLBlock', 'HTMLTag'],
 };