@dxos/react-ui-editor 0.4.5-main.f8d6c4e → 0.4.5

package/src/extensions/markdown/decorate.ts

@@ -0,0 +1,301 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { syntaxTree } from '@codemirror/language';
+import { RangeSetBuilder, type EditorState } from '@codemirror/state';
+import { EditorView, Decoration, type DecorationSet, WidgetType, ViewPlugin, type ViewUpdate } from '@codemirror/view';
+
+import { mx } from '@dxos/react-ui-theme';
+
+import { getToken } from '../../styles';
+
+/**
+ * Widget for first/last line of code block (read-only).
+ */
+// TODO(burdon): Add copy-to-clipboard button.
+class FencedCodeBoundary extends WidgetType {
+  constructor(private readonly _className: string) {
+    super();
+  }
+
+  override toDOM() {
+    const el = document.createElement('span');
+    el.innerHTML = ' ';
+    el.className = mx('cm-code cm-codeblock', this._className);
+    return el;
+  }
+}
+
+class HorizontalRuleWidget extends WidgetType {
+  override toDOM() {
+    const el = document.createElement('span');
+    el.className = 'cm-hr';
+    return el;
+  }
+}
+
+class LinkButton extends WidgetType {
+  constructor(
+    private readonly url: string,
+    private readonly render: (el: Element, url: string) => void,
+  ) {
+    super();
+  }
+
+  override eq(other: this) {
+    return this.url === other.url;
+  }
+
+  override toDOM(view: EditorView) {
+    const el = document.createElement('span');
+    this.render(el, this.url);
+    return el;
+  }
+}
+
+class CheckboxWidget extends WidgetType {
+  constructor(private _checked: boolean) {
+    super();
+  }
+
+  override eq(other: this) {
+    return this._checked === other._checked;
+  }
+
+  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) {
+      input.setAttribute('disabled', '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 input;
+  }
+
+  override ignoreEvent() {
+    return false;
+  }
+}
+
+const hide = Decoration.replace({});
+const fencedCodeTop = Decoration.replace({ widget: new FencedCodeBoundary('cm-codeblock-end cm-codeblock-first') });
+const fencedCodeBottom = Decoration.replace({ widget: new FencedCodeBoundary('cm-codeblock-end cm-codeblock-last') });
+const horizontalRule = Decoration.replace({ widget: new HorizontalRuleWidget() });
+const checkedTask = Decoration.replace({ widget: new CheckboxWidget(true) });
+const uncheckedTask = Decoration.replace({ widget: new CheckboxWidget(false) });
+
+const editingRange = (state: EditorState, range: { from: number; to: number }) => {
+  const {
+    readOnly,
+    selection: {
+      main: { head },
+    },
+  } = state;
+  return !readOnly && head >= range.from && head <= range.to;
+};
+
+const MarksByParent = new Set(['CodeMark', 'EmphasisMark', 'StrikethroughMark', 'SubscriptMark', 'SuperscriptMark']);
+
+const buildDecorations = (view: EditorView, options: DecorateOptions): DecorationSet => {
+  const builder = new RangeSetBuilder<Decoration>();
+  const { state } = view;
+
+  for (const { from, to } of view.visibleRanges) {
+    syntaxTree(state).iterate({
+      from,
+      to,
+      enter: (node) => {
+        if (node.name === 'FencedCode') {
+          const editing = editingRange(state, node);
+          // FencedCode > CodeMark > [CodeInfo] > CodeText > CodeMark
+          for (const block of view.viewportLineBlocks) {
+            if (block.to < node.from) {
+              continue;
+            }
+            if (block.from > node.to) {
+              break;
+            }
+            const first = block.from <= node.from;
+            const last = block.to >= node.to;
+            if (!editing && (first || last)) {
+              builder.add(block.from, block.to, first ? fencedCodeTop : fencedCodeBottom);
+            } else {
+              builder.add(
+                block.from,
+                block.from,
+                Decoration.line({
+                  class: mx('cm-code cm-codeblock-line', first && 'cm-codeblock-first', last && 'cm-codeblock-last'),
+                }),
+              );
+            }
+          }
+          return false;
+        } else if (node.name === 'Link') {
+          const marks = node.node.getChildren('LinkMark');
+          const urlNode = node.node.getChild('URL');
+          const editing = editingRange(state, node);
+          if (urlNode && marks.length >= 2) {
+            const url = state.sliceDoc(urlNode.from, urlNode.to);
+            if (!editing) {
+              builder.add(node.from, marks[0].to, hide);
+            }
+            builder.add(
+              marks[0].to,
+              marks[1].from,
+              Decoration.mark({
+                tagName: 'a',
+                attributes: {
+                  class: 'cm-link',
+                  href: url,
+                  rel: 'noreferrer',
+                  target: '_blank',
+                },
+              }),
+            );
+            if (!editing) {
+              builder.add(
+                marks[1].from,
+                node.to,
+                options.renderLinkButton
+                  ? Decoration.replace({
+                      widget: new LinkButton(url, options.renderLinkButton),
+                    })
+                  : hide,
+              );
+            }
+          }
+        } else if (node.name === 'HeaderMark') {
+          const parent = node.node.parent!;
+          if (/^ATX/.test(parent.name) && !editingRange(state, state.doc.lineAt(node.from))) {
+            const next = state.doc.sliceString(node.to, node.to + 1);
+            builder.add(node.from, node.to + (next === ' ' ? 1 : 0), hide);
+          }
+        } else if (node.name === 'HorizontalRule') {
+          if (!editingRange(state, node)) {
+            builder.add(node.from, node.to, horizontalRule);
+          }
+        } else if (node.name === 'TaskMarker') {
+          // Check if cursor is inside text.
+          if (!editingRange(state, node)) {
+            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 ? checkedTask : uncheckedTask);
+          }
+        } else if (MarksByParent.has(node.name)) {
+          if (!editingRange(state, node.node.parent!)) {
+            builder.add(node.from, node.to, hide);
+          }
+        }
+      },
+    });
+  }
+
+  return builder.finish();
+};
+
+export interface DecorateOptions {
+  renderLinkButton?: (el: Element, url: string) => void;
+}
+
+export const decorateMarkdown = (options: DecorateOptions = {}) => {
+  return [
+    ViewPlugin.fromClass(
+      class {
+        decorations: DecorationSet;
+        constructor(view: EditorView) {
+          this.decorations = buildDecorations(view, options);
+        }
+
+        update(update: ViewUpdate) {
+          if (update.docChanged || update.selectionSet || update.viewportChanged) {
+            this.decorations = buildDecorations(update.view, options);
+          }
+        }
+      },
+      {
+        decorations: (value) => value.decorations,
+      },
+    ),
+    formattingStyles,
+  ];
+};
+
+const formattingStyles = EditorView.baseTheme({
+  '& .cm-code': {
+    fontFamily: getToken('fontFamily.mono', []).join(','),
+  },
+  '& .cm-codeblock-line': {
+    paddingInline: '1rem !important',
+  },
+
+  '& .cm-codeblock-end': {
+    display: 'inline-block',
+    width: '100%',
+    position: 'relative',
+    '&::after': {
+      position: 'absolute',
+      inset: 0,
+      content: '""',
+    },
+  },
+  '& .cm-codeblock-first': {
+    '&::after': {
+      borderTopLeftRadius: '.5rem',
+      borderTopRightRadius: '.5rem',
+    },
+  },
+  '& .cm-codeblock-last': {
+    '&::after': {
+      borderBottomLeftRadius: '.5rem',
+      borderBottomRightRadius: '.5rem',
+    },
+  },
+
+  '&light .cm-codeblock-line, &light .cm-activeLine.cm-codeblock-line': {
+    background: getToken('extend.semanticColors.input.light'),
+    mixBlendMode: 'darken',
+  },
+  '&dark .cm-codeblock-line, &dark .cm-activeLine.cm-codeblock-line': {
+    background: getToken('extend.semanticColors.input.dark'),
+    mixBlendMode: 'lighten',
+  },
+  '&light .cm-codeblock-first, &light .cm-codeblock-last': {
+    mixBlendMode: 'darken',
+    '&::after': {
+      background: getToken('extend.semanticColors.input.light'),
+    },
+  },
+  '&dark .cm-codeblock-first, &dark .cm-codeblock-last': {
+    mixBlendMode: 'lighten',
+    '&::after': {
+      background: getToken('extend.semanticColors.input.dark'),
+    },
+  },
+  '& .cm-hr': {
+    display: 'inline-block',
+    width: '100%',
+    height: '0',
+    verticalAlign: 'middle',
+    borderTop: `1px solid ${getToken('extend.colors.neutral.200')}`,
+  },
+  '& .cm-task': {
+    color: getToken('extend.colors.blue.500'),
+  },
+  '& .cm-task-checkbox': {
+    marginLeft: '4px',
+    marginRight: '4px',
+  },
+});

package/src/extensions/markdown/formatting.test.ts

@@ -101,6 +101,8 @@ describe('setHeading', () => {
   testCommand('can add a heading inside block markup', '> - {one\n> - two}\n', setHeading(1), '> - # one\n> - # two\n');
 
   testCommand('can remove a heading inside block markup', '1. # one{}', setHeading(0), '1. one');
+
+  testCommand('can add a heading to a blank line', 'one\n\n{}', setHeading(1), 'one\n\n# {}');
 });
 
 describe('addStyle', () => {
@@ -158,6 +160,8 @@ describe('addStyle', () => {
     em,
     '*[one {two](x) ![three} four](y)* five',
   );
+
+  testCommand('can add a style to an empty line', '{}', em, '*{}*');
 });
 
 describe('removeStyle', () => {
@@ -188,6 +192,15 @@ describe('removeStyle', () => {
   );
 
   testCommand('can shrink existing styles', '*one {two three} four*', em, '*one* {two three} *four*');
+
+  testCommand('can remove strong from a partially emphasized text', '**{one*two*}**', str, '{one*two*}');
+
+  testCommand(
+    'can remove strong from a partially emphasized text with markers outside',
+    '***{o*ne*two}***',
+    str,
+    '*{o*ne*two}*',
+  );
 });
 
 describe('addLink', () => {
@@ -284,6 +297,8 @@ describe('addList', () => {
   );
 
   testCommand("doesn't renumber lists with a different parent", '> one{}\n\n1. two', ordered, '> 1. one\n\n1. two');
+
+  testCommand('can add a list to an empty line', '{}', ordered, '1. {}');
 });
 
 describe('removeList', () => {
@@ -345,6 +360,8 @@ describe('addBlockquote', () => {
     addBlockquote,
     '> one\n> two\n>\n> # three\n\nfour',
   );
+
+  testCommand('can add a blockquote to an empty line', '{}', addBlockquote, '>{}');
 });
 
 describe('removeBlockquote', () => {

package/src/extensions/markdown/formatting.ts

@@ -7,14 +7,13 @@ import { syntaxTree } from '@codemirror/language';
 import {
   type Extension,
   type StateCommand,
-  RangeSetBuilder,
   type EditorState,
   type ChangeSpec,
   type Text,
   EditorSelection,
   type Line,
 } from '@codemirror/state';
-import { Decoration, type DecorationSet, EditorView, keymap, ViewPlugin, type ViewUpdate } from '@codemirror/view';
+import { EditorView, keymap } from '@codemirror/view';
 import { type SyntaxNodeRef, type SyntaxNode } from '@lezer/common';
 import { useState, useMemo } from 'react';
 
@@ -94,6 +93,7 @@ export const setHeading =
     const changes: ChangeSpec[] = [];
     let prevBlock = -1;
     for (const range of ranges) {
+      let sawBlock = false;
       syntaxTree(state).iterate({
         from: range.from,
         to: range.to,
@@ -101,6 +101,7 @@ export const setHeading =
           if (!Object.hasOwn(Textblocks, node.name) || prevBlock === node.from) {
             return;
           }
+          sawBlock = true;
           prevBlock = node.from;
           const blockType = Textblocks[node.name];
           const isHeading = /heading(\d)/.exec(blockType);
@@ -129,13 +130,25 @@ export const setHeading =
           }
         },
       });
+      let line;
+      if (!sawBlock && range.empty && level > 0 && !/\S/.test((line = state.doc.lineAt(range.from)).text)) {
+        changes.push({ from: line.from, to: line.to, insert: '#'.repeat(level) + ' ' });
+      }
     }
 
     if (!changes.length) {
       return false;
     }
 
-    dispatch(state.update({ changes, userEvent: 'format.setHeading', scrollIntoView: true }));
+    const changeSet = state.changes(changes);
+    dispatch(
+      state.update({
+        changes: changeSet,
+        selection: state.selection.map(changeSet, 1),
+        userEvent: 'format.setHeading',
+        scrollIntoView: true,
+      }),
+    );
     return true;
   };
 
@@ -174,8 +187,8 @@ export const setStyle =
       const changesAtEnd: ChangeSpec[] = [];
       let blockStart = -1;
       let blockEnd = -1;
-      let startCovered: boolean | 'adjacent' = false;
-      let endCovered: boolean | 'adjacent' = false;
+      let startCovered: boolean | { from: number; to: number } = false;
+      let endCovered: boolean | { from: number; to: number } = false;
       let { from, to } = range;
       // Iterate the selected range. For each textblock, determine a
       // start and end position, the overlap of the selected range and
@@ -218,10 +231,16 @@ export const setStyle =
             // by this.
             if (markType === type) {
               if (openEnd <= from && closeStart >= from) {
-                startCovered = openEnd === from ? 'adjacent' : true;
+                startCovered =
+                  !enable && openEnd === skipMarkers(from, node.node, -1, openEnd)
+                    ? { from: node.from, to: openEnd }
+                    : true;
               }
               if (openEnd <= to && closeStart >= to) {
-                endCovered = closeStart === to ? 'adjacent' : true;
+                endCovered =
+                  !enable && closeStart === skipMarkers(to, node.node, 1, closeStart)
+                    ? { from: closeStart, to: node.to }
+                    : true;
               }
             }
             // Marks of the same type in range, or any mark if we're
@@ -263,13 +282,13 @@ export const setStyle =
                 changes.push({ from: rangeEnd, insert: marker });
               }
             } else {
-              if (startCovered === 'adjacent') {
-                changes.push({ from: from - marker.length, to: from });
+              if (typeof startCovered === 'object') {
+                changes.push(startCovered);
               } else if (startCovered) {
                 changes.push({ from: skipSpaces(rangeStart, state.doc, -1, blockStart), insert: marker });
               }
-              if (endCovered === 'adjacent') {
-                changes.push({ from: to, to: to + marker.length });
+              if (typeof endCovered === 'object') {
+                changes.push(endCovered);
               } else if (endCovered) {
                 changes.push({ from: skipSpaces(rangeEnd, state.doc, 1, blockEnd), insert: marker });
               }
@@ -277,6 +296,12 @@ export const setStyle =
           }
         },
       });
+      if (blockStart < 0 && range.empty && enable && !/\S/.test(state.doc.lineAt(range.from).text)) {
+        return {
+          changes: { from: range.head, insert: marker + marker },
+          range: EditorSelection.cursor(range.head + marker.length),
+        };
+      }
       const changeSet = state.changes(changes.concat(changesAtEnd));
       return {
         changes: changeSet,
@@ -350,6 +375,20 @@ const skipSpaces = (pos: number, doc: Text, dir: -1 | 1, limit?: number) => {
   return pos;
 };
 
+const skipMarkers = (pos: number, tree: SyntaxNode, dir: -1 | 1, limit?: number) => {
+  for (;;) {
+    const next = tree.resolve(pos, dir);
+    if (!IgnoreInline.has(next.name)) {
+      return pos;
+    }
+    const moveTo = dir < 0 ? next.from : next.to;
+    if (limit != null && (dir < 0 ? moveTo < limit : moveTo > limit)) {
+      return pos;
+    }
+    pos = moveTo;
+  }
+};
+
 // TODO(burdon): Define and trigger snippets for codeblock, table, etc.
 const snippets = {
   codeblock: snippet(
@@ -515,7 +554,6 @@ export const addLink: StateCommand = ({ state, dispatch }) => {
 // Lists
 //
 
-// TODO(burdon): Cursor is positioned incorrectly.
 export const addList =
   (type: List): StateCommand =>
   ({ state, dispatch }) => {
@@ -654,7 +692,15 @@ export const addList =
       }
     }
 
-    dispatch(state.update({ changes, userEvent: 'format.list.add', scrollIntoView: true }));
+    const changeSet = state.changes(changes);
+    dispatch(
+      state.update({
+        changes: changeSet,
+        selection: state.selection.map(changeSet, 1),
+        userEvent: 'format.list.add',
+        scrollIntoView: true,
+      }),
+    );
     return true;
   };
 
@@ -751,6 +797,7 @@ export const setBlockquote =
     const lines: Line[] = [];
     let lastBlock = -1;
     for (const { from, to } of state.selection.ranges) {
+      const sawBlock = false;
       syntaxTree(state).iterate({
         from,
         to,
@@ -786,6 +833,10 @@ export const setBlockquote =
           }
         },
       });
+      let line;
+      if (!sawBlock && enable && from === to && !/\S/.test((line = state.doc.lineAt(from)).text)) {
+        lines.push(line);
+      }
     }
 
     const changes: ChangeSpec[] = [];
@@ -803,9 +854,11 @@ export const setBlockquote =
       return false;
     }
 
+    const changeSet = state.changes(changes);
     dispatch(
       state.update({
-        changes,
+        changes: changeSet,
+        selection: state.selection.map(changeSet, 1),
         userEvent: enable ? 'format.blockquote.add' : 'format.blockquote.remove',
         scrollIntoView: true,
       }),
@@ -942,68 +995,6 @@ export const formatting = (options: FormattingOptions = {}): Extension => {
         run: toggleStrong,
       },
     ]),
-    styling(),
-  ];
-};
-
-const styling = (): Extension => {
-  const buildDecorations = (view: EditorView): DecorationSet => {
-    const builder = new RangeSetBuilder<Decoration>();
-    const { state } = view;
-    const cursor = state.selection.main.head;
-
-    // TODO(burdon): Bug if '***foo***' (since StrongEmphasis is nested inside EmphasisMark).
-    //  Ranges must be added sorted by `from` position and `startSide`.
-    const replace = (node: SyntaxNodeRef, marks: SyntaxNode[]) => {
-      if (cursor <= node.from || cursor >= node.to) {
-        for (const mark of marks) {
-          builder.add(mark.from, mark.to, Decoration.replace({}));
-        }
-      }
-    };
-
-    for (const { from, to } of view.visibleRanges) {
-      syntaxTree(state).iterate({
-        enter: (node) => {
-          switch (node.name) {
-            case 'Emphasis':
-            case 'StrongEmphasis': {
-              const marks = node.node.getChildren('EmphasisMark');
-              replace(node, marks);
-              break;
-            }
-
-            case 'Strikethrough': {
-              const marks = node.node.getChildren('StrikethroughMark');
-              replace(node, marks);
-              break;
-            }
-          }
-        },
-        from,
-        to,
-      });
-    }
-
-    return builder.finish();
-  };
-
-  return [
-    ViewPlugin.fromClass(
-      class {
-        decorations: DecorationSet;
-        constructor(view: EditorView) {
-          this.decorations = buildDecorations(view);
-        }
-
-        update(update: ViewUpdate) {
-          this.decorations = buildDecorations(update.view);
-        }
-      },
-      {
-        decorations: (value) => value.decorations,
-      },
-    ),
   ];
 };
 

package/src/extensions/markdown/index.ts

@@ -3,12 +3,9 @@
 //
 
 export * from './bundle';
-export * from './code';
+export * from './decorate';
 export * from './formatting';
-export * from './heading';
 export * from './highlight';
-export * from './hr';
 export * from './image';
 export * from './link';
 export * from './table';
-export * from './tasklist';