@ephia/dova-sdk 1.0.0

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

@@ -0,0 +1,315 @@
+import type { MonacoEditorInstance } 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;
+}
+
+type MonacoRange = { startLineNumber: number; startColumn: number; endLineNumber: number; endColumn: number };
+
+/**
+ * Binding Monaco Editor. Prend une instance duck-typée (IStandaloneCodeEditor).
+ *
+ * Même stratégie que le binding CM6 : les partials restent en mémoire et sont
+ * émis sur le DOM container. Seuls les finals s'appliquent via `model.applyEdits`.
+ */
+export function createMonacoBinding(editor: MonacoEditorInstance): TargetBinding {
+  let anchor: SessionAnchor | null = null;
+  let segments = new Map<string, SessionSegment>();
+  let pendingPartial: PendingPartial | null = null;
+
+  const getContainer = (): HTMLElement | null => editor.getDomNode();
+
+  const dispatchPartialEvent = (text: string | null, insertAt: number) => {
+    const el = getContainer();
+    if (!el) return;
+    el.dispatchEvent(
+      new CustomEvent(text === null ? "ephia:partial-cleared" : "ephia:partial", {
+        bubbles: false,
+        detail: text === null ? undefined : { text, insertAt },
+      })
+    );
+  };
+
+  const getOffset = (pos: { lineNumber: number; column: number } | null): number => {
+    if (!pos) return editor.getValue().length;
+    return editor.getModel()?.getOffsetAt(pos) ?? editor.getValue().length;
+  };
+
+  const posFromOffset = (offset: number): { lineNumber: number; column: number } => {
+    return editor.getModel()?.getPositionAt(offset) ?? { lineNumber: 1, column: 1 };
+  };
+
+  const applyEdit = (startOffset: number, endOffset: number, text: string): void => {
+    const model = editor.getModel();
+    if (!model) return;
+    const startPos = posFromOffset(startOffset);
+    const endPos = posFromOffset(endOffset);
+    const range: MonacoRange = {
+      startLineNumber: startPos.lineNumber,
+      startColumn: startPos.column,
+      endLineNumber: endPos.lineNumber,
+      endColumn: endPos.column,
+    };
+    model.applyEdits([{ range, text }]);
+    editor.setPosition(posFromOffset(startOffset + text.length));
+  };
+
+  return {
+    kind: "monaco",
+
+    attach(): void {},
+
+    detach(): void {
+      segments.clear();
+      pendingPartial = null;
+      anchor = null;
+    },
+
+    // ─── Session lifecycle ─────────────────────────────────────────────────────
+
+    beginSession(opts: BeginSessionOptions = {}): SessionAnchor {
+      const replaceSelection = opts.replaceSelection ?? true;
+      const sel = editor.getSelection();
+      const isFocused = !!(document.activeElement && getContainer()?.contains(document.activeElement));
+
+      let from: number;
+      let to: number;
+      let hadSelection = false;
+
+      if (sel && !sel.isEmpty() && isFocused) {
+        from = getOffset({ lineNumber: sel.startLineNumber, column: sel.startColumn });
+        to = getOffset({ lineNumber: sel.endLineNumber, column: sel.endColumn });
+        hadSelection = true;
+      } else if (isFocused) {
+        from = getOffset(editor.getPosition());
+        to = from;
+      } else {
+        from = editor.getValue().length;
+        to = from;
+      }
+
+      // Ne pas supprimer la sélection ici — la suppression est différée
+      // au premier insert pour que l'user voie encore le texte pendant la connexion.
+
+      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;
+    },
+
+    getRangeRect(start: number, end: number): DOMRect | null {
+      try {
+        const model = editor.getModel();
+        if (!model) return null;
+        const startPos = model.getPositionAt(start);
+        const endPos = model.getPositionAt(end);
+        const startCoords = editor.getScrolledVisiblePosition(startPos);
+        const endCoords = editor.getScrolledVisiblePosition(endPos);
+        if (!startCoords || !endCoords) return null;
+        const containerRect = getContainer()?.getBoundingClientRect();
+        if (!containerRect) return null;
+        const top = Math.min(startCoords.top, endCoords.top) + containerRect.top;
+        const bottom = Math.max(startCoords.top + startCoords.height, endCoords.top + endCoords.height) + containerRect.top;
+        const left = Math.min(startCoords.left, endCoords.left) + containerRect.left;
+        const right = Math.max(startCoords.left, endCoords.left) + containerRect.left;
+        return new DOMRect(left, top, Math.max(2, right - left), bottom - top);
+      } catch {
+        return null;
+      }
+    },
+
+    getCursorRect(): DOMRect | null {
+      return getContainer()?.getBoundingClientRect() ?? null;
+    },
+
+    // ─── Streaming ─────────────────────────────────────────────────────────────
+
+    insertPartial(segmentId: string, text: string, revision: number): void {
+      if (!anchor) {
+        const pos = getOffset(editor.getPosition());
+        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 {
+      const currentText = editor.getValue();
+
+      if (!anchor) {
+        const pos = getOffset(editor.getPosition());
+        const before = currentText.slice(0, pos);
+        const joiner = pickJoiner(before, text);
+        applyEdit(pos, pos, joiner + text);
+        return;
+      }
+
+      // Suppression lazy de la sélection au premier commit
+      if (anchor.selectionPendingDelete && anchor.initialEnd > anchor.initialStart) {
+        applyEdit(anchor.initialStart, anchor.initialEnd, "");
+        anchor.end = anchor.initialStart;
+        anchor.selectionPendingDelete = false;
+      }
+
+      if (pendingPartial?.segmentId === segmentId) {
+        const insertAt = pendingPartial.insertAt;
+        const before = editor.getValue().slice(0, insertAt);
+        const joiner = pickJoiner(before, text);
+        const full = joiner + text;
+
+        dispatchPartialEvent(null, 0);
+        applyEdit(insertAt, insertAt, full);
+
+        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;
+          applyEdit(existing.start, existing.end, text);
+          existing.end = existing.start + text.length;
+          existing.revision += 1;
+          anchor.end += text.length - oldLen;
+        } else {
+          const before = editor.getValue().slice(0, anchor.end);
+          const joiner = pickJoiner(before, text);
+          const full = joiner + text;
+          applyEdit(anchor.end, anchor.end, full);
+          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 editor.getValue();
+    },
+
+    getCursorOffset(): number | null {
+      return getOffset(editor.getPosition());
+    },
+
+    getSelection() {
+      const sel = editor.getSelection();
+      if (!sel || sel.isEmpty()) return null;
+      const from = getOffset({ lineNumber: sel.startLineNumber, column: sel.startColumn });
+      const to = getOffset({ lineNumber: sel.endLineNumber, column: sel.endColumn });
+      return {
+        text: editor.getValue().slice(from, to),
+        range: { start: from, end: to },
+      };
+    },
+
+    applyOperation(operation: DocumentOperation): void {
+      const text = editor.getValue();
+      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;
+          applyEdit(start, end, operation.replacement);
+          if (anchor) anchor.end += operation.replacement.length - (end - start);
+          break;
+        }
+        case "insert": {
+          let pos = getOffset(editor.getPosition());
+          if (typeof operation.position === "number") pos = operation.position;
+          else if (operation.position === "end") pos = text.length;
+          else if (operation.position === "start") pos = 0;
+          applyEdit(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;
+          applyEdit(start, end, "");
+          if (anchor) anchor.end -= (end - start);
+          break;
+        }
+        case "replace_all": {
+          const model = editor.getModel();
+          if (!model) break;
+          const len = text.length;
+          applyEdit(0, len, operation.replacement);
+          segments.clear();
+          if (anchor) anchor.end = operation.replacement.length;
+          break;
+        }
+        default:
+          console.warn("[monacoBinding] Operation not supported:", operation.type);
+      }
+    },
+  };
+}