@dxos/react-ui-editor 0.3.10-main.dcfebef → 0.3.10-main.e948ee0

package/src/components/TextEditor/extensions/markdown/highlight.ts

@@ -5,9 +5,11 @@
 import { markdownLanguage } from '@codemirror/lang-markdown';
 import { HighlightStyle } from '@codemirror/language';
 import { tags, styleTags, Tag } from '@lezer/highlight';
-import { type MarkdownConfig } from '@lezer/markdown';
+import { type MarkdownConfig, Table } from '@lezer/markdown';
 import get from 'lodash.get';
 
+import { mx } from '@dxos/react-ui-theme';
+
 import {
   blockquote,
   bold,
@@ -40,128 +42,166 @@ export const markdownTags = {
   ListMark: Tag.define(),
   QuoteMark: Tag.define(),
   URL: Tag.define(),
-};
 
-export const markdownTagsExtension: MarkdownConfig = {
-  props: [styleTags(markdownTags)],
+  // Custom.
+  TableCell: Tag.define(),
 };
 
+// TODO(burdon): Customize table parser (make all content monospace).
+//  https://github.com/lezer-parser/markdown/blob/main/src/extension.ts
+Table.defineNodes?.forEach((node: any) => {
+  switch (node?.name) {
+    case 'TableCell': {
+      node.style = markdownTags.TableCell;
+      break;
+    }
+  }
+});
+
+export const markdownTagsExtensions: MarkdownConfig[] = [
+  Table,
+  {
+    props: [styleTags(markdownTags)],
+  },
+];
+
 /**
  * Styling based on `lezer` parser tags.
  * https://codemirror.net/examples/styling
  * https://github.com/lezer-parser/highlight
- * https://lezer.codemirror.net/docs/ref/#highlight (list of tags)
+ * https://github.com/lezer-parser/highlight/blob/main/src/highlight.ts#L427
+ * https://lezer.codemirror.net/docs/ref/#highlight.tags (list of tags)
+ *
+ * Examples:
+ * - https://github.com/codemirror/language/blob/main/src/highlight.ts#L194
+ * - https://github.com/codemirror/theme-one-dark/blob/main/src/one-dark.ts#L115
  */
-export const markdownHighlightStyle = HighlightStyle.define(
-  [
-    {
-      tag: [
-        tags.keyword,
-        tags.name,
-        tags.deleted,
-        tags.character,
-        tags.propertyName,
-        tags.macroName,
-        tags.color,
-        tags.constant(tags.name),
-        tags.standard(tags.name),
-        tags.definition(tags.name),
-        tags.separator,
-        tags.typeName,
-        tags.className,
-        tags.number,
-        tags.changed,
-        tags.annotation,
-        tags.modifier,
-        tags.self,
-        tags.namespace,
-        tags.operator,
-        tags.operatorKeyword,
-        tags.escape,
-        tags.regexp,
-        tags.special(tags.string),
-        tags.meta,
-        tags.comment,
-        tags.atom,
-        tags.bool,
-        tags.special(tags.variableName),
-        tags.processingInstruction,
-        tags.string,
-        tags.inserted,
-        tags.invalid,
-      ],
-      color: 'inherit !important',
-    },
+export const markdownHighlightStyle = (readonly?: boolean) => {
+  return HighlightStyle.define(
+    [
+      {
+        tag: [
+          tags.keyword,
+          tags.name,
+          tags.deleted,
+          tags.character,
+          tags.propertyName,
+          tags.macroName,
+          tags.color,
+          tags.constant(tags.name),
+          tags.standard(tags.name),
+          tags.definition(tags.name),
+          tags.separator,
+          tags.typeName,
+          tags.className,
+          tags.number,
+          tags.changed,
+          tags.annotation,
+          tags.modifier,
+          tags.self,
+          tags.namespace,
+          tags.operator,
+          tags.operatorKeyword,
+          tags.escape,
+          tags.regexp,
+          tags.special(tags.string),
+          tags.meta,
+          tags.comment,
+          tags.atom,
+          tags.bool,
+          tags.special(tags.variableName),
+          tags.processingInstruction,
+          tags.string,
+          tags.inserted,
+          tags.invalid,
+        ],
+        color: 'inherit !important',
+      },
 
-    // Markdown marks.
-    {
-      tag: [
-        tags.meta,
-        tags.processingInstruction,
-        markdownTags.CodeMark,
-        markdownTags.EmphasisMark,
-        markdownTags.HeaderMark,
-        markdownTags.LinkLabel,
-        markdownTags.LinkReference,
-        markdownTags.ListMark,
-        markdownTags.QuoteMark,
-      ],
-      class: mark,
-    },
+      // Markdown marks.
+      {
+        tag: [
+          tags.meta,
+          tags.processingInstruction,
+          markdownTags.LinkLabel,
+          markdownTags.LinkReference,
+          markdownTags.ListMark,
+        ],
+        class: mark,
+      },
 
-    // Headings.
-    { tag: tags.heading1, class: heading[1] },
-    { tag: tags.heading2, class: heading[2] },
-    { tag: tags.heading3, class: heading[3] },
-    { tag: tags.heading4, class: heading[4] },
-    { tag: tags.heading5, class: heading[5] },
-    { tag: tags.heading6, class: heading[6] },
+      // Markdown marks.
+      {
+        tag: [markdownTags.CodeMark, markdownTags.HeaderMark, markdownTags.QuoteMark, markdownTags.EmphasisMark],
+        class: readonly ? 'hidden' : mark,
+      },
 
-    // Emphasis.
-    { tag: tags.emphasis, class: italic },
-    { tag: tags.strong, class: bold },
-    { tag: tags.strikethrough, class: strikethrough },
+      // E.g., code block language (after ```).
+      {
+        tag: [tags.function(tags.variableName), tags.labelName],
+        class: readonly ? 'hidden' : codeMark,
+      },
 
-    // Naked URLs.
-    {
-      tag: [markdownTags.URL],
-      class: inlineUrl,
-    },
+      {
+        tag: [tags.monospace],
+        class: 'font-mono',
+      },
 
-    // E.g., code block language (after ```).
-    {
-      tag: [tags.function(tags.variableName), tags.labelName],
-      class: codeMark,
-    },
+      // Headings.
+      { tag: tags.heading1, class: heading(1, readonly) },
+      { tag: tags.heading2, class: heading(2, readonly) },
+      { tag: tags.heading3, class: heading(3, readonly) },
+      { tag: tags.heading4, class: heading(4, readonly) },
+      { tag: tags.heading5, class: heading(5, readonly) },
+      { tag: tags.heading6, class: heading(6, readonly) },
 
-    // NOTE: The `markdown` extension configures extensions for `lezer` to parse markdown tokens (incl. below).
-    // However, since `codeLanguages` is also defined, the `lezer` will not parse fenced code blocks,
-    // when a language is specified. In this case, the syntax highlighting extensions will colorize
-    // the code, but all other CSS properties will be inherited.
-    // IMPORTANT: Therefore, the fenced code block will use the base editor font.
-    {
-      tag: [markdownTags.CodeText, markdownTags.InlineCode],
-      class: code,
-    },
+      // Emphasis.
+      { tag: tags.emphasis, class: italic },
+      { tag: tags.strong, class: bold },
+      { tag: tags.strikethrough, class: strikethrough },
 
-    {
-      tag: [markdownTags.QuoteMark],
-      class: blockquote,
-    },
+      // Naked URLs.
+      {
+        tag: [markdownTags.URL],
+        class: inlineUrl,
+      },
+
+      // NOTE: The `markdown` extension configures extensions for `lezer` to parse markdown tokens (incl. below).
+      // However, since `codeLanguages` is also defined, the `lezer` will not parse fenced code blocks,
+      // when a language is specified. In this case, the syntax highlighting extensions will colorize
+      // the code, but all other CSS properties will be inherited.
+      // IMPORTANT: Therefore, the fenced code block will use the base editor font.
+      {
+        tag: [markdownTags.CodeText, markdownTags.InlineCode],
+        class: code,
+      },
+
+      {
+        tag: [markdownTags.QuoteMark],
+        class: blockquote,
+      },
 
+      // TODO(burdon): Replace with extension.
+      {
+        tag: [markdownTags.HorizontalRule],
+        class: mx(horizontalRule, readonly && '-indent-[100rem]'),
+      },
+
+      // TODO(burdon): Only if being edited.
+      {
+        tag: [markdownTags.TableCell],
+        class: 'font-mono',
+      },
+
+      // Main content, paragraphs, etc.
+      // {
+      //   tag: [tags.content],
+      //   fontFamily: get(tokens, 'fontFamily.body', []).join(','),
+      // },
+    ],
     {
-      tag: [markdownTags.HorizontalRule],
-      class: horizontalRule,
+      scope: markdownLanguage,
+      all: { fontFamily: get(tokens, 'fontFamily.body', []).join(',') },
     },
-
-    // Main content, paragraphs, etc.
-    // {
-    //   tag: [tags.content],
-    //   fontFamily: get(tokens, 'fontFamily.body', []).join(','),
-    // },
-  ],
-  {
-    scope: markdownLanguage,
-    all: { fontFamily: get(tokens, 'fontFamily.body', []).join(',') },
-  },
-);
+  );
+};

package/src/components/TextEditor/extensions/mention.ts

@@ -0,0 +1,31 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { autocompletion, type CompletionContext, type CompletionResult } from '@codemirror/autocomplete';
+import type { Extension } from '@codemirror/state';
+
+export type MentionOptions = {
+  onSearch: (text: string) => string[];
+};
+
+export const mention = ({ onSearch }: MentionOptions): Extension => {
+  return autocompletion({
+    closeOnBlur: false, // For debugging.
+    override: [
+      (context: CompletionContext): CompletionResult | null => {
+        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/components/TextEditor/extensions/table.ts

@@ -0,0 +1,119 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { syntaxTree } from '@codemirror/language';
+import { type EditorState, type RangeSet, RangeSetBuilder, StateField, type Transaction } from '@codemirror/state';
+import { Decoration, EditorView, WidgetType } from '@codemirror/view';
+
+// TODO(burdon): Snippet to create basic table.
+//  https://codemirror.net/docs/ref/#autocomplete.snippet
+
+export type TableOptions = {};
+
+/**
+ * GFM tables.
+ * https://github.github.com/gfm/#tables-extension
+ */
+export const table = (options: TableOptions = {}) => {
+  return StateField.define<RangeSet<any>>({
+    create: (state) => update(state, options),
+    update: (_: RangeSet<any>, tr: Transaction) => update(tr.state, options),
+    provide: (field) => EditorView.decorations.from(field),
+  });
+};
+
+type Table = {
+  from: number;
+  to: number;
+  header?: string[];
+  rows?: string[][];
+};
+
+const update = (state: EditorState, options: TableOptions) => {
+  const builder = new RangeSetBuilder();
+  const cursor = state.selection.main.head;
+
+  const tables: Table[] = [];
+  const getTable = () => tables[tables.length - 1];
+  const getRow = () => {
+    const table = getTable();
+    return table.rows?.[table.rows.length - 1];
+  };
+
+  // Parse table.
+  syntaxTree(state).iterate({
+    enter: (node) => {
+      // Check if cursor is inside text.
+      switch (node.name) {
+        case 'Table': {
+          tables.push({ from: node.from, to: node.to });
+          break;
+        }
+        case 'TableHeader': {
+          getTable().header = [];
+          break;
+        }
+        case 'TableRow': {
+          (getTable().rows ??= []).push([]);
+          break;
+        }
+        case 'TableCell': {
+          const row = getRow();
+          if (row) {
+            row.push(state.sliceDoc(node.from, node.to));
+          } else {
+            getTable().header?.push(state.sliceDoc(node.from, node.to));
+          }
+          break;
+        }
+      }
+    },
+  });
+
+  tables.forEach((table) => {
+    const hide = state.readOnly || cursor < table.from || cursor > table.to;
+    hide && builder.add(table.from, table.to, Decoration.replace({ widget: new TableWidget(table) }));
+    builder.add(table.from, table.to, Decoration.mark({ class: 'cm-table' }));
+  });
+
+  return builder.finish();
+};
+
+class TableWidget extends WidgetType {
+  constructor(readonly _table: Table) {
+    super();
+  }
+
+  override eq(other: WidgetType) {
+    return this._table.from === (other as any as TableWidget)?._table?.from;
+  }
+
+  toDOM(view: EditorView) {
+    const table = document.createElement('table');
+
+    {
+      const header = table.appendChild(document.createElement('thead'));
+      const tr = header.appendChild(document.createElement('tr'));
+      this._table.header?.forEach((cell) => {
+        const th = document.createElement('th');
+        th.setAttribute('class', 'cm-table-head');
+        tr.appendChild(th).textContent = cell;
+      });
+    }
+
+    {
+      const body = table.appendChild(document.createElement('tbody'));
+      this._table.rows?.forEach((row) => {
+        const tr = body.appendChild(document.createElement('tr'));
+        row.forEach((cell) => {
+          const td = document.createElement('td');
+          td.setAttribute('class', 'cm-table-cell');
+          tr.appendChild(td).textContent = cell;
+        });
+      });
+    }
+
+    return table;
+  }
+}

package/src/components/TextEditor/extensions/tasklist.ts

@@ -12,12 +12,20 @@ import {
   type ViewUpdate,
 } from '@codemirror/view';
 
+// TODO(burdon): Reconcile with theme.
+const styles = EditorView.baseTheme({
+  '& .cm-task-item': {
+    paddingLeft: '4px',
+    paddingRight: '8px',
+  },
+});
+
 class CheckboxWidget extends WidgetType {
   constructor(
     private readonly _pos: number,
     private _checked: boolean,
     private readonly _indent: number,
-    private readonly _onCheck: (check: boolean) => void,
+    private readonly _onCheck?: (check: boolean) => void,
   ) {
     super();
   }
@@ -35,10 +43,15 @@ class CheckboxWidget extends WidgetType {
     const input = wrap.appendChild(document.createElement('input'));
     input.type = 'checkbox';
     input.checked = this._checked;
-    input.onchange = (event: Event) => {
-      this._onCheck((event.target as any).checked);
-      return true;
-    };
+    if (!this._onCheck) {
+      input.setAttribute('disabled', 'true');
+    }
+    if (this._onCheck) {
+      input.onchange = (event: Event) => {
+        this._onCheck?.((event.target as any).checked);
+        return true;
+      };
+    }
 
     return wrap;
   }
@@ -48,15 +61,9 @@ class CheckboxWidget extends WidgetType {
   }
 }
 
-// TODO(burdon): Reconcile with theme.
-const styles = EditorView.baseTheme({
-  '& .cm-task-item': {
-    paddingLeft: '4px',
-    paddingRight: '8px',
-  },
-});
+export type TasklistOptions = {};
 
-export const tasklist = () => {
+export const tasklist = (options: TasklistOptions = {}) => {
   // TODO(burdon): Matcher isn't as precise as syntax tree.
   //  Allows for indents to be greater than AST would allow.
   const taskMatcher = new MatchDecorator({
@@ -65,20 +72,27 @@ export const tasklist = () => {
       const indent = Math.floor(match[1].length / 2);
       const checked = match[2] === 'x' || match[2] === 'X';
       return Decoration.replace({
-        widget: new CheckboxWidget(pos, checked, indent, (checked) => {
-          const idx = pos + match[0].indexOf('[') + 1;
-          view.dispatch({
-            changes: {
-              from: idx,
-              to: idx + 1,
-              insert: checked ? 'x' : ' ',
-            },
-            // TODO(burdon): Restore cursor position? More useful to move to end of line (can indent).
-            selection: {
-              anchor: idx + 3,
-            },
-          });
-        }),
+        widget: new CheckboxWidget(
+          pos,
+          checked,
+          indent,
+          view.state.readOnly
+            ? undefined
+            : (checked) => {
+                const idx = pos + match[0].indexOf('[') + 1;
+                view.dispatch({
+                  changes: {
+                    from: idx,
+                    to: idx + 1,
+                    insert: checked ? 'x' : ' ',
+                  },
+                  // TODO(burdon): Restore cursor position? More useful to move to end of line (can indent).
+                  selection: {
+                    anchor: idx + 3,
+                  },
+                });
+              },
+        ),
       });
     },
   });
@@ -95,7 +109,7 @@ export const tasklist = () => {
       }
     },
     {
-      decorations: (instance) => instance.tasks,
+      decorations: (value) => value.tasks,
       provide: (plugin) =>
         EditorView.atomicRanges.of((view) => {
           return view.plugin(plugin)?.tasks || Decoration.none;

package/src/components/TextEditor/themes/default.ts

@@ -10,6 +10,11 @@ import { tokens } from '../../../styles';
 /**
  * Minimal styles.
  * https://codemirror.net/examples/styling
+ *
+ * Examples:
+ * - https://github.com/codemirror/view/blob/main/src/theme.ts
+ * - https://github.com/codemirror/theme-one-dark/blob/main/src/one-dark.ts
+ *
  * NOTE: Use one of '&', '&light', and '&dark' prefix to scope instance.
  * NOTE: `light` and `dark` selectors are preprocessed by CodeMirror and can only be in the base theme.
  */
@@ -50,10 +55,10 @@ export const defaultTheme: {
   //
   // Cursor
   //
-  '&light .cm-cursor': {
+  '&light .cm-cursor, &light .cm-dropCursor': {
     borderLeft: '2px solid black',
   },
-  '&dark .cm-cursor': {
+  '&dark .cm-cursor, &dark .cm-dropCursor': {
     borderLeft: '2px solid white',
   },
   '& .cm-placeholder': {
@@ -136,8 +141,59 @@ export const defaultTheme: {
   '& .cm-tooltip': {
     border: 'none',
   },
-  // '& .cm-tooltip-below': {},
-  // '& .cm-tooltip-autocomplete': {},
+  '& .cm-tooltip-below': {},
+
+  //
+  // autocomplete
+  //
+  '& .cm-tooltip-autocomplete': {
+    marginTop: '4px',
+    marginLeft: '-3px',
+  },
+  '& .cm-tooltip-autocomplete ul li': {},
+  '& .cm-tooltip-autocomplete ul li[aria-selected]': {},
+  '& .cm-completionIcon': {
+    display: 'none',
+  },
+  '& .cm-completionLabel': {
+    fontFamily: get(tokens, 'fontFamily.body', []).join(','),
+  },
+  '& .cm-completionMatchedText': {
+    textDecoration: 'none',
+  },
+
+  //
+  // widgets
+  //
+  '& .cm-widgetBuffer': {
+    display: 'none',
+    height: 0,
+  },
+
+  //
+  // table
+  //
+  '& .cm-table *': {
+    fontFamily: `${get(tokens, 'fontFamily.mono', []).join(',')} !important`,
+    textDecoration: 'none !important',
+  },
+  '& .cm-table-head': {
+    padding: '2px 16px 2px 0px',
+    borderBottom: `1px solid ${get(tokens, 'extend.colors.neutral.500')}`,
+    fontWeight: 100,
+    textAlign: 'left',
+    color: get(tokens, 'extend.colors.neutral.500'),
+  },
+  '& .cm-table-cell': {
+    padding: '2px 16px 2px 0px',
+  },
+
+  //
+  // image
+  //
+  '& .cm-image': {
+    margin: '0.5rem 0',
+  },
 
   //
   // font size
@@ -151,6 +207,43 @@ export const defaultTheme: {
     acc[`& .text-${fontSize} + .cm-widgetBuffer + .cm-ySelectionCaret`] = { height };
     return acc;
   }, {}),
+
+  /**
+   * Panels
+   * https://github.com/codemirror/search/blob/main/src/search.ts#L745
+   *
+   * Find/replace panel.
+   * <div class="cm-announced">...</div>
+   * <div class="cm-scroller">...</div>
+   * <div class="cm-panels cm-panels-bottom">
+   *   <div class="cm-search cm-panel">
+   *     <input class="cm-textfield" />
+   *     <button class="cm-button">...</button>
+   *     <label><input type="checkbox" />...</label>
+   *   </div>
+   * </div
+   */
+  '& .cm-panels': {
+    border: `1px solid ${get(tokens, 'extend.colors.neutral.200')}`,
+    borderBottom: 'none',
+  },
+  '& .cm-panel': {
+    background: get(tokens, 'extend.colors.neutral.50'),
+    fontFamily: get(tokens, 'fontFamily.body', []).join(','),
+  },
+  '& .cm-button': {
+    margin: '4px',
+    fontFamily: get(tokens, 'fontFamily.body', []).join(','),
+    background: get(tokens, 'extend.colors.neutral.100'),
+    border: 'none',
+  },
+
+  '& .cm-searchMatch': {
+    backgroundColor: get(tokens, 'extend.colors.yellow.100'),
+  },
+  '& .cm-searchMatch.cm-searchMatch-selected': {
+    backgroundColor: get(tokens, 'extend.colors.primary.100'),
+  },
 };
 
 export const textTheme: {

package/src/hooks/automerge/automerge.stories.tsx

@@ -9,6 +9,7 @@ import { basicSetup } from 'codemirror';
 import get from 'lodash.get';
 import React, { useEffect, useRef, useState } from 'react';
 
+// TODO(burdon): Why separate imports?
 import { type Prop } from '@dxos/automerge/automerge';
 import { type DocHandle, Repo } from '@dxos/automerge/automerge-repo';