@dxos/react-ui-editor 0.3.10-next.ef70620 → 0.3.11-main.0e40963

package/src/extensions/table.ts

@@ -0,0 +1,132 @@
+//
+// 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
+
+// TODO(burdon): Advanced formatting (left/right/center).
+// TODO(burdon): Editor to auto balance columns.
+
+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({
+          block: true,
+          widget: new TableWidget(table),
+        }),
+      );
+
+    // Add class for styling.
+    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/extensions/tasklist.ts

@@ -0,0 +1,121 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import {
+  EditorView,
+  Decoration,
+  WidgetType,
+  MatchDecorator,
+  ViewPlugin,
+  type DecorationSet,
+  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,
+  ) {
+    super();
+  }
+
+  override eq(other: CheckboxWidget) {
+    return this._pos === other._pos && this._checked === other._checked && this._indent === other._indent;
+  }
+
+  toDOM(view: EditorView) {
+    const wrap = document.createElement('span');
+    wrap.className = 'cm-task-item';
+    wrap.setAttribute('aria-hidden', 'true');
+    wrap.style.setProperty('margin-left', this._indent * 24 + 'px');
+
+    const input = wrap.appendChild(document.createElement('input'));
+    input.type = 'checkbox';
+    input.checked = this._checked;
+    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;
+  }
+
+  override ignoreEvent() {
+    return false;
+  }
+}
+
+export type TasklistOptions = {};
+
+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({
+    regexp: /^(\s*)- \[([ xX])\]\s/g,
+    decoration: (match, view, pos) => {
+      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,
+          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,
+                  },
+                });
+              },
+        ),
+      });
+    },
+  });
+
+  const tasks = ViewPlugin.fromClass(
+    class {
+      tasks: DecorationSet;
+      constructor(view: EditorView) {
+        this.tasks = taskMatcher.createDeco(view);
+      }
+
+      update(update: ViewUpdate) {
+        this.tasks = taskMatcher.updateDeco(update, this.tasks);
+      }
+    },
+    {
+      decorations: (value) => value.tasks,
+      provide: (plugin) =>
+        EditorView.atomicRanges.of((view) => {
+          return view.plugin(plugin)?.tasks || Decoration.none;
+        }),
+    },
+  );
+
+  return [tasks, styles];
+};

package/src/extensions/typewriter.ts

@@ -0,0 +1,68 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { type Extension } from '@codemirror/state';
+import { keymap } from '@codemirror/view';
+
+// TODO(burdon): Review https://github.com/sergeche/codemirror-movie?tab=readme-ov-file
+
+export type DemoOptions = {
+  delay?: number;
+  items?: string[];
+};
+
+const defaultItems = ['hello world!', 'this is a test.', 'this is [DXOS](https://dxos.org)'];
+
+/**
+ * Configurable plugin that let's user cycle through pre-configured input script.
+ */
+export const typewriter = ({ delay = 75, items = defaultItems }: DemoOptions = {}): Extension => {
+  let t: any;
+  let idx = 0; // TODO(burdon): Make global.
+
+  return [
+    keymap.of([
+      {
+        // Reset.
+        key: "alt-meta-'",
+        run: (view) => {
+          clearTimeout(t);
+          idx = 0;
+          return true;
+        },
+      },
+      {
+        // Next prompt.
+        // TODO(burdon): Press 1-9 to select prompt?
+        key: "shift-meta-'",
+        run: (view) => {
+          clearTimeout(t);
+          // TODO(burdon): Add space if needed.
+          const text = items[idx++];
+          if (idx === items?.length) {
+            idx = 0;
+          }
+
+          let i = 0;
+          const insert = (d = 0) => {
+            t = setTimeout(() => {
+              const pos = view.state.selection.main.head;
+              view.dispatch({
+                changes: { from: pos, insert: text[i++] },
+                selection: { anchor: pos + 1 },
+              });
+
+              if (i < text.length) {
+                insert(Math.random() * delay * (text[i] === ' ' ? 2 : 1));
+              }
+            }, d);
+          };
+
+          insert();
+          return true;
+        },
+      },
+    ]),
+  ];
+};

package/src/extensions/util.ts

@@ -0,0 +1,18 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { log } from '@dxos/log';
+
+/**
+ * CodeMirror callbacks swallow errors so wrap handlers.
+ */
+// TODO(burdon): Figure out how to systematize this.
+export const callbackWrapper = <T extends Function>(fn: T): T =>
+  ((...args: any[]) => {
+    try {
+      return fn(...args);
+    } catch (error) {
+      log.catch(error);
+    }
+  }) as unknown as T;

package/src/{automerge → hooks/automerge}/automerge.stories.tsx

@@ -9,10 +9,12 @@ 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';
 
-import { type IDocHandle, automergePlugin } from './automerge-plugin';
+import { type IDocHandle } from './handle';
+import { automergePlugin } from './plugin';
 
 type EditorProps = {
   handle: IDocHandle;
@@ -81,9 +83,9 @@ const Story = () => {
 };
 
 export default {
-  title: 'Automerge',
-};
-
-export const AutomergeRepo = {
+  title: 'react-ui-editor/Automerge',
+  component: Editor,
   render: () => <Story />,
 };
+
+export const Default = {};

package/src/{automerge/automerge-plugin → hooks/automerge}/plugin.ts

@@ -17,8 +17,8 @@ import { ViewPlugin, type EditorView, type PluginValue, type ViewUpdate } from '
 import * as automerge from '@dxos/automerge/automerge';
 import { type Heads, type Prop } from '@dxos/automerge/automerge';
 
-import { PatchSemaphore } from './PatchSemaphore';
 import { type IDocHandle } from './handle';
+import { PatchSemaphore } from './semaphore';
 
 export type Value = {
   lastHeads: Heads;
@@ -78,6 +78,7 @@ export const automergePlugin = (handle: IDocHandle, path: Prop[]): AutomergePlug
       return result;
     },
   });
+
   const semaphore = new PatchSemaphore(stateField);
 
   const viewPlugin = ViewPlugin.fromClass(

package/src/{automerge/automerge-plugin/PatchSemaphore.ts → hooks/automerge/semaphore.ts}

@@ -2,20 +2,25 @@
 // Copyright 2023 DXOS.org
 //
 
+// TODO(burdon): Additional copyright?
+
 import { type EditorView } from '@codemirror/view';
 
 import { next as automerge } from '@dxos/automerge/automerge';
 
-import amToCodemirror from './amToCodemirror';
-import codeMirrorToAm from './codeMirrorToAm';
 import { type IDocHandle } from './handle';
 import { type Field, isReconcileTx, getPath, reconcileAnnotationType, updateHeads, getLastHeads } from './plugin';
+import { updateAutomerge } from './update-automerge';
+import { updateCodeMirror } from './update-codemirror';
 
 type Doc<T> = automerge.Doc<T>;
 type Heads = automerge.Heads;
 
 type ChangeFn = (atHeads: Heads, change: (doc: Doc<unknown>) => void) => Heads | undefined;
 
+/**
+ * TODO(burdon): Comment.
+ */
 export class PatchSemaphore {
   _field!: Field;
   _inReconcile = false;
@@ -39,7 +44,7 @@ export class PatchSemaphore {
 
     const transactions = view.state.field(this._field).unreconciledTransactions.filter((tx) => !isReconcileTx(tx));
 
-    // First undo all the unreconciled transactions
+    // First undo all the unreconciled transactions.
     const toInvert = transactions.slice().reverse();
     for (const tx of toInvert) {
       const inverted = tx.changes.invert(tx.startState.doc);
@@ -50,19 +55,18 @@ export class PatchSemaphore {
       });
     }
 
-    // now apply the unreconciled transactions to the document
-    let newHeads = codeMirrorToAm(this._field, handle, transactions, view.state);
+    // Apply the unreconciled transactions to the document.
+    let newHeads = updateAutomerge(this._field, handle, transactions, view.state);
 
-    // NOTE: null and undefined each come from automerge and repo respectively
+    // NOTE: null and undefined each come from automerge and repo respectively.
     if (newHeads === null || newHeads === undefined) {
       // TODO: @alexjg this is the call that's resetting the editor state on click
       newHeads = automerge.getHeads(handle.docSync()!);
     }
 
-    // now get the diff between the updated state of the document and the heads
-    // and apply that to the codemirror doc
+    // Now get the diff between the updated state of the document and the heads and apply that to the codemirror doc.
     const diff = automerge.equals(oldHeads, newHeads) ? [] : automerge.diff(handle.docSync()!, oldHeads, newHeads);
-    amToCodemirror(view, selection, path, diff);
+    updateCodeMirror(view, selection, path, diff);
 
     view.dispatch({
       effects: updateHeads(newHeads),

package/src/{automerge/automerge-plugin/codeMirrorToAm.ts → hooks/automerge/update-automerge.ts}

@@ -2,6 +2,8 @@
 // Copyright 2023 DXOS.org
 //
 
+// TODO(burdon): Additional copyright?
+
 import { type EditorState, type Text, type Transaction } from '@codemirror/state';
 
 import { next as am, type Heads } from '@dxos/automerge/automerge';
@@ -9,7 +11,7 @@ import { next as am, type Heads } from '@dxos/automerge/automerge';
 import { type IDocHandle } from './handle';
 import { type Field } from './plugin';
 
-export default (
+export const updateAutomerge = (
   field: Field,
   handle: IDocHandle,
   transactions: Transaction[],
@@ -18,7 +20,7 @@ export default (
   const { lastHeads, path } = state.field(field);
 
   // We don't want to call `automerge.updateAt` if there are no changes.
-  // Otherwise later on `automerge.diff` will return empty patches that result in a no-op but still mess up the selection.
+  // Otherwise, later on `automerge.diff` will return empty patches that result in a no-op but still mess up the selection.
   let hasChanges = false;
   for (const tr of transactions) {
     tr.changes.iterChanges(() => {
@@ -37,5 +39,6 @@ export default (
       });
     }
   });
+
   return newHeads ?? undefined;
 };

package/src/{automerge/automerge-plugin/amToCodemirror.ts → hooks/automerge/update-codemirror.ts}

@@ -2,6 +2,8 @@
 // Copyright 2023 DXOS.org
 //
 
+// TODO(burdon): Additional copyright?
+
 import { ChangeSet, type ChangeSpec, type EditorSelection, type EditorState } from '@codemirror/state';
 import { type EditorView } from '@codemirror/view';
 
@@ -16,7 +18,7 @@ import {
 
 import { reconcileAnnotationType } from './plugin';
 
-export default (view: EditorView, selection: EditorSelection, target: Prop[], patches: Patch[]) => {
+export const updateCodeMirror = (view: EditorView, selection: EditorSelection, target: Prop[], patches: Patch[]) => {
   for (const patch of patches) {
     const changeSpec = handlePatch(patch, target, view.state);
     if (changeSpec != null) {
@@ -28,6 +30,7 @@ export default (view: EditorView, selection: EditorSelection, target: Prop[], pa
       });
     }
   }
+
   view.dispatch({
     selection,
     annotations: reconcileAnnotationType.of({}),

package/src/hooks/index.ts

@@ -2,6 +2,5 @@
 // Copyright 2023 DXOS.org
 //
 
-export * from './useCollaboration';
 export * from './useTextModel';
 export * from './yjs';