kindy-editor 3.2.6 → 3.2.8

package/dist-lib/index-D5dkvB0x.js

@@ -0,0 +1,490 @@
+import { t as I } from "./qrcode-CR8i1-w0.js";
+const w = "1.0";
+function M(o) {
+  const e = /* @__PURE__ */ new Set();
+  for (const n of o)
+    switch (n.type) {
+      case "insertText":
+      case "insertRuns":
+      case "splitParagraph":
+        e.add(n.at.blockId), n.type === "splitParagraph" && e.add(n.newBlockId);
+        break;
+      case "mergeParagraphs":
+        e.add(n.firstBlockId);
+        break;
+      case "insertBlock":
+        e.add(n.block.id);
+        break;
+      case "setTableRow":
+      case "setTableStructure":
+      case "setTableStyleRef":
+      case "insertTableRow":
+      case "removeTableRow":
+      case "setRowHeight":
+      case "insertTableColumn":
+      case "removeTableColumn":
+        e.add(n.tableId);
+        break;
+      case "deleteRange":
+      case "setRuns":
+      case "setParaStyle":
+      case "removeBlock":
+      case "setImageProps":
+      case "setEquation":
+      case "setEquationAlign":
+      case "setTableColFractions":
+      case "setTableWidthMode":
+      case "setTablePreferredWidth":
+      case "setTableAlign":
+      case "setTableProps":
+        e.add(n.blockId);
+        break;
+    }
+  return [...e];
+}
+function S(o, e) {
+  const n = { type: "review.operation.applied", data: { operation: o, remote: e } };
+  switch (o.type) {
+    case "addSuggestion":
+      return [n, { type: "review.suggestion.created", data: { suggestionId: o.s.id, kind: o.s.kind, remote: e } }];
+    case "removeSuggestion":
+      return [n, { type: "review.suggestion.removed", data: { suggestionId: o.id, remote: e } }];
+    case "growSuggestion":
+      return [n];
+    case "addThread": {
+      const s = o.t.comments[0];
+      return s ? [
+        n,
+        { type: "review.thread.created", data: { threadId: o.t.id, remote: e } },
+        {
+          type: "review.comment.added",
+          data: {
+            threadId: o.t.id,
+            commentId: s.id,
+            authorId: s.author.id,
+            isReply: !1,
+            mentionedUserIds: (s.mentions ?? []).map((t) => t.id),
+            remote: e
+          }
+        }
+      ] : [n, { type: "review.thread.created", data: { threadId: o.t.id, remote: e } }];
+    }
+    case "removeThread":
+      return [n, { type: "review.thread.removed", data: { threadId: o.id, remote: e } }];
+    case "addComment":
+      return [n, {
+        type: "review.comment.added",
+        data: {
+          threadId: o.threadId,
+          commentId: o.c.id,
+          authorId: o.c.author.id,
+          isReply: !0,
+          mentionedUserIds: (o.c.mentions ?? []).map((s) => s.id),
+          remote: e
+        }
+      }];
+    case "removeComment":
+      return [n, { type: "review.comment.removed", data: { threadId: o.threadId, commentId: o.commentId, remote: e } }];
+    case "editComment":
+      return [n, {
+        type: "review.comment.edited",
+        data: {
+          threadId: o.threadId,
+          commentId: o.commentId,
+          mentionedUserIds: (o.mentions ?? []).map((s) => s.id),
+          newlyMentionedUserIds: o.newlyMentionedUserIds ?? [],
+          remote: e
+        }
+      }];
+    case "deleteComment":
+      return [n, {
+        type: "review.comment.deleted",
+        data: {
+          threadId: o.threadId,
+          commentId: o.commentId,
+          deletedByUserId: o.deletedBy.id,
+          remote: e
+        }
+      }];
+    case "setThreadStatus":
+      return [n, { type: "review.thread.status.changed", data: { threadId: o.threadId, status: o.status, remote: e } }];
+  }
+}
+function p(o) {
+  if (o.length === 0) return [];
+  const e = /* @__PURE__ */ new Map();
+  for (const s of o) {
+    let t = e.get(s.blockId);
+    t || (t = [], e.set(s.blockId, t)), t.push({ ...s });
+  }
+  const n = [];
+  for (const [s, t] of e) {
+    if (t.length === 0) continue;
+    const i = [];
+    for (const r of t) {
+      if (i.length === 0) {
+        i.push(r);
+        continue;
+      }
+      const a = i[i.length - 1];
+      if (a.action === "delete" && r.action === "insert" && a.offset === r.offset) {
+        a.action = "replace", a.toText = r.toText;
+        continue;
+      }
+      if (a.action === "replace" && r.action === "insert" && r.offset === a.offset + a.toText.length) {
+        a.toText += r.toText;
+        continue;
+      }
+      if (a.action === "insert" && r.action === "insert" && r.offset === a.offset + a.toText.length) {
+        a.toText += r.toText;
+        continue;
+      }
+      if (a.action === "delete" && r.action === "delete" && r.offset === a.offset) {
+        a.fromText += r.fromText;
+        continue;
+      }
+      if (a.action === "delete" && r.action === "delete" && r.offset + r.fromText.length === a.offset) {
+        a.offset = r.offset, a.fromText = r.fromText + a.fromText;
+        continue;
+      }
+      i.push(r);
+    }
+    for (const r of i)
+      r.action === "replace" && r.fromText === r.toText || r.action === "insert" && r.toText.length === 0 || r.action === "delete" && r.fromText.length === 0 || n.push({
+        action: r.action,
+        blockId: s,
+        offset: r.offset,
+        fromText: r.fromText,
+        toText: r.toText
+      });
+  }
+  return n;
+}
+function E(o, e) {
+  const n = new Map(Object.entries(e)), s = [];
+  for (const t of o)
+    if (t.type === "deleteRange") {
+      const i = n.get(t.blockId) ?? "", r = Math.max(0, Math.min(t.start, i.length)), a = Math.max(r, Math.min(t.end, i.length)), c = i.slice(r, a);
+      c.length > 0 && s.push({
+        action: "delete",
+        blockId: t.blockId,
+        offset: r,
+        fromText: c,
+        toText: ""
+      }), n.set(t.blockId, i.slice(0, r) + i.slice(a));
+    } else if (t.type === "insertText") {
+      const i = n.get(t.at.blockId) ?? "", r = Math.max(0, Math.min(t.at.offset, i.length));
+      t.text.length > 0 && s.push({
+        action: "insert",
+        blockId: t.at.blockId,
+        offset: r,
+        fromText: "",
+        toText: t.text
+      }), n.set(
+        t.at.blockId,
+        i.slice(0, r) + t.text + i.slice(r)
+      );
+    } else if (t.type === "insertRuns") {
+      const i = I(t.runs), r = n.get(t.at.blockId) ?? "", a = Math.max(0, Math.min(t.at.offset, r.length));
+      i.length > 0 && s.push({
+        action: "insert",
+        blockId: t.at.blockId,
+        offset: a,
+        fromText: "",
+        toText: i
+      }), n.set(
+        t.at.blockId,
+        r.slice(0, a) + i + r.slice(a)
+      );
+    } else if (t.type === "setRuns") {
+      const i = n.get(t.blockId) ?? "", r = I(t.runs);
+      i !== r && s.push({
+        action: "replace",
+        blockId: t.blockId,
+        offset: 0,
+        fromText: i,
+        toText: r
+      }), n.set(t.blockId, r);
+    } else if (t.type === "splitParagraph") {
+      const i = n.get(t.at.blockId) ?? "", r = Math.max(0, Math.min(t.at.offset, i.length)), a = i.slice(0, r), c = i.slice(r);
+      n.set(t.at.blockId, a), n.set(t.newBlockId, c);
+    } else if (t.type === "removeBlock") {
+      const i = n.get(t.blockId) ?? "";
+      i.length > 0 && s.push({
+        action: "delete",
+        blockId: t.blockId,
+        offset: 0,
+        fromText: i,
+        toText: ""
+      }), n.set(t.blockId, "");
+    }
+  return p(s);
+}
+function x(o, e, n, s = 0) {
+  if (o === e) return [];
+  let t = 0;
+  const i = Math.min(o.length, e.length);
+  for (; t < i && o[t] === e[t]; )
+    t++;
+  let r = 0;
+  const a = Math.min(o.length - t, e.length - t);
+  for (; r < a && o[o.length - 1 - r] === e[e.length - 1 - r]; )
+    r++;
+  const c = o.slice(t, o.length - r), d = e.slice(t, e.length - r), h = s + t;
+  return c.length > 0 && d.length === 0 ? [{ action: "delete", blockId: n, offset: h, fromText: c, toText: "" }] : c.length === 0 && d.length > 0 ? [{ action: "insert", blockId: n, offset: h, fromText: "", toText: d }] : c.length > 0 && d.length > 0 ? [{ action: "replace", blockId: n, offset: h, fromText: c, toText: d }] : [];
+}
+class B {
+  detail;
+  includeSelection;
+  handlers = /* @__PURE__ */ new Map();
+  anyHandlers = /* @__PURE__ */ new Set();
+  sink;
+  redact;
+  onError;
+  disposed = !1;
+  constructor(e = {}) {
+    this.detail = e.detail ?? "metadata", this.includeSelection = e.includeSelection ?? !1, this.sink = e.sink, this.redact = e.redact, this.onError = e.onError ?? ((n) => console.error("[kindy-editor:event]", n));
+  }
+  on(e, n, s = {}) {
+    if (this.disposed || s.signal?.aborted) return () => {
+    };
+    let t = this.handlers.get(e);
+    t || this.handlers.set(e, t = /* @__PURE__ */ new Set()), t.add(n);
+    const i = () => {
+      t?.delete(n), t?.size === 0 && this.handlers.delete(e);
+    };
+    return s.signal?.addEventListener("abort", i, { once: !0 }), i;
+  }
+  onAny(e, n = {}) {
+    if (this.disposed || n.signal?.aborted) return () => {
+    };
+    this.anyHandlers.add(e);
+    const s = () => {
+      this.anyHandlers.delete(e);
+    };
+    return n.signal?.addEventListener("abort", s, { once: !0 }), s;
+  }
+  off(e, n) {
+    this.handlers.get(e)?.delete(n);
+  }
+  /** Called by the editor runtime after state is already consistent. Public only
+   * for custom bridges; normal integrations subscribe with on/onAny. */
+  dispatch(e) {
+    if (this.disposed) return;
+    const n = this.redact ? this.redact(e) : e;
+    if (n) {
+      for (const s of this.handlers.get(n.type) ?? []) this.safeCall(s, n);
+      for (const s of this.anyHandlers) this.safeCall(s, n);
+      if (this.sink)
+        try {
+          Promise.resolve(this.sink(n)).catch((s) => this.reportError(s, n));
+        } catch (s) {
+          this.reportError(s, n);
+        }
+    }
+  }
+  destroy() {
+    this.disposed = !0, this.handlers.clear(), this.anyHandlers.clear();
+  }
+  safeCall(e, n) {
+    try {
+      e(n);
+    } catch (s) {
+      this.reportError(s, n);
+    }
+  }
+  reportError(e, n) {
+    try {
+      this.onError(e, n);
+    } catch (s) {
+      console.error("[kindy-editor:event:onError]", s);
+    }
+  }
+}
+function C(o) {
+  const e = o.fetch ?? globalThis.fetch;
+  if (!e) throw new Error("createHttpEventSink requires fetch");
+  const n = Math.max(1, o.batchSize ?? 25), s = Math.max(10, o.flushIntervalMs ?? 1e3), t = Math.max(1, o.maxAttempts ?? 3);
+  let i = [], r = null, a = Promise.resolve(), c = !1;
+  const d = () => {
+    r && clearTimeout(r), r = null;
+  }, h = async () => {
+    const l = typeof o.headers == "function" ? await o.headers() : o.headers, f = new Headers(l);
+    return f.has("content-type") || f.set("content-type", "application/json"), f;
+  }, y = async (l) => {
+    let f;
+    for (let m = 1; m <= t; m++)
+      try {
+        const g = await e(o.endpoint, {
+          method: "POST",
+          headers: await h(),
+          body: JSON.stringify({ schemaVersion: l[0]?.schemaVersion ?? "1.0", events: l })
+        });
+        if (!g.ok) throw new Error(`event sink returned HTTP ${g.status}`);
+        return;
+      } catch (g) {
+        f = g, m < t && await new Promise((b) => setTimeout(b, 100 * 2 ** (m - 1)));
+      }
+    o.onDeliveryError?.(f, l);
+  }, u = async () => {
+    if (d(), i.length === 0) return a;
+    const l = i;
+    i = [], a = a.then(() => y(l)), await a;
+  }, T = ((l) => {
+    c || o.eventTypes && !o.eventTypes.includes(l.type) || (i.push(l), i.length >= n ? u() : r || (r = setTimeout(() => void u(), s)));
+  });
+  return T.flush = u, T.destroy = async () => {
+    c = !0, await u();
+  }, T;
+}
+class k {
+  idleMs;
+  selectionJumpThreshold;
+  constructor(e = {}) {
+    this.idleMs = Math.max(100, e.idleMs ?? 1e3), this.selectionJumpThreshold = Math.max(1, e.selectionJumpThreshold ?? 2);
+  }
+  /**
+   * Evaluates if a selection movement constitutes a boundary (e.g. jumped to another block
+   * or moved far away from the active typing position).
+   */
+  shouldCommitOnSelectionChange(e, n, s, t) {
+    return !e || s === null || t === null ? !1 : e !== s || n !== null && Math.abs(t - n) > this.selectionJumpThreshold;
+  }
+}
+class R {
+  policy;
+  emit;
+  getVersion;
+  idGenerator;
+  currentSession = null;
+  idleTimer = null;
+  disposed = !1;
+  nextGroupId = 1;
+  constructor(e) {
+    this.policy = e.policy instanceof k ? e.policy : new k({
+      ...typeof e.idleMs == "number" ? { idleMs: e.idleMs } : {},
+      ...e.policy
+    }), this.emit = e.emit, this.getVersion = e.getVersion ?? (() => 0), this.idGenerator = e.idGenerator ?? (() => `chg-${Date.now()}-${this.nextGroupId++}`);
+  }
+  /**
+   * Tracks a raw applied change. Starts a new session or extends the active session.
+   */
+  trackChange(e) {
+    if (this.disposed) return;
+    this.currentSession && this.currentSession.origin !== e.origin && this.flush("origin-change");
+    const n = e.version ?? this.getVersion();
+    if (!this.currentSession) {
+      const t = this.getVersion(), i = e.version ?? t;
+      this.currentSession = {
+        changeGroupId: this.idGenerator(),
+        origin: e.origin,
+        ...e.intent !== void 0 ? { intent: e.intent } : {},
+        beforeVersion: t,
+        afterVersion: i,
+        lastTransactionId: e.transactionId,
+        initialBlockTexts: /* @__PURE__ */ new Map(),
+        currentBlockTexts: /* @__PURE__ */ new Map(),
+        diffs: [],
+        activeBlockId: e.selectionAfter?.focus.blockId ?? null,
+        lastOffset: e.selectionAfter?.focus.offset ?? null
+      };
+    }
+    const s = this.currentSession;
+    if (s) {
+      s.afterVersion = n, s.lastTransactionId = e.transactionId, e.intent !== void 0 && s.intent === void 0 && (s.intent = e.intent);
+      for (const t of e.affectedBlockIds)
+        if (!s.initialBlockTexts.has(t)) {
+          const i = e.blockTextBefore?.[t] ?? "";
+          s.initialBlockTexts.set(t, i), s.currentBlockTexts.set(t, i);
+        }
+      if (this.applyOpsToCurrentTexts(s.currentBlockTexts, e.ops), e.textDiffs && e.textDiffs.length > 0 && s.diffs.push(...e.textDiffs), e.selectionAfter && (s.activeBlockId = e.selectionAfter.focus.blockId, s.lastOffset = e.selectionAfter.focus.offset), e.origin === "paste" || e.origin === "command") {
+        this.flush("explicit");
+        return;
+      }
+      this.restartIdleTimer();
+    }
+  }
+  /**
+   * Signals a semantic boundary from the editor environment (blur, save, selection change, etc.).
+   */
+  notifyBoundary(e, n) {
+    if (!(this.disposed || !this.currentSession)) {
+      if (e === "selection-jump") {
+        this.policy.shouldCommitOnSelectionChange(
+          this.currentSession.activeBlockId,
+          this.currentSession.lastOffset,
+          n?.newBlockId ?? null,
+          n?.newOffset ?? null
+        ) && this.flush("selection-jump");
+        return;
+      }
+      this.flush(e);
+    }
+  }
+  /**
+   * Flushes and commits the active session if one exists and contains non-trivial changes.
+   */
+  flush(e) {
+    this.clearIdleTimer();
+    const n = this.currentSession;
+    if (!n) return;
+    this.currentSession = null;
+    const s = [];
+    for (const [t, i] of n.initialBlockTexts) {
+      const r = n.currentBlockTexts.get(t) ?? i;
+      if (i !== r) {
+        const a = x(i, r, t);
+        s.push(...a);
+      }
+    }
+    s.length !== 0 && this.emit({
+      transactionId: n.lastTransactionId,
+      changeGroupId: n.changeGroupId,
+      beforeVersion: n.beforeVersion,
+      afterVersion: n.afterVersion,
+      origin: n.origin,
+      textDiffs: s,
+      ...n.intent ? { intent: n.intent } : {},
+      affectedBlockIds: Array.from(n.initialBlockTexts.keys())
+    });
+  }
+  destroy() {
+    this.disposed || (this.flush("destroy"), this.disposed = !0);
+  }
+  applyOpsToCurrentTexts(e, n) {
+    for (const s of n)
+      if (s.type === "deleteRange") {
+        const t = e.get(s.blockId) ?? "", i = Math.max(0, Math.min(s.start, t.length)), r = Math.max(i, Math.min(s.end, t.length));
+        e.set(s.blockId, t.slice(0, i) + t.slice(r));
+      } else if (s.type === "insertText") {
+        const t = e.get(s.at.blockId) ?? "", i = Math.max(0, Math.min(s.at.offset, t.length));
+        e.set(s.at.blockId, t.slice(0, i) + s.text + t.slice(i));
+      } else if (s.type === "insertRuns") {
+        const t = I(s.runs), i = e.get(s.at.blockId) ?? "", r = Math.max(0, Math.min(s.at.offset, i.length));
+        e.set(s.at.blockId, i.slice(0, r) + t + i.slice(r));
+      } else if (s.type === "setRuns")
+        e.set(s.blockId, I(s.runs));
+      else if (s.type === "splitParagraph") {
+        const t = e.get(s.at.blockId) ?? "", i = Math.max(0, Math.min(s.at.offset, t.length));
+        e.set(s.at.blockId, t.slice(0, i)), e.set(s.newBlockId, t.slice(i));
+      } else s.type === "removeBlock" && e.set(s.blockId, "");
+  }
+  restartIdleTimer() {
+    this.clearIdleTimer(), this.idleTimer = setTimeout(() => {
+      this.flush("idle");
+    }, this.policy.idleMs);
+  }
+  clearIdleTimer() {
+    this.idleTimer && (clearTimeout(this.idleTimer), this.idleTimer = null);
+  }
+}
+export {
+  R as C,
+  w as E,
+  M as a,
+  B as b,
+  E as c,
+  k as d,
+  C as e,
+  S as p
+};