@ephia/dova-sdk 1.0.0

package/src/core/bindings/targets/codemirror.binding.ts

@@ -0,0 +1,293 @@
+import type { CMEditorView } from "../../../shared/types/editors";
+import type {
+  BeginSessionOptions,
+  SessionAnchor,
+  TargetBinding,
+} from "../TargetBinding";
+import { pickJoiner } from "../TargetBinding";
+import type { DocumentOperation } from "ephia-protocol";
+
+interface SessionSegment {
+  start: number;
+  end: number;
+  revision: number;
+}
+
+interface PendingPartial {
+  segmentId: string;
+  text: string;
+  insertAt: number;
+  revision: number;
+}
+
+/**
+ * Binding CodeMirror 6. Prend une `EditorView` duck-typed.
+ *
+ * Les partials ne sont PAS écrits dans le document CM6 — ils restent en mémoire
+ * et sont émis via `ephia:partial` sur le container DOM pour un éventuel overlay.
+ * Seuls les finals (`commitFinal`) s'appliquent via `view.dispatch`.
+ */
+export function createCodeMirrorBinding(view: CMEditorView): TargetBinding {
+  let anchor: SessionAnchor | null = null;
+  let segments = new Map<string, SessionSegment>();
+  let pendingPartial: PendingPartial | null = null;
+
+  const container = view.dom;
+
+  const getDocLength = () => view.state.doc.length;
+  const getText = () => view.state.doc.toString();
+
+  const dispatchEdit = (from: number, to: number, insert: string, newCursor?: number) => {
+    const changes = { from, to, insert };
+    const selectionAnchor = newCursor ?? from + insert.length;
+    view.dispatch({ changes, selection: { anchor: selectionAnchor } });
+  };
+
+  const dispatchPartialEvent = (text: string | null, insertAt: number) => {
+    container.dispatchEvent(
+      new CustomEvent(text === null ? "ephia:partial-cleared" : "ephia:partial", {
+        bubbles: false,
+        detail: text === null ? undefined : { text, insertAt },
+      })
+    );
+  };
+
+  return {
+    kind: "codemirror",
+
+    attach(): void {},
+
+    detach(): void {
+      segments.clear();
+      pendingPartial = null;
+      anchor = null;
+    },
+
+    // ─── Session lifecycle ─────────────────────────────────────────────────────
+
+    beginSession(opts: BeginSessionOptions = {}): SessionAnchor {
+      const replaceSelection = opts.replaceSelection ?? true;
+      const sel = view.state.selection.main;
+      const isFocused = document.activeElement === view.contentDOM || view.contentDOM.contains(document.activeElement);
+
+      let from: number;
+      let to: number;
+      let hadSelection = false;
+
+      if (!sel.empty && isFocused) {
+        from = sel.from;
+        to = sel.to;
+        hadSelection = true;
+      } else if (isFocused) {
+        from = sel.head;
+        to = sel.head;
+      } else {
+        from = getDocLength();
+        to = from;
+      }
+
+      // Ne pas supprimer la sélection ici — différé au premier insert.
+
+      anchor = {
+        initialStart: from,
+        initialEnd: to,        // conserver la vraie fin de sélection
+        hadSelection,
+        end: from,             // point d'insertion = début de sélection
+        selectionPendingDelete: hadSelection && replaceSelection,
+      };
+      segments.clear();
+      pendingPartial = null;
+      return anchor;
+    },
+
+    endSession(): void {
+      if (pendingPartial) dispatchPartialEvent(null, 0);
+      anchor = null;
+      segments.clear();
+      pendingPartial = null;
+    },
+
+    getSessionAnchor(): SessionAnchor | null {
+      return anchor;
+    },
+
+    getCursorRect(): DOMRect | null {
+      // CM6 expose getBoundingClientRect via les coordonnées du curseur
+      try {
+        const pos = anchor?.end ?? view.state.selection.main.head;
+        const coords = (view as unknown as { coordsAtPos?: (pos: number) => { top: number; bottom: number; left: number } | null }).coordsAtPos?.(pos);
+        if (!coords) return container.getBoundingClientRect();
+        const height = coords.bottom - coords.top;
+        return new DOMRect(coords.left, coords.top, 2, height);
+      } catch {
+        return container.getBoundingClientRect();
+      }
+    },
+
+    // ─── Streaming ─────────────────────────────────────────────────────────────
+
+    insertPartial(segmentId: string, text: string, revision: number): void {
+      if (!anchor) {
+        const pos = view.state.selection.main.head;
+        anchor = { initialStart: pos, initialEnd: pos, hadSelection: false, end: pos, selectionPendingDelete: false };
+      }
+
+      if (pendingPartial?.segmentId === segmentId) {
+        if (revision < pendingPartial.revision) return;
+        pendingPartial.text = text;
+        pendingPartial.revision = revision;
+      } else {
+        pendingPartial = { segmentId, text, insertAt: anchor.end, revision };
+      }
+
+      dispatchPartialEvent(text, pendingPartial.insertAt);
+    },
+
+    commitFinal(segmentId: string, text: string): void {
+      if (!anchor) {
+        const pos = view.state.selection.main.head;
+        const before = getText().slice(0, pos);
+        const joiner = pickJoiner(before, text);
+        dispatchEdit(pos, pos, joiner + text);
+        return;
+      }
+
+      // Suppression lazy de la sélection au premier commit
+      if (anchor.selectionPendingDelete && anchor.initialEnd > anchor.initialStart) {
+        dispatchEdit(anchor.initialStart, anchor.initialEnd, "");
+        anchor.end = anchor.initialStart;
+        anchor.selectionPendingDelete = false;
+      }
+
+      if (pendingPartial?.segmentId === segmentId) {
+        const insertAt = pendingPartial.insertAt;
+        const before = getText().slice(0, insertAt);
+        const joiner = pickJoiner(before, text);
+        const full = joiner + text;
+
+        dispatchPartialEvent(null, 0);
+        dispatchEdit(insertAt, insertAt, full, insertAt + full.length);
+
+        segments.set(segmentId, { start: insertAt + joiner.length, end: insertAt + full.length, revision: 0 });
+        anchor.end = insertAt + full.length;
+        pendingPartial = null;
+      } else {
+        const existing = segments.get(segmentId);
+        if (existing) {
+          const oldLen = existing.end - existing.start;
+          dispatchEdit(existing.start, existing.end, text, existing.start + text.length);
+          existing.end = existing.start + text.length;
+          existing.revision += 1;
+          anchor.end += text.length - oldLen;
+        } else {
+          const before = getText().slice(0, anchor.end);
+          const joiner = pickJoiner(before, text);
+          const full = joiner + text;
+          dispatchEdit(anchor.end, anchor.end, full, anchor.end + full.length);
+          segments.set(segmentId, { start: anchor.end + joiner.length, end: anchor.end + full.length, revision: 0 });
+          anchor.end += full.length;
+        }
+      }
+    },
+
+    clearPartial(segmentId: string): void {
+      if (pendingPartial?.segmentId === segmentId) {
+        pendingPartial = null;
+        dispatchPartialEvent(null, 0);
+      }
+    },
+
+    clearAll(): void {
+      if (pendingPartial) {
+        pendingPartial = null;
+        dispatchPartialEvent(null, 0);
+      }
+    },
+
+    getSegmentRange(segmentId: string): { start: number; end: number } | null {
+      const seg = segments.get(segmentId);
+      return seg ? { start: seg.start, end: seg.end } : null;
+    },
+
+    getText(): string {
+      return getText();
+    },
+
+    getRangeRect(start: number, end: number): DOMRect | null {
+      try {
+        const startCoords = (view as unknown as { coordsAtPos?: (pos: number) => { top: number; bottom: number; left: number; right: number } | null }).coordsAtPos?.(start);
+        const endCoords = (view as unknown as { coordsAtPos?: (pos: number) => { top: number; bottom: number; left: number; right: number } | null }).coordsAtPos?.(end);
+        if (!startCoords || !endCoords) return null;
+        const top = Math.min(startCoords.top, endCoords.top);
+        const bottom = Math.max(startCoords.bottom, endCoords.bottom);
+        const left = Math.min(startCoords.left, endCoords.left);
+        const right = Math.max(startCoords.right, endCoords.right);
+        return new DOMRect(left, top, Math.max(2, right - left), bottom - top);
+      } catch {
+        return null;
+      }
+    },
+
+    getCursorOffset(): number | null {
+      return view.state.selection.main.head;
+    },
+
+    getSelection() {
+      const sel = view.state.selection.main;
+      if (sel.empty) return null;
+      const text = getText();
+      return {
+        text: text.slice(sel.from, sel.to),
+        range: { start: sel.from, end: sel.to },
+      };
+    },
+
+    applyOperation(operation: DocumentOperation): void {
+      const text = getText();
+      switch (operation.type) {
+        case "replace": {
+          let start: number, end: number;
+          if (operation.range) {
+            start = operation.range.start;
+            end = operation.range.end;
+          } else if (operation.targetText) {
+            const idx = text.indexOf(operation.targetText);
+            if (idx === -1) return;
+            start = idx; end = idx + operation.targetText.length;
+          } else return;
+          dispatchEdit(start, end, operation.replacement);
+          if (anchor) anchor.end += operation.replacement.length - (end - start);
+          break;
+        }
+        case "insert": {
+          let pos = view.state.selection.main.head;
+          if (typeof operation.position === "number") pos = operation.position;
+          else if (operation.position === "end") pos = text.length;
+          else if (operation.position === "start") pos = 0;
+          dispatchEdit(pos, pos, operation.text);
+          break;
+        }
+        case "delete": {
+          let start: number, end: number;
+          if (operation.range) {
+            start = operation.range.start; end = operation.range.end;
+          } else if (operation.targetText) {
+            const idx = text.indexOf(operation.targetText);
+            if (idx === -1) return;
+            start = idx; end = idx + operation.targetText.length;
+          } else return;
+          dispatchEdit(start, end, "");
+          if (anchor) anchor.end -= (end - start);
+          break;
+        }
+        case "replace_all":
+          view.dispatch({ changes: { from: 0, to: text.length, insert: operation.replacement } });
+          segments.clear();
+          if (anchor) anchor.end = operation.replacement.length;
+          break;
+        default:
+          console.warn("[codeMirrorBinding] Operation not supported:", operation.type);
+      }
+    },
+  };
+}