@fileverse-dev/ddoc 6.0.0-drop-in.3 → 6.0.1-dist-slim.0

package/dist/ddoc-persistence-DLdSviUr.mjs

@@ -0,0 +1,371 @@
+import { fromUint8Array as _, toUint8Array as C } from "js-base64";
+import * as m from "yjs";
+import { S as I, A as $ } from "./tab-utils-BNFvrUAj.mjs";
+const U = (e) => {
+  const r = [];
+  for (const [n, f] of e) {
+    const o = r[r.length - 1];
+    o && o[1] === n ? o[1] = f : r.push([n, f]);
+  }
+  return r;
+}, j = (e) => e.map(([r, n]) => `${r}-${n}`).join(","), N = (e) => {
+  const r = e.share.get(I), n = (t) => r !== void 0 && t instanceof m.Item && t.parent === r && t.parentSub === $, f = Array.from(e.store.clients.keys()).sort((t, s) => t - s), o = [];
+  for (const t of f) {
+    const s = [], u = [];
+    for (const a of e.store.clients.get(t) ?? []) {
+      if (n(a)) continue;
+      const i = [
+        a.id.clock,
+        a.id.clock + a.length
+      ];
+      s.push(i), a.deleted && u.push([...i]);
+    }
+    s.length !== 0 && o.push(
+      `${t}:${j(U(s))}|${j(
+        U(u)
+      )}`
+    );
+  }
+  return o.join(";");
+}, Y = async (e) => {
+  const r = await crypto.subtle.digest(
+    "SHA-256",
+    new TextEncoder().encode(N(e))
+  );
+  return _(new Uint8Array(r));
+}, T = 8e3, W = "DdocStoreRepaired", h = "updates", P = "custom", B = (e) => e instanceof Error ? e : new Error(String(e)), E = (e, r, n) => ({
+  ddocId: e,
+  status: r,
+  encodedState: null,
+  ...n ? { error: B(n) } : {}
+}), O = (e, r) => {
+  const n = m.encodeStateAsUpdate(r);
+  return {
+    ddocId: e,
+    status: n.length <= 2 ? "empty" : "available",
+    encodedState: _(n)
+  };
+}, R = (e) => e.objectStoreNames.contains(h), M = (e) => Object.prototype.toString.call(e) === "[object Uint8Array]", k = (e, r) => {
+  for (const n of r ?? []) {
+    if (!M(n))
+      throw new Error("dDoc IndexedDB contains a non-Yjs update");
+    m.applyUpdate(e, n);
+  }
+}, F = (e, r) => new Promise((n) => {
+  const f = new m.Doc();
+  let o = null, t = null, s = !1, u = !1;
+  const a = (c) => {
+    s || (s = !0, clearTimeout(p), o == null || o.close(), f.destroy(), n(c));
+  }, i = (c, l) => a(E(e, c, l)), p = setTimeout(() => {
+    try {
+      t == null || t.abort();
+    } catch {
+    }
+    i("timed-out", new Error("dDoc IndexedDB read timed out"));
+  }, r);
+  let b;
+  try {
+    b = indexedDB.open(e);
+  } catch (c) {
+    i("unavailable", c);
+    return;
+  }
+  b.onupgradeneeded = () => {
+    var c;
+    u = !0, (c = b.transaction) == null || c.abort();
+  }, b.onerror = () => {
+    u ? a(E(e, "missing")) : i("unavailable", b.error);
+  }, b.onsuccess = () => {
+    if (o = b.result, s) {
+      o.close();
+      return;
+    }
+    if (!R(o)) {
+      i("corrupt", new Error("dDoc IndexedDB has no updates store"));
+      return;
+    }
+    try {
+      t = o.transaction(h, "readonly");
+      const c = t.objectStore(h).getAll();
+      c.onerror = () => i("unavailable", c.error), c.onsuccess = () => {
+        try {
+          k(f, c.result);
+        } catch (l) {
+          i("corrupt", l);
+        }
+      }, t.oncomplete = () => a(O(e, f)), t.onabort = () => {
+        s || i("unavailable", t == null ? void 0 : t.error);
+      }, t.onerror = () => {
+        s || i("unavailable", t == null ? void 0 : t.error);
+      };
+    } catch (c) {
+      i("unavailable", c);
+    }
+  };
+}), q = async (e, r) => {
+  const n = indexedDB;
+  if (!n.databases) return null;
+  let f;
+  try {
+    const o = await Promise.race([
+      n.databases(),
+      new Promise((t) => {
+        f = setTimeout(() => t(null), r);
+      })
+    ]);
+    return o ? o.some((t) => t.name === e) : null;
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(f);
+  }
+}, K = async (e, r) => typeof indexedDB > "u" ? E(
+  e,
+  "unavailable",
+  new Error("IndexedDB is unavailable")
+) : await q(e, r) === !1 ? E(e, "missing") : F(e, r), z = (e, r = {}) => K(
+  e,
+  r.timeoutMs ?? T
+), G = (e, r, n = {}) => {
+  const f = n.timeoutMs ?? T, o = (s, u) => ({
+    ...E(e, s, u),
+    changed: !1,
+    created: !1
+  }), t = new m.Doc();
+  try {
+    m.applyUpdate(t, C(r));
+  } catch (s) {
+    return t.destroy(), Promise.resolve(o("corrupt", s));
+  }
+  return typeof indexedDB > "u" ? (t.destroy(), Promise.resolve(
+    o("unavailable", new Error("IndexedDB is unavailable"))
+  )) : new Promise((s) => {
+    const u = new m.Doc();
+    let a = null, i = null, p = !1, b = !1, c = !1, l = null;
+    const y = (d) => {
+      p || (p = !0, clearTimeout(A), a == null || a.close(), u.destroy(), t.destroy(), s(d));
+    }, A = setTimeout(() => {
+      try {
+        i == null || i.abort();
+      } catch {
+      }
+      y(
+        o("timed-out", new Error("dDoc IndexedDB merge timed out"))
+      );
+    }, f);
+    let D;
+    try {
+      D = indexedDB.open(e);
+    } catch (d) {
+      y(o("unavailable", d));
+      return;
+    }
+    D.onupgradeneeded = () => {
+      var g;
+      if (p) {
+        (g = D.transaction) == null || g.abort();
+        return;
+      }
+      c = !0;
+      const d = D.result;
+      d.objectStoreNames.contains(h) || d.createObjectStore(h, { autoIncrement: !0 }), d.objectStoreNames.contains(P) || d.createObjectStore(P);
+    }, D.onerror = () => y(o("unavailable", D.error)), D.onsuccess = () => {
+      if (a = D.result, p) {
+        a.close();
+        return;
+      }
+      if (!R(a)) {
+        y(
+          o(
+            "corrupt",
+            new Error("dDoc IndexedDB has no updates store")
+          )
+        );
+        return;
+      }
+      try {
+        const d = a.transaction(h, "readwrite");
+        i = d;
+        const g = d.objectStore(h), v = (w, x) => {
+          l ?? (l = { status: w, error: x });
+          try {
+            d.abort();
+          } catch {
+          }
+        }, S = g.getAll();
+        S.onsuccess = () => {
+          try {
+            k(u, S.result);
+          } catch (w) {
+            v("corrupt", w);
+            return;
+          }
+          try {
+            const w = m.encodeStateAsUpdate(
+              t,
+              m.encodeStateVector(u)
+            ), x = () => {
+              b = !0;
+            };
+            u.on("update", x);
+            try {
+              m.applyUpdate(u, w);
+            } finally {
+              u.off("update", x);
+            }
+            b && g.add(w);
+          } catch (w) {
+            v("unavailable", w);
+          }
+        }, d.oncomplete = () => y({ ...O(e, u), changed: b, created: c }), d.onabort = () => y(
+          o(
+            (l == null ? void 0 : l.status) ?? "unavailable",
+            (l == null ? void 0 : l.error) ?? d.error ?? new Error("dDoc IndexedDB merge aborted")
+          )
+        );
+      } catch (d) {
+        y(o("unavailable", d));
+      }
+    };
+  });
+}, V = (e) => {
+  if (!M(e)) return !1;
+  const r = new m.Doc();
+  try {
+    return m.applyUpdate(r, e), !0;
+  } catch {
+    return !1;
+  } finally {
+    r.destroy();
+  }
+}, J = async (e, r = {}) => {
+  const n = (o, t = 0, s) => ({
+    ddocId: e,
+    status: o,
+    droppedRows: t,
+    ...s ? { error: B(s) } : {}
+  });
+  if (typeof indexedDB > "u")
+    return n("unavailable", 0, new Error("IndexedDB is unavailable"));
+  const f = r.timeoutMs ?? T;
+  return await q(e, f) === !1 ? n("missing") : new Promise((o) => {
+    let t = null, s = null, u = !1, a = !1, i = 0;
+    const p = (l) => {
+      u || (u = !0, clearTimeout(b), t == null || t.close(), o(l));
+    }, b = setTimeout(() => {
+      try {
+        s == null || s.abort();
+      } catch {
+      }
+      p(
+        n("timed-out", 0, new Error("dDoc IndexedDB repair timed out"))
+      );
+    }, f);
+    let c;
+    try {
+      c = indexedDB.open(e);
+    } catch (l) {
+      p(n("unavailable", 0, l));
+      return;
+    }
+    c.onupgradeneeded = () => {
+      var l;
+      a = !0, (l = c.transaction) == null || l.abort();
+    }, c.onerror = () => p(
+      a ? n("missing") : n("unavailable", 0, c.error)
+    ), c.onsuccess = () => {
+      if (t = c.result, u) {
+        t.close();
+        return;
+      }
+      if (!R(t)) {
+        p(
+          n(
+            "corrupt",
+            0,
+            new Error("dDoc IndexedDB has no updates store")
+          )
+        );
+        return;
+      }
+      try {
+        const l = t.transaction(h, "readwrite");
+        s = l;
+        const y = l.objectStore(h), A = y.getAllKeys(), D = y.getAll();
+        D.onsuccess = () => {
+          const d = A.result ?? [];
+          (D.result ?? []).forEach((v, S) => {
+            V(v) || (y.delete(d[S]), i += 1);
+          });
+        }, l.oncomplete = () => p(i > 0 ? n("repaired", i) : n("healthy")), l.onabort = () => p(
+          n(
+            "unavailable",
+            0,
+            l.error ?? new Error("dDoc IndexedDB repair aborted")
+          )
+        );
+      } catch (l) {
+        p(n("unavailable", 0, l));
+      }
+    };
+  });
+}, Q = (e, r = {}) => {
+  if (typeof indexedDB > "u")
+    return Promise.resolve({
+      ddocId: e,
+      status: "unavailable",
+      error: new Error("IndexedDB is unavailable")
+    });
+  const n = r.timeoutMs ?? T;
+  return new Promise((f) => {
+    let o = !1, t = !1;
+    const s = (i) => {
+      o || (o = !0, clearTimeout(u), f(i));
+    }, u = setTimeout(
+      () => s(
+        t ? {
+          ddocId: e,
+          status: "blocked",
+          error: new Error(
+            "dDoc IndexedDB delete is blocked by an open connection"
+          )
+        } : {
+          ddocId: e,
+          status: "unavailable",
+          error: new Error("dDoc IndexedDB delete timed out")
+        }
+      ),
+      n
+    );
+    let a;
+    try {
+      a = indexedDB.deleteDatabase(e);
+    } catch (i) {
+      s({ ddocId: e, status: "unavailable", error: B(i) });
+      return;
+    }
+    a.onblocked = () => {
+      t = !0;
+    }, a.onsuccess = () => s({ ddocId: e, status: "deleted" }), a.onerror = () => s({
+      ddocId: e,
+      status: "unavailable",
+      error: B(a.error ?? "dDoc IndexedDB delete failed")
+    });
+  });
+}, X = async (e) => {
+  const r = new m.Doc();
+  try {
+    return m.applyUpdate(r, C(e)), await Y(r);
+  } finally {
+    r.destroy();
+  }
+};
+export {
+  W as D,
+  T as a,
+  J as b,
+  Q as d,
+  X as g,
+  G as m,
+  z as r
+};

package/dist/headless-editor-utils.es.js

@@ -1,4 +1,4 @@
-import { ch as s } from "./use-headless-editor-KdKS6vWp.mjs";
+import { c as s } from "./use-headless-editor-fZCM6BjV.mjs";
 const n = (e) => {
   const { getYjsConvertor: t, mergeYjsUpdates: r } = s(e);
   return { getYjsConvertor: t, mergeYjsUpdates: r };