@kalada/codemirror 0.1.0 → 0.2.0

package/dist/index.js

@@ -1,20 +1,95 @@
-import { autocompletion, completionKeymap, closeCompletion } from '@codemirror/autocomplete';
-import { history, historyKeymap } from '@codemirror/commands';
-import { setDiagnostics } from '@codemirror/lint';
-import { StateEffect, StateField, Compartment, EditorState, Transaction, EditorSelection, Text } from '@codemirror/state';
-import { showTooltip, ViewPlugin, hoverTooltip as hoverTooltip$1, keymap, EditorView, closeHoverTooltips } from '@codemirror/view';
+import { NeutralEditorSession } from './chunk-GCHU6EL7.js';
 
-// src/session.ts
-function detectLineSeparator(text) {
-  if (text.includes("\r\n")) return "\r\n";
-  if (text.includes("\r")) return "\r";
-  return "\n";
-}
-function textForEditor(text) {
-  return Text.of(text.split(/\r\n|\r|\n/u));
-}
-function textFromEditor(document, lineSeparator) {
-  return document.sliceString(0, document.length, lineSeparator);
+// src/kalada-provider.ts
+var KaladaProvider = class {
+  service;
+  uri;
+  hovers = /* @__PURE__ */ new WeakMap();
+  identities = /* @__PURE__ */ new WeakMap();
+  constructor(service, uri) {
+    this.service = service;
+    this.uri = uri;
+  }
+  isCurrent(identity) {
+    const original = this.identities.get(identity);
+    return !!original && this.service.isCurrent(original);
+  }
+  diagnostics(request) {
+    const result = this.service.diagnostics(this.uri, cancellation(request));
+    if (result.kind !== "diagnostics" || !this.service.isCurrent(result)) return null;
+    return this.tagged(
+      request,
+      result,
+      result.diagnostics.map((item) => ({
+        ...item.source ? this.range(item.source.range) : { from: 0, to: 0 },
+        message: item.message,
+        severity: "error"
+      }))
+    );
+  }
+  completion(request, offset) {
+    const result = this.service.completion(
+      this.uri,
+      this.document().lineIndex.positionAt(offset),
+      cancellation(request)
+    );
+    if (result.kind !== "completion" || !this.service.isCurrent(result)) return null;
+    return this.tagged(
+      request,
+      result,
+      result.items.map((item) => ({
+        label: item.label,
+        edit: { ...this.range(item.edit.range), text: item.edit.text },
+        type: item.kind === "binding" ? "variable" : item.kind,
+        detail: `${item.support}, ${item.presence}`,
+        boost: item.support === "common" ? 10 : 0
+      }))
+    );
+  }
+  hover(request, offset) {
+    const result = this.service.hover(
+      this.uri,
+      this.document().lineIndex.positionAt(offset),
+      cancellation(request)
+    );
+    if (result.kind !== "hover" || !result.hover || !this.service.isCurrent(result)) return null;
+    const hover = { ...this.range(result.hover.range), content: "" };
+    this.hovers.set(hover, result.hover);
+    return this.tagged(request, result, hover);
+  }
+  format(request) {
+    const result = this.service.format(this.uri, cancellation(request));
+    if (result.kind !== "format" || !result.edit || !this.service.isCurrent(result)) return null;
+    return this.tagged(request, result, {
+      ...this.range(result.edit.range),
+      text: result.edit.text
+    });
+  }
+  tagged(request, original, value) {
+    const result = {
+      uri: this.uri,
+      version: request.snapshot.version,
+      environmentGeneration: request.snapshot.environmentGeneration,
+      value
+    };
+    this.identities.set(result, original);
+    return result;
+  }
+  range(source) {
+    const document = this.document();
+    return {
+      from: document.lineIndex.offsetAt(source.start),
+      to: document.lineIndex.offsetAt(source.end)
+    };
+  }
+  document() {
+    const document = this.service.getDocument(this.uri);
+    if (!document) throw new Error("Kalada editor document is not open");
+    return document;
+  }
+};
+function cancellation(request) {
+  return { cancellation: { isCancellationRequested: () => request.signal.aborted } };
 }
 
 // src/render.ts
@@ -66,6 +141,17 @@ function evidenceText(evidence) {
   return `${evidence.code} at ${evidence.path.join(".") || "root"}`;
 }
 
+// src/session-helpers.ts
+function wholeReplacement(snapshot, text) {
+  return {
+    range: {
+      start: { line: 0, character: 0 },
+      end: snapshot.lineIndex.positionAt(snapshot.text.length)
+    },
+    text
+  };
+}
+
 // src/translation.ts
 function changesToEdits(startDoc, newDoc, changes, snapshot, lineSeparator = "\n") {
   const offsets = [];
@@ -81,14 +167,6 @@ function changesToEdits(startDoc, newDoc, changes, snapshot, lineSeparator = "\n
   if (translated.every((edit) => edit !== null)) return translated;
   return [wholeDocumentEdit(snapshot, newDoc.sliceString(0, newDoc.length, lineSeparator))];
 }
-function rangeToOffsets(document, range) {
-  const from = offsetAt(document, range.start.line, range.start.character);
-  const to = offsetAt(document, range.end.line, range.end.character);
-  return from === null || to === null || from > to ? null : { from, to };
-}
-function diagnosticOffsets(document, range) {
-  return rangeToOffsets(document, range) ?? { from: 0, to: 0 };
-}
 function offsetEdit(edit, document, index) {
   const start = positionAt(document, edit.from);
   const end = positionAt(document, edit.to);
@@ -99,14 +177,6 @@ function positionAt(document, offset) {
   const line = document.lineAt(offset);
   return { line: line.number - 1, character: offset - line.from };
 }
-function offsetAt(document, line, character) {
-  if (!Number.isSafeInteger(line) || !Number.isSafeInteger(character) || line < 0 || character < 0) {
-    return null;
-  }
-  if (line >= document.lines) return null;
-  const found = document.line(line + 1);
-  return character <= found.length ? found.from + character : null;
-}
 function coalesceInserts(edits) {
   const output = [];
   for (const edit of edits) {
@@ -127,345 +197,76 @@ function wholeDocumentEdit(snapshot, text) {
   };
 }
 
-// src/session-helpers.ts
-function positionAt2(document, offset) {
-  const line = document.lineAt(offset);
-  return { line: line.number - 1, character: offset - line.from };
-}
-function translatedTooltip(result, view) {
-  const range = result.hover ? rangeToOffsets(view.state.doc, result.hover.range) : null;
-  if (!range || !result.hover) return null;
-  return { ...hoverTooltip(result.hover, range.from), end: range.to };
-}
-function translateDiagnostic(diagnostic, view) {
-  const range = diagnostic.source ? diagnosticOffsets(view.state.doc, diagnostic.source.range) : { from: 0, to: 0 };
-  return { ...range, severity: "error", message: diagnostic.message };
-}
-function animationWindow(view) {
-  const window = view.dom.ownerDocument.defaultView;
-  if (!window) throw new Error("CodeMirror view has no window");
-  return window;
-}
-function wholeReplacement(snapshot, text) {
+// src/session.ts
+function createKaladaEditorSession(options) {
+  const { service } = options;
+  const opened = service.openDocument(options.document);
+  let disposed = false;
+  const provider = new KaladaProvider(service, opened.uri);
+  const committed = /* @__PURE__ */ new WeakMap();
+  const core = new NeutralEditorSession(
+    {
+      document: opened,
+      ariaLabel: "Kalada expression editor",
+      provider,
+      onDocumentChange: (identity) => {
+        const snapshot = committed.get(identity);
+        if (snapshot) options.onDocumentChange?.(snapshot);
+      }
+    },
+    kaladaBridge(provider, (identity, snapshot) => committed.set(identity, snapshot))
+  );
   return {
-    range: {
-      start: { line: 0, character: 0 },
-      end: snapshot.lineIndex.positionAt(snapshot.text.length)
+    extension: core.extension,
+    refreshEnvironment: () => core.refreshEnvironment(),
+    replaceDocument: (text) => core.replaceDocument(text),
+    format() {
+      const formatted = core.format();
+      if (typeof formatted !== "boolean") throw new Error("Kalada formatting must be synchronous");
+      return formatted;
     },
-    text
-  };
-}
-var setKeyboardTooltip = StateEffect.define();
-var keyboardTooltipField = StateField.define({
-  create: () => [],
-  update(value, transaction) {
-    let next = value;
-    for (const effect of transaction.effects) {
-      if (effect.is(setKeyboardTooltip)) next = effect.value ? [effect.value] : [];
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      core.dispose();
+      service.closeDocument(opened.uri);
     }
-    return next;
-  },
-  provide: (field) => showTooltip.computeN([field], (state) => state.field(field))
-});
-
-// src/session.ts
-function createKaladaEditorSession(options) {
-  return new EditorSession(options);
+  };
 }
-var EditorSession = class {
-  extension;
-  service;
-  uri;
-  onDocumentChange;
-  lineSeparator = new Compartment();
-  view = null;
-  expectedText;
-  revision;
-  disposed = false;
-  viewEpoch = 0;
-  completionEpoch = 0;
-  hoverEpoch = 0;
-  diagnosticsEpoch = 0;
-  diagnosticsFrame = null;
-  constructor(options) {
-    this.service = options.service;
-    this.uri = options.document.uri;
-    this.onDocumentChange = options.onDocumentChange;
-    const opened = this.service.openDocument(options.document);
-    this.expectedText = opened.text;
-    this.revision = opened.version;
-    this.extension = this.createExtension();
-  }
-  refreshEnvironment() {
-    this.assertOpen();
-    this.invalidateRequests();
-    const view = this.view;
-    if (!view) return;
-    this.clearEditor(view, false);
-    this.scheduleDiagnostics(view);
-  }
-  replaceDocument(text) {
-    this.assertOpen();
-    if (typeof text !== "string") throw new TypeError("Replacement text must be a string");
-    const view = this.view;
-    if (view) {
-      const separator = detectLineSeparator(text);
-      view.dispatch({
-        changes: { from: 0, to: view.state.doc.length, insert: textForEditor(text) },
-        selection: EditorSelection.cursor(0),
-        annotations: Transaction.addToHistory.of(true),
-        effects: separator === view.state.lineBreak ? void 0 : this.lineSeparator.reconfigure(EditorState.lineSeparator.of(separator))
-      });
-      return;
-    }
-    const current = this.requireDocument();
-    const snapshot = this.service.updateDocument({
-      uri: this.uri,
-      version: this.nextRevision(),
-      edits: [wholeReplacement(current, text)]
-    });
-    this.expectedText = snapshot.text;
-    this.invalidateRequests();
-    this.notify(snapshot);
-  }
-  format() {
-    this.assertOpen();
-    const view = this.view;
-    if (!view) return false;
-    const epoch = this.completionEpoch;
-    const result = this.service.format(this.uri, {
-      cancellation: this.cancellation("completion", epoch)
-    });
-    if (result.kind !== "format" || !result.edit || !this.publishable(result, view, epoch, "completion")) {
-      return false;
-    }
-    const range = rangeToOffsets(view.state.doc, result.edit.range);
-    if (!range) return false;
-    view.dispatch({
-      changes: { ...range, insert: textForEditor(result.edit.text) },
-      annotations: Transaction.addToHistory.of(true)
-    });
-    return true;
-  }
-  dispose() {
-    if (this.disposed) return;
-    this.disposed = true;
-    this.invalidateRequests();
-    this.cancelDiagnosticsFrame();
-    const view = this.view;
-    if (view) this.clearEditor(view, true);
-    this.view = null;
-    this.service.closeDocument(this.uri);
-  }
-  createExtension() {
-    const session = this;
-    const lifecycle = ViewPlugin.define((view) => {
-      session.attach(view);
-      return {
-        update(update) {
-          session.updateView(update);
-        },
-        destroy() {
-          session.detach(view);
-        }
-      };
-    });
-    return [
-      lifecycle,
-      this.lineSeparator.of(EditorState.lineSeparator.of(detectLineSeparator(this.expectedText))),
-      history(),
-      autocompletion({ override: [(context) => this.complete(context)] }),
-      hoverTooltip$1((view, position) => this.pointerHover(view, position)),
-      keyboardTooltipField,
-      keymap.of([
-        ...completionKeymap,
-        ...historyKeymap,
-        { key: "Mod-Shift-h", run: (view) => this.keyboardHover(view) },
-        { key: "Escape", run: (view) => this.clearInteractions(view) }
-      ]),
-      EditorView.contentAttributes.of({ "aria-label": "Kalada expression editor" })
-    ];
-  }
-  attach(view) {
-    this.assertOpen();
-    if (this.view && this.view !== view)
-      throw new Error("Kalada editor session already has a view");
-    if (textFromEditor(view.state.doc, view.state.lineBreak) !== this.expectedText) {
-      throw new Error("CodeMirror document does not match the opened Kalada document");
-    }
-    this.view = view;
-    this.viewEpoch += 1;
-    this.scheduleDiagnostics(view);
-  }
-  detach(view) {
-    if (this.view !== view) return;
-    this.cancelDiagnosticsFrame();
-    this.invalidateRequests();
-    this.view = null;
-    this.viewEpoch += 1;
-  }
-  updateView(update) {
-    if (this.disposed || !update.docChanged) return;
-    this.invalidateRequests();
-    for (const transaction of update.transactions) {
-      if (transaction.docChanged) this.applyTransaction(transaction);
-    }
-    this.expectedText = textFromEditor(update.state.doc, update.state.lineBreak);
-    this.scheduleDiagnostics(update.view);
-  }
-  applyTransaction(transaction) {
-    const current = this.requireDocument();
-    const startText = textFromEditor(transaction.startState.doc, transaction.startState.lineBreak);
-    if (current.text !== startText) {
-      throw new Error("CodeMirror and language-service snapshots diverged");
-    }
-    const edits = changesToEdits(
-      transaction.startState.doc,
-      transaction.newDoc,
-      transaction.changes,
-      current,
-      transaction.state.lineBreak
-    );
-    const snapshot = this.service.updateDocument({
-      uri: this.uri,
-      version: this.nextRevision(),
-      edits
-    });
-    if (snapshot.text !== textFromEditor(transaction.newDoc, transaction.state.lineBreak)) {
-      throw new Error("CodeMirror transaction translation changed document text");
-    }
-    this.expectedText = snapshot.text;
-    this.notify(snapshot);
-  }
-  complete(context) {
-    const view = this.view;
-    if (!view || view.state !== context.state || this.disposed) return null;
-    const epoch = ++this.completionEpoch;
-    const result = this.service.completion(this.uri, positionAt2(context.state.doc, context.pos), {
-      cancellation: this.cancellation("completion", epoch)
-    });
-    if (result.kind !== "completion" || !this.publishable(result, view, epoch, "completion")) {
-      return null;
-    }
-    const translated = result.items.map(
-      (item) => this.translateCompletion(item, result, view, epoch)
-    );
-    const available = translated.filter((entry) => entry !== null);
-    const first = available[0];
-    return first ? { from: first.from, to: first.to, options: available.map(({ option }) => option) } : null;
-  }
-  translateCompletion(item, identity, view, epoch) {
-    const range = rangeToOffsets(view.state.doc, item.edit.range);
-    if (!range) return null;
-    const option = {
-      label: item.label,
-      type: item.kind === "binding" ? "variable" : item.kind,
-      detail: `${item.support}, ${item.presence}`,
-      boost: item.support === "common" ? 10 : 0,
-      apply: (target) => this.applyCompletion(target, item, identity, epoch)
-    };
-    return { ...range, option };
-  }
-  applyCompletion(view, item, identity, epoch) {
-    if (!this.publishable(identity, view, epoch, "completion")) return;
-    const range = rangeToOffsets(view.state.doc, item.edit.range);
-    if (!range) return;
-    view.dispatch({ changes: { ...range, insert: item.edit.text } });
-  }
-  pointerHover(view, offset) {
-    return this.requestHover(view, offset);
-  }
-  keyboardHover(view) {
-    const tooltip = this.requestHover(view, view.state.selection.main.head);
-    if (!tooltip) return false;
-    view.dispatch({ effects: setKeyboardTooltip.of(tooltip) });
-    return true;
-  }
-  requestHover(view, offset) {
-    const epoch = ++this.hoverEpoch;
-    const result = this.service.hover(this.uri, positionAt2(view.state.doc, offset), {
-      cancellation: this.cancellation("hover", epoch)
-    });
-    if (result.kind !== "hover" || !result.hover || !this.publishable(result, view, epoch, "hover")) {
-      return null;
-    }
-    return translatedTooltip(result, view);
-  }
-  clearInteractions(view) {
-    this.clearEditor(view, false);
-    view.focus();
-    return true;
-  }
-  clearEditor(view, diagnostics) {
-    closeCompletion(view);
-    const interactions = { effects: [setKeyboardTooltip.of(null), closeHoverTooltips] };
-    if (diagnostics) view.dispatch(interactions, setDiagnostics(view.state, []));
-    else view.dispatch(interactions);
-  }
-  scheduleDiagnostics(view) {
-    this.cancelDiagnosticsFrame();
-    const epoch = ++this.diagnosticsEpoch;
-    const viewEpoch = this.viewEpoch;
-    this.diagnosticsFrame = animationWindow(view).requestAnimationFrame(() => {
-      this.diagnosticsFrame = null;
-      const result = this.service.diagnostics(this.uri, {
-        cancellation: this.cancellation("diagnostics", epoch)
+function kaladaBridge(provider, committed) {
+  return {
+    filterCompletions: true,
+    isCurrent: (identity) => provider.isCurrent(identity),
+    matches(snapshot) {
+      const current = provider.service.getDocument(provider.uri);
+      return !!current && current.uri === snapshot.uri && current.version === snapshot.version && current.text === snapshot.text;
+    },
+    changed(snapshot, previous, transaction) {
+      const current = provider.service.getDocument(provider.uri);
+      if (!current || current.text !== previous.text || current.version !== previous.version)
+        throw new Error("CodeMirror and language-service snapshots diverged");
+      const updated = provider.service.updateDocument({
+        uri: provider.uri,
+        version: snapshot.version,
+        edits: transaction ? changesToEdits(
+          transaction.startState.doc,
+          transaction.newDoc,
+          transaction.changes,
+          current,
+          transaction.state.lineBreak
+        ) : [wholeReplacement(current, snapshot.text)]
       });
-      if (result.kind !== "diagnostics" || !this.publishable(result, view, epoch, "diagnostics"))
-        return;
-      if (this.viewEpoch !== viewEpoch) return;
-      view.dispatch(
-        setDiagnostics(
-          view.state,
-          result.diagnostics.map((entry) => translateDiagnostic(entry, view))
-        )
-      );
-    });
-  }
-  cancelDiagnosticsFrame() {
-    if (this.diagnosticsFrame === null || !this.view) return;
-    animationWindow(this.view).cancelAnimationFrame(this.diagnosticsFrame);
-    this.diagnosticsFrame = null;
-  }
-  cancellation(kind, epoch) {
-    return {
-      isCancellationRequested: () => this.disposed || this.epoch(kind) !== epoch
-    };
-  }
-  publishable(identity, view, epoch, kind) {
-    return !this.disposed && this.view === view && this.epoch(kind) === epoch && "status" in identity && identity.status === "current" && this.service.isCurrent(identity);
-  }
-  epoch(kind) {
-    if (kind === "completion") return this.completionEpoch;
-    if (kind === "hover") return this.hoverEpoch;
-    return this.diagnosticsEpoch;
-  }
-  invalidateRequests() {
-    this.completionEpoch += 1;
-    this.hoverEpoch += 1;
-    this.diagnosticsEpoch += 1;
-  }
-  nextRevision() {
-    if (this.revision >= Number.MAX_SAFE_INTEGER)
-      throw new RangeError("Kalada document revision exhausted");
-    this.revision += 1;
-    return this.revision;
-  }
-  requireDocument() {
-    const document = this.service.getDocument(this.uri);
-    if (!document) throw new Error("Kalada editor document is not open");
-    return document;
-  }
-  notify(snapshot) {
-    try {
-      this.onDocumentChange?.(snapshot);
-    } catch {
+      if (updated.text !== snapshot.text)
+        throw new Error("CodeMirror transaction translation changed document text");
+      committed(snapshot, updated);
+    },
+    renderHover(hover, from, to) {
+      const info = provider.hovers.get(hover);
+      if (!info) throw new Error("Missing Kalada hover presentation");
+      return { ...hoverTooltip(info, from), end: to };
     }
-  }
-  assertOpen() {
-    if (this.disposed) throw new Error("Kalada editor session is disposed");
-  }
-};
+  };
+}
 
 export { createKaladaEditorSession };
 //# sourceMappingURL=index.js.map