@pixerate/editor 0.59.0 → 0.61.0

package/dist/{chunk-WLVZ235X.js → chunk-OK7T2LHK.js}

@@ -14,6 +14,10 @@ import {
   normalizeChartSpec
 } from "./chunk-633QC34G.js";
 import {
+  plainTextToSlice
+} from "./chunk-UKI64KUD.js";
+import {
+  TRACK_CHANGES_SKIP_META,
   isTrackChangesEnabled
 } from "./chunk-SWE3NPOU.js";
 
@@ -1999,6 +2003,217 @@ function createTableStore(editor) {
   };
 }
 
+// src/extensions/agent-caret.ts
+import { Extension } from "@tiptap/core";
+import { Plugin as Plugin3, PluginKey as PluginKey3 } from "@tiptap/pm/state";
+import { Decoration, DecorationSet } from "@tiptap/pm/view";
+var DEFAULT_AGENT_CARET_COLOR = "#8b5cf6";
+var DEFAULT_AGENT_CARET_NAME = "Agent";
+var agentCaretPluginKey = new PluginKey3("agentCaret");
+var clamp = (pos, size) => Math.max(0, Math.min(size, Math.round(pos)));
+function caretWidget(caret) {
+  return (view) => {
+    const doc = view.dom.ownerDocument;
+    const el = doc.createElement("span");
+    el.className = "pe-agent-caret";
+    el.setAttribute("data-agent-id", caret.id);
+    el.setAttribute("contenteditable", "false");
+    el.setAttribute("aria-hidden", "true");
+    el.style.cssText = `position:relative;margin-left:-1px;margin-right:-1px;border-left:2px solid ${caret.color};word-break:normal;pointer-events:none;`;
+    const label = doc.createElement("span");
+    label.className = "pe-agent-caret-label";
+    label.textContent = caret.name;
+    label.style.cssText = `position:absolute;left:-2px;bottom:100%;background:${caret.color};color:#fff;font:600 11px/1.5 system-ui,sans-serif;padding:0 5px;border-radius:3px 3px 3px 0;white-space:nowrap;user-select:none;pointer-events:none;`;
+    el.append("\u2060", label, "\u2060");
+    return el;
+  };
+}
+var tint = (color, percent) => `color-mix(in srgb, ${color} ${percent}%, transparent)`;
+function buildDecorations(state, carets) {
+  const decorations = [];
+  for (const caret of carets) {
+    for (const range of caret.changed) {
+      decorations.push(
+        Decoration.inline(range.from, range.to, {
+          class: "pe-agent-changed",
+          "data-agent-id": caret.id,
+          style: `background-color:${tint(caret.color, 18)};`
+        })
+      );
+    }
+    const from = Math.min(caret.anchor, caret.head);
+    const to = Math.max(caret.anchor, caret.head);
+    if (from < to) {
+      decorations.push(
+        Decoration.inline(from, to, {
+          class: "pe-agent-selection",
+          "data-agent-id": caret.id,
+          style: `background-color:${tint(caret.color, 28)};`
+        })
+      );
+    }
+    decorations.push(
+      Decoration.widget(caret.head, caretWidget(caret), {
+        key: `agent-caret:${caret.id}:${caret.name}:${caret.color}`,
+        side: 10,
+        ignoreSelection: true
+      })
+    );
+  }
+  return DecorationSet.create(state.doc, decorations);
+}
+function createAgentCaretPlugin() {
+  return new Plugin3({
+    key: agentCaretPluginKey,
+    state: {
+      init: (_, state) => ({ carets: [], spans: {}, decorations: DecorationSet.create(state.doc, []) }),
+      apply(tr, value, _old, state) {
+        const meta = tr.getMeta(agentCaretPluginKey);
+        if (!tr.docChanged && !meta) return value;
+        const size = state.doc.content.size;
+        let carets = value.carets;
+        let spans = value.spans;
+        if (tr.docChanged) {
+          const anchorBias = (c) => c.anchor <= c.head ? 1 : -1;
+          carets = carets.map((c) => ({
+            ...c,
+            anchor: tr.mapping.map(c.anchor, anchorBias(c)),
+            head: tr.mapping.map(c.head, -anchorBias(c)),
+            changed: c.changed.map((r) => ({ from: tr.mapping.map(r.from, 1), to: tr.mapping.map(r.to, -1) })).filter((r) => r.from < r.to)
+          }));
+          const own = !!meta && "span" in meta;
+          spans = Object.fromEntries(
+            Object.entries(spans).map(([id, s]) => {
+              const from = tr.mapping.map(s.from, 1);
+              return [id, { from, to: Math.max(from, tr.mapping.map(s.to, -1)), foreign: s.foreign || !own }];
+            })
+          );
+        }
+        if (meta && "set" in meta) {
+          const input = meta.set;
+          const prev = carets.find((c) => c.id === input.id);
+          const anchor = clamp(input.from, size);
+          const caret = {
+            id: input.id,
+            name: input.name ?? prev?.name ?? DEFAULT_AGENT_CARET_NAME,
+            color: input.color ?? prev?.color ?? DEFAULT_AGENT_CARET_COLOR,
+            anchor,
+            head: input.to === void 0 ? anchor : clamp(input.to, size),
+            changed: prev?.changed ?? []
+          };
+          carets = prev ? carets.map((c) => c.id === input.id ? caret : c) : [...carets, caret];
+        } else if (meta && "clear" in meta) {
+          carets = meta.clear === null ? [] : carets.filter((c) => c.id !== meta.clear);
+        } else if (meta && "changed" in meta) {
+          const { id, ranges } = meta.changed;
+          carets = carets.map(
+            (c) => c.id === id ? { ...c, changed: ranges.map((r) => ({ from: clamp(r.from, size), to: clamp(r.to, size) })).filter((r) => r.from < r.to) } : c
+          );
+        } else if (meta && "span" in meta) {
+          const span = meta.span;
+          spans = { ...spans };
+          if ("end" in span) delete spans[span.id];
+          else spans[span.id] = { from: span.from, to: span.to, foreign: spans[span.id]?.foreign ?? false };
+        }
+        return { carets, spans, decorations: buildDecorations(state, carets) };
+      }
+    },
+    props: {
+      decorations: (state) => agentCaretPluginKey.getState(state)?.decorations
+    }
+  });
+}
+var AgentCaret = Extension.create({
+  name: "agentCaret",
+  addProseMirrorPlugins() {
+    return [createAgentCaretPlugin()];
+  }
+});
+function ensureAgentCaret(editor) {
+  if (editor.isDestroyed || agentCaretPluginKey.getState(editor.state)) return;
+  editor.registerPlugin(createAgentCaretPlugin());
+}
+function dispatchMeta(editor, meta) {
+  if (editor.isDestroyed) return;
+  ensureAgentCaret(editor);
+  editor.view.dispatch(editor.state.tr.setMeta(agentCaretPluginKey, meta).setMeta("addToHistory", false));
+}
+function setAgentCaret(editor, caret) {
+  dispatchMeta(editor, { set: caret });
+}
+function clearAgentCaret(editor, id) {
+  if (editor.isDestroyed || !agentCaretPluginKey.getState(editor.state)) return;
+  dispatchMeta(editor, { clear: id ?? null });
+}
+function markAgentChanges(editor, id, ranges) {
+  if (!ranges.length && !agentCaretPluginKey.getState(editor.state)) return;
+  dispatchMeta(editor, { changed: { id, ranges } });
+}
+function getAgentCarets(state) {
+  return agentCaretPluginKey.getState(state)?.carets ?? [];
+}
+function replaceWithTextTransaction(state, from, to, text) {
+  return /[\r\n]/.test(text) ? state.tr.replace(from, to, plainTextToSlice(text, state.schema)) : text ? state.tr.insertText(text, from, to) : state.tr.delete(from, to);
+}
+var NO_HISTORY = (tr) => tr.setMeta("addToHistory", false).setMeta(TRACK_CHANGES_SKIP_META, true);
+var cannotAnimate = () => typeof document === "undefined" || document.hidden === true;
+async function typeAgentText(editor, options) {
+  const { from, to, text, caret, signal } = options;
+  const cps = options.charsPerSecond ?? 60;
+  const chars = Array.from(text);
+  ensureAgentCaret(editor);
+  const show = (tr, anchor, head = anchor) => tr.setMeta(agentCaretPluginKey, { set: { ...caret, from: anchor, to: head } });
+  const commit = (start, end) => {
+    const tr = replaceWithTextTransaction(editor.state, start, end, text);
+    const insertedTo = tr.mapping.map(end, 1);
+    const insertedFrom = Math.min(tr.mapping.map(start, -1), insertedTo);
+    editor.view.dispatch(show(tr, insertedTo).scrollIntoView());
+    if (insertedFrom < insertedTo) markAgentChanges(editor, caret.id, [{ from: insertedFrom, to: insertedTo }]);
+    return { from: insertedFrom, to: insertedTo };
+  };
+  const animate = Number.isFinite(cps) && cps > 0 && chars.length > 0 && (options.wait || !cannotAnimate());
+  if (!animate) return commit(from, to);
+  const wait = options.wait ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const duration = Math.min(options.maxDurationMs ?? 1500, chars.length / cps * 1e3);
+  const frameMs = 1e3 / 30;
+  const frames = Math.max(1, Math.min(chars.length, Math.round(duration / frameMs)));
+  const original = editor.state.doc.slice(from, to);
+  const inverses = [];
+  const span = () => agentCaretPluginKey.getState(editor.state).spans[caret.id];
+  editor.view.dispatch(NO_HISTORY(editor.state.tr.setMeta(agentCaretPluginKey, { span: { id: caret.id, from, to } })));
+  editor.view.dispatch(NO_HISTORY(show(editor.state.tr, from, to)));
+  const rollback = () => {
+    const s = span();
+    const tr = editor.state.tr;
+    if (!s.foreign) inverses.slice().reverse().forEach((step) => tr.step(step));
+    else tr.replace(s.from, s.to, original);
+    tr.setMeta(agentCaretPluginKey, { span: { id: caret.id, end: true } });
+    editor.view.dispatch(NO_HISTORY(tr));
+    return { from: s.from, to: s.from + original.size };
+  };
+  try {
+    if (from < to) await wait(options.selectMs ?? 250);
+    for (let i = 1; i <= frames; i++) {
+      if (signal?.aborted) throw new Error("Typing was cancelled; the document is unchanged.");
+      if (editor.isDestroyed) throw new Error("The editor was closed while the agent was typing.");
+      const s = span();
+      const prefix = chars.slice(0, Math.round(chars.length * i / frames)).join("");
+      const tr = replaceWithTextTransaction(editor.state, s.from, s.to, prefix);
+      tr.steps.forEach((step, k) => inverses.push(step.invert(tr.docs[k])));
+      const end = tr.mapping.map(s.to, 1);
+      tr.setMeta(agentCaretPluginKey, { span: { id: caret.id, from: Math.min(tr.mapping.map(s.from, -1), end), to: end } });
+      editor.view.dispatch(NO_HISTORY(tr));
+      editor.view.dispatch(NO_HISTORY(show(editor.state.tr, end)));
+      if (i < frames) await wait(duration / frames);
+    }
+  } catch (error) {
+    if (!editor.isDestroyed) rollback();
+    throw error;
+  }
+  const restored = rollback();
+  return commit(restored.from, restored.to);
+}
+
 export {
   ALLOW_NESTED_TABLES_META,
   tableNestingPluginKey,
@@ -2057,6 +2272,18 @@ export {
   runTableAction,
   EMPTY_TABLE_STATE,
   getTableState,
-  createTableStore
+  createTableStore,
+  DEFAULT_AGENT_CARET_COLOR,
+  DEFAULT_AGENT_CARET_NAME,
+  agentCaretPluginKey,
+  createAgentCaretPlugin,
+  AgentCaret,
+  ensureAgentCaret,
+  setAgentCaret,
+  clearAgentCaret,
+  markAgentChanges,
+  getAgentCarets,
+  replaceWithTextTransaction,
+  typeAgentText
 };
-//# sourceMappingURL=chunk-WLVZ235X.js.map
+//# sourceMappingURL=chunk-OK7T2LHK.js.map