@dxos/react-ui-editor 0.3.10-main.5515dfe → 0.3.10-main.560f82b

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

@@ -2,35 +2,29 @@
 // Copyright 2023 DXOS.org
 //
 
-// TODO(burdon): Automcomplete: https://codemirror.net/5/doc/manual.html#addon_runmode
-// TODO(burdon): Modes: parallel parsing and decoration (e.g., associated with language).
-// TODO(burdon): Add-on: runmode: run lexer over content (with rendering codemirror).
-//  https://codemirror.net/5/doc/manual.html#addon_runmode
-// TODO(burdon): Add-on: dialog.
-// TODO(burdon): Comments: https://codemirror.net/5/doc/manual.html#setBookmark
-// TODO(burdon): Split view: https://codemirror.net/examples/split
-
 // https://codemirror.net/examples/autocompletion
 // https://codemirror.net/docs/ref/#autocomplete.autocompletion
 // https://codemirror.net/docs/ref/#autocomplete.Completion
 
 import {
   autocompletion,
+  completionKeymap,
   type Completion,
   type CompletionContext,
-  completionKeymap,
   type CompletionResult,
 } from '@codemirror/autocomplete';
 import { keymap } from '@codemirror/view';
 
+export type AutocompleteResult = Completion;
+
 export type AutocompleteOptions = {
-  getOptions: (text: string) => Completion[];
+  onSearch: (text: string) => Completion[];
 };
 
 /**
  * Autocomplete extension.
  */
-export const autocomplete = ({ getOptions }: AutocompleteOptions) => {
+export const autocomplete = ({ onSearch }: AutocompleteOptions) => {
   return [
     // https://codemirror.net/docs/ref/#view.keymap
     // https://discuss.codemirror.net/t/how-can-i-replace-the-default-autocompletion-keymap-v6/3322
@@ -49,21 +43,14 @@ export const autocomplete = ({ getOptions }: AutocompleteOptions) => {
       // TODO(burdon): Optional decoration via addToOptions
       override: [
         (context: CompletionContext): CompletionResult | null => {
-          const word = context.matchBefore(/\w*/);
-          if (!word || (word.from === word.to && !context.explicit)) {
+          const match = context.matchBefore(/\w*/);
+          if (!match || (match.from === match.to && !context.explicit)) {
             return null;
           }
 
-          // TODO(burdon): Option to convert to links?
           return {
-            from: word.from,
-            options: getOptions(word.text.toLowerCase()),
-            // options: [
-            //   { label: 'apple', type: 'keyword' },
-            //   { label: 'amazon', type: 'keyword' },
-            //   { label: 'hello', type: 'variable', info: '(World)' },
-            //   { label: 'magic', type: 'text', apply: '⠁⭒*.✩.*⭒⠁', detail: 'macro' },
-            // ],
+            from: match.from,
+            options: onSearch(match.text.toLowerCase()),
           };
         },
       ],

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

@@ -11,11 +11,12 @@ import { EditorView, placeholder } from '@codemirror/view';
 import type { ThemeMode } from '@dxos/react-ui';
 
 export type BasicBundleOptions = {
+  readonly?: boolean;
   themeMode?: ThemeMode;
   placeholder?: string;
 };
 
-export const basicBundle = ({ themeMode, placeholder: _placeholder }: BasicBundleOptions): Extension[] =>
+export const basicBundle = ({ readonly, themeMode, placeholder: _placeholder }: BasicBundleOptions): Extension[] =>
   [
     // TODO(burdon): Compare with minimalSetup.
     // https://codemirror.net/docs/ref/#codemirror.minimalSetup

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

@@ -0,0 +1,375 @@
+//
+// Copyright 2023 DXOS.org
+// Based on a demo by Joel Besada and Kushagra Gour.
+// https://twitter.com/JoelBesada/status/670343885655293952
+// https://github.com/chinchang/code-blast-codemirror/blob/master/code-blast.js
+//
+
+import { type Extension, StateField } from '@codemirror/state';
+import { EditorView, keymap } from '@codemirror/view';
+import defaultsDeep from 'lodash.defaultsdeep';
+
+import { invariant } from '@dxos/invariant';
+
+export type BlastOptions = {
+  effect?: number;
+  maxParticles: number;
+  particleGravity: number;
+  particleAlphaFadeout: number;
+  particleSize: { min: number; max: number };
+  particleNumRange: { min: number; max: number };
+  particleVelocityRange: { x: [number, number]; y: [number, number] };
+  particleShrinkRate: number;
+  shakeIntensity: number;
+  color?: () => number[];
+};
+
+export const defaultOptions: BlastOptions = {
+  maxParticles: 200,
+  particleGravity: 0.08,
+  particleAlphaFadeout: 0.996,
+  particleSize: { min: 2, max: 8 },
+  particleNumRange: { min: 5, max: 10 },
+  particleVelocityRange: { x: [-1, 1], y: [-3.5, -1.5] },
+  particleShrinkRate: 0.95,
+  shakeIntensity: 5,
+};
+
+export const blast = (options: Partial<BlastOptions>): Extension => {
+  let blaster: Blaster | undefined;
+  let last = 0;
+
+  const getPoint = (view: EditorView, pos: number) => {
+    const { left: x = 0, top: y = 0 } = view.coordsForChar(pos) ?? {};
+    const element = document.elementFromPoint(x, y);
+
+    const { offsetLeft: left = 0, offsetTop: top = 0 } = view.scrollDOM.parentElement ?? {};
+    const point = { x: x - left, y: y - top };
+
+    return { element, point };
+  };
+
+  return [
+    // Cursor moved.
+    EditorView.updateListener.of((update) => {
+      // NOTE: The MarkdownEditor may recreated the EditorView.
+      if (blaster?.node !== update.view.scrollDOM) {
+        if (blaster) {
+          blaster.destroy();
+        }
+
+        blaster = new Blaster(update.view.scrollDOM, defaultsDeep({}, options, defaultOptions));
+        blaster.initialize();
+        blaster.start(); // TODO(burdon): Stop/clean-up.
+      } else {
+        blaster.resize();
+      }
+
+      const current = update.view.state.selection.main.head;
+      if (current !== last) {
+        last = current;
+        // TODO(burdon): Null if end of line.
+        const { element, point } = getPoint(update.view, current);
+        if (element && point) {
+          blaster.spawn({ element, point });
+        }
+      }
+    }),
+
+    // Document changed.
+    StateField.define({
+      create: () => null,
+      update: (_value, transaction) => {
+        if (blaster && transaction.docChanged) {
+          // TODO(burdon): Only on delete.
+          const view = EditorView.findFromDOM(blaster.node)!;
+          const { element, point } = getPoint(view, transaction.selection!.main.head);
+          if (element && point) {
+            blaster.spawn({ element, point });
+          }
+        }
+
+        return null;
+      },
+    }),
+
+    keymap.of([
+      {
+        any: (view, event) => {
+          if (blaster && event.key === 'Enter' && event.shiftKey) {
+            blaster.shake({ time: 0.4 });
+          }
+
+          return false;
+        },
+      },
+    ]),
+  ];
+};
+
+//
+// Blaster (no CM deps).
+//
+
+class Blaster {
+  _canvas: HTMLCanvasElement | undefined;
+  _ctx: CanvasRenderingContext2D | undefined | null;
+
+  private readonly _effect: Effect;
+
+  _running = false;
+  _lastTime: number | undefined;
+  _shakeTime = 0;
+  _shakeTimeMax = 0;
+
+  _particles: Particle[] = [];
+  _particlePointer = 0;
+
+  _lastPoint = { x: 0, y: 0 };
+
+  constructor(private readonly _node: HTMLElement, private readonly _options: BlastOptions) {
+    this._effect = this._options.effect === 1 ? new Effect1(_options) : new Effect2(_options);
+  }
+
+  get node() {
+    return this._node;
+  }
+
+  initialize() {
+    // console.log('initialize');
+    invariant(!this._canvas && !this._ctx);
+
+    this._canvas = document.createElement('canvas');
+    this._canvas.id = 'code-blast-canvas';
+    this._canvas.style.position = 'absolute';
+    this._canvas.style.zIndex = '0';
+    this._canvas.style.pointerEvents = 'none';
+    // this._canvas.style.border = '2px solid red';
+
+    this._ctx = this._canvas.getContext('2d');
+
+    const parent = this._node.parentElement?.parentElement;
+    parent?.appendChild(this._canvas);
+
+    this.resize();
+  }
+
+  destroy() {
+    this.stop();
+    // console.log('destroy');
+    if (this._canvas) {
+      this._canvas.remove();
+      this._canvas = undefined;
+      this._ctx = undefined;
+    }
+  }
+
+  resize() {
+    if (this._node.parentElement && this._canvas) {
+      const { offsetLeft: x, offsetTop: y, offsetWidth: width, offsetHeight: height } = this._node.parentElement;
+      this._canvas.style.top = `${y}px`;
+      this._canvas.style.left = `${x}px`;
+      this._canvas.width = width;
+      this._canvas.height = height;
+    }
+  }
+
+  start() {
+    // console.log('start');
+    invariant(this._canvas && this._ctx);
+    this._running = true;
+    this.loop();
+  }
+
+  stop() {
+    // console.log('stop');
+    this._running = false;
+    this._node.style.transform = 'translate(0px, 0px)';
+  }
+
+  loop() {
+    if (!this._running || !this._canvas || !this._ctx) {
+      return;
+    }
+
+    this._ctx.clearRect(0, 0, this._canvas.width ?? 0, this._canvas.height ?? 0);
+
+    // Calculate the delta from the previous frame.
+    const now = new Date().getTime();
+    this._lastTime ??= now;
+    const dt = (now - this._lastTime) / 1000;
+    this._lastTime = now;
+
+    if (this._shakeTime > 0) {
+      this._shakeTime -= dt;
+      const magnitude = (this._shakeTime / this._shakeTimeMax) * this._options.shakeIntensity;
+      const shakeX = random(-magnitude, magnitude);
+      const shakeY = random(-magnitude, magnitude);
+      this._node!.style.transform = `translate(${shakeX}px,${shakeY}px)`;
+    }
+
+    this.drawParticles();
+
+    requestAnimationFrame(this.loop.bind(this));
+  }
+
+  shake = throttle<{ time: number }>(({ time }) => {
+    this._shakeTime = this._shakeTimeMax;
+    this._shakeTimeMax = time;
+  }, 100);
+
+  spawn = throttle<{ element: Element; point: { x: number; y: number } }>(({ element, point }) => {
+    const color = getRGBComponents(element, this._options.color);
+    const numParticles = random(this._options.particleNumRange.min, this._options.particleNumRange.max);
+    const dir = this._lastPoint.x === point.x ? 0 : this._lastPoint.x < point.x ? 1 : -1;
+    this._lastPoint = point;
+    for (let i = numParticles; i--; i > 0) {
+      this._particles[this._particlePointer] = this._effect.create(point.x - dir * 16, point.y, color);
+      this._particlePointer = (this._particlePointer + 1) % this._options.maxParticles;
+    }
+  }, 100);
+
+  drawParticles() {
+    for (let i = this._particles.length; i--; i > 0) {
+      const particle = this._particles[i];
+      if (!particle) {
+        continue;
+      }
+
+      if (particle.alpha < 0.01 || particle.size <= 0.5) {
+        continue;
+      }
+
+      this._effect.update(this._ctx!, particle);
+    }
+  }
+}
+
+//
+// Effects
+//
+
+type Particle = {
+  x: number;
+  y: number;
+  vx: number;
+  vy: number;
+  size: number;
+  color: (string | number)[];
+  alpha: number;
+  theta?: number;
+  drag?: number;
+  wander?: number;
+};
+
+abstract class Effect {
+  constructor(protected readonly _options: BlastOptions) {}
+  abstract create(x: number, y: number, color: Particle['color']): Particle;
+  abstract update(ctx: CanvasRenderingContext2D, particle: Particle): void;
+}
+
+class Effect1 extends Effect {
+  create(x: number, y: number, color: Particle['color']) {
+    return {
+      x,
+      y: y + 10,
+      vx: random(this._options.particleVelocityRange.x[0], this._options.particleVelocityRange.x[1]),
+      vy: random(this._options.particleVelocityRange.y[0], this._options.particleVelocityRange.y[1]),
+      size: random(this._options.particleSize.min, this._options.particleSize.max),
+      color,
+      alpha: 1,
+    };
+  }
+
+  update(ctx: CanvasRenderingContext2D, particle: Particle) {
+    particle.vy += this._options.particleGravity;
+    particle.x += particle.vx;
+    particle.y += particle.vy;
+    particle.alpha *= this._options.particleAlphaFadeout;
+
+    ctx.fillStyle = `rgba(${particle.color[0]},${particle.color[1]},${particle.color[2]},${particle.alpha})`;
+    ctx.fillRect(Math.round(particle.x - 1), Math.round(particle.y - 1), particle.size, particle.size);
+  }
+}
+
+/**
+ * Based on Soulwire's demo.
+ * http://codepen.io/soulwire/pen/foktm
+ */
+class Effect2 extends Effect {
+  create(x: number, y: number, color: Particle['color']) {
+    return {
+      x,
+      y: y + 10,
+      vx: random(this._options.particleVelocityRange.x[0], this._options.particleVelocityRange.x[1]),
+      vy: random(this._options.particleVelocityRange.y[0], this._options.particleVelocityRange.y[1]),
+      size: random(this._options.particleSize.min, this._options.particleSize.max),
+      color,
+      alpha: 1,
+      theta: (random(0, 360) * Math.PI) / 180,
+      drag: 0.92,
+      wander: 0.15,
+    };
+  }
+
+  update(ctx: CanvasRenderingContext2D, particle: Particle) {
+    particle.vy += this._options.particleGravity;
+    particle.x += particle.vx;
+    particle.y += particle.vy;
+    particle.vx *= particle.drag!;
+    particle.vy *= particle.drag!;
+    particle.theta! += random(-0.5, 0.5);
+    particle.vx += Math.sin(particle.theta!) * 0.1;
+    particle.vy += Math.cos(particle.theta!) * 0.1;
+    particle.size *= this._options.particleShrinkRate;
+    particle.alpha *= this._options.particleAlphaFadeout;
+
+    ctx.fillStyle = `rgba(${particle.color[0]},${particle.color[1]},${particle.color[2]},${particle.alpha})`;
+    ctx.beginPath();
+    ctx.arc(Math.round(particle.x - 1), Math.round(particle.y - 1), particle.size, 0, 2 * Math.PI);
+    ctx.fill();
+  }
+}
+
+//
+// Utils
+//
+
+function throttle<T>(callback: (arg: T) => void, limit: number): (arg: T) => void {
+  let wait = false;
+  return function (...args: any[]) {
+    if (!wait) {
+      // @ts-ignore
+      callback.apply(this, args);
+      wait = true;
+      setTimeout(() => {
+        wait = false;
+      }, limit);
+    }
+  };
+}
+
+const getRGBComponents = (node: Element, color: BlastOptions['color']): Particle['color'] => {
+  if (typeof color === 'function') {
+    return color();
+  }
+
+  const bgColor = getComputedStyle(node).color;
+  if (bgColor) {
+    const x = bgColor.match(/(\d+), (\d+), (\d+)/)?.slice(1);
+    if (x) {
+      return x;
+    }
+  }
+
+  return [50, 50, 50];
+};
+
+const random = (min: number, max: number) => {
+  if (!max) {
+    max = min;
+    min = 0;
+  }
+
+  return min + ~~(Math.random() * (max - min + 1));
+};

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

@@ -0,0 +1,190 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { type Extension } from '@codemirror/state';
+import {
+  keymap,
+  type DecorationSet,
+  type Rect,
+  type ViewUpdate,
+  Decoration,
+  EditorView,
+  MatchDecorator,
+  ViewPlugin,
+  WidgetType,
+} from '@codemirror/view';
+
+import { debounce } from '@dxos/async';
+import { invariant } from '@dxos/invariant';
+
+// 1. TODO(burdon): Make atomic (for tasklist also).
+//    - https://discuss.codemirror.net/t/easily-track-remove-content-with-decorations/4606
+//    - https://discuss.codemirror.net/t/creating-atomic-replace-decorations/2961
+//    - https://codemirror.net/docs/ref/#state.EditorState%5EtransactionFilter (transaction filter: move, delete).
+// 2. TODO(burdon): Create/track threads in composer (change global state). Select/follow. Scroll with page.
+//    - Separate from chat/search.
+// 3. TODO(burdon): Support multiple threads in sidebar?
+// 4. TODO(burdon): Anchor AI thread when creating section.
+// 5. TODO(burdon): Button to resolve thread to close comments.
+
+// 6. TODO(burdon): Perf: Update existing rangeset.
+//  https://discuss.codemirror.net/t/rangeset-with-metadata-and-different-decorations/3874
+
+// TODO(burdon): Import note (performance):
+//  Easily track & remove content with decorations
+//  https://discuss.codemirror.net/t/easily-track-remove-content-with-decorations/4606
+
+class BookmarkWidget extends WidgetType {
+  constructor(private readonly _pos: number, private readonly _id: string) {
+    super();
+    invariant(this._id);
+  }
+
+  override eq(other: BookmarkWidget) {
+    return this._id === other._id;
+  }
+
+  override toDOM() {
+    const span = document.createElement('span');
+    span.className = 'cm-bookmark';
+    // TODO(burdon): Call out to react?
+    // https://emojifinder.com/comment
+    span.textContent = '💬';
+    return span;
+  }
+}
+
+// TODO(burdon): Reconcile with theme.
+const styles = EditorView.baseTheme({
+  '& .cm-bookmark': {
+    cursor: 'pointer',
+    margin: '4px',
+    padding: '4px',
+    backgroundColor: 'yellow',
+  },
+  '& .cm-bookmark-selected': {
+    backgroundColor: 'orange',
+  },
+});
+
+type CommentsInfo = {
+  active?: string;
+  items: { id: string; pos: number; location: Rect | null }[];
+};
+
+export type CommentsOptions = {
+  key?: string;
+  onCreate?: () => string | void;
+  onUpdate?: (info: CommentsInfo) => void;
+};
+
+// https://www.markdownguide.org/extended-syntax/#footnotes
+// TODO(burdon): Record span in automerge model?
+// TODO(burdon): Extended markdown: https://www.markdownguide.org/extended-syntax
+export const comments = (options: CommentsOptions = {}): Extension => {
+  let active: string | undefined;
+
+  const bookmarkMatcher = new MatchDecorator({
+    regexp: /\[\^(\w+)\]/g,
+    decoration: (match, view, pos) => {
+      const id = match[1];
+      return Decoration.replace({
+        id,
+        widget: new BookmarkWidget(pos, id),
+      });
+    },
+  });
+
+  const bookmarks = ViewPlugin.fromClass(
+    class {
+      bookmarks: DecorationSet;
+      constructor(view: EditorView) {
+        this.bookmarks = bookmarkMatcher.createDeco(view);
+      }
+
+      update(update: ViewUpdate) {
+        this.bookmarks = bookmarkMatcher.updateDeco(update, this.bookmarks);
+      }
+    },
+    {
+      decorations: (instance) => instance.bookmarks,
+      provide: (plugin) =>
+        EditorView.atomicRanges.of((view) => {
+          return view.plugin(plugin)?.bookmarks || Decoration.none;
+        }),
+    },
+  );
+
+  const doUpdate = debounce((data: CommentsInfo) => {
+    options.onUpdate?.(data);
+  }, 200);
+
+  return [
+    keymap.of([
+      {
+        key: options?.key ?? 'shift-meta-c',
+        run: (view) => {
+          // Insert footnote.
+          const id = options.onCreate?.();
+          if (id) {
+            const pos = view.state.selection.main.head;
+            const tag = `[^${id}]`;
+            view.dispatch({
+              changes: { from: pos, insert: tag },
+              selection: { anchor: pos + tag.length },
+            });
+
+            return true;
+          }
+
+          return false;
+        },
+      },
+    ]),
+
+    bookmarks,
+
+    // Monitor cursor movement.
+    EditorView.updateListener.of((update) => {
+      active = undefined;
+      if (!options.onUpdate) {
+        return;
+      }
+
+      const view = update.view;
+      const pos = view.state.selection.main.head;
+
+      const decorations: { from: number; to: number; value: Decoration }[] = [];
+      const rangeSet = view.plugin(bookmarks)?.bookmarks;
+      let closest = Infinity;
+      // TODO(burdon): Always shows entire document?
+      const { from, to } = view.visibleRanges?.[0] ?? { from: 0, to: view.state.doc.length };
+      rangeSet?.between(from, to, (from, to, value) => {
+        decorations.push({ from, to, value });
+        const d = Math.min(Math.abs(pos - from), Math.abs(pos - to));
+        if (d < closest) {
+          // TODO(burdon): Update class of selected.
+          active = value.spec.id;
+          closest = d;
+        }
+      });
+
+      if (decorations.length) {
+        doUpdate({
+          active,
+          items: decorations.map(
+            ({
+              from,
+              value: {
+                spec: { id },
+              },
+            }) => ({ id: id as string, pos: from, location: view.coordsAtPos(from) }),
+          ),
+        });
+      }
+    }),
+
+    styles,
+  ];
+};