@dailies-studio/shot-editor 0.1.0 → 0.2.0

package/src/state/syncCache.ts

@@ -0,0 +1,159 @@
+// What live sync keeps on this device (collaboration lane R4), in IndexedDB.
+//
+//   docs     the confirmed document per `sht_` id, at the session's epoch and
+//            seq: a rejoin asks only for the entries after it (a `welcome`)
+//            instead of the whole document again
+//   batches  every batch this device made and the server has not acked, by
+//            queue and counter. A batch is written here BEFORE it is sent, so
+//            an edit that left the tab is never only in memory.
+//   queues   which queue wrote for which document: a tab that closed with
+//            batches still pending leaves its row, and the next tab of the
+//            document adopts that queue (sync.ts, R5)
+//
+// Keyed by document id, never by name: a rename does not orphan anything. The
+// confirmed copy also carries the name it was opened under, so an editor
+// opened with no network can find it (`confirmedByName`).
+import type { Doc3D, SyncOp } from "@dailies-studio/shot/doc";
+
+export interface SyncConfirmed {
+  docId: string;
+  epoch: string;
+  seq: number;
+  rev: string;
+  sv: number;
+  doc: Doc3D;
+  /** The Project name it was opened under, for an offline boot. */
+  name?: string;
+  /** When it was written (ms): the newest wins a name two documents share. */
+  savedAt?: number;
+}
+
+export interface SyncStoredBatch {
+  q: string;
+  n: number;
+  docId: string;
+  base: number;
+  sv: number;
+  ops: SyncOp[];
+}
+
+export interface SyncCache {
+  confirmed(docId: string): Promise<SyncConfirmed | null>;
+  saveConfirmed(c: SyncConfirmed): Promise<void>;
+  /** Store one batch (and its queue's registry row). */
+  putBatch(b: SyncStoredBatch): Promise<void>;
+  /** Forget queue `q`'s batches `from` to `to`, both included. */
+  dropBatches(q: string, from: number, to: number): Promise<void>;
+  /** The newest confirmed copy opened under `name`. */
+  confirmedByName(name: string): Promise<SyncConfirmed | null>;
+  /** Every stored batch of one document, any queue. */
+  batchesOf(docId: string): Promise<SyncStoredBatch[]>;
+  /** Every queue that wrote for one document. */
+  queuesOf(docId: string): Promise<string[]>;
+  /** Forget a queue: its row and any batch it still has. */
+  dropQueue(q: string): Promise<void>;
+  /** Free space: forget the confirmed copies of every OTHER document. Never a
+   *  batch: those are edits nobody else holds. */
+  prune(keepDocId: string): Promise<void>;
+}
+
+/** Was this a refusal for space (`QuotaExceededError`)? */
+export function isQuotaError(e: unknown): boolean {
+  return typeof e === "object" && e !== null && (e as { name?: unknown }).name === "QuotaExceededError";
+}
+
+const DB_NAME = "dailies-sync";
+
+function done<T>(req: IDBRequest<T>): Promise<T> {
+  return new Promise((resolve, reject) => {
+    req.onsuccess = () => resolve(req.result);
+    req.onerror = () => reject(req.error ?? new Error("IndexedDB request failed"));
+  });
+}
+
+function committed(tx: IDBTransaction): Promise<void> {
+  return new Promise((resolve, reject) => {
+    tx.oncomplete = () => resolve();
+    tx.onerror = () => reject(tx.error ?? new Error("IndexedDB transaction failed"));
+    tx.onabort = () => reject(tx.error ?? new Error("IndexedDB transaction aborted"));
+  });
+}
+
+/** The newest of `all` opened under `name`, or null. */
+export function newestNamed(all: readonly SyncConfirmed[], name: string): SyncConfirmed | null {
+  let best: SyncConfirmed | null = null;
+  for (const c of all) if (c.name === name && (best === null || (c.savedAt ?? 0) > (best.savedAt ?? 0))) best = c;
+  return best;
+}
+
+/** The browser's cache, or null where IndexedDB is missing (then sync runs
+ *  from memory: nothing survives the tab, and the unsaved-work guard says so
+ *  until each batch is acked). */
+export function indexedDbSyncCache(): SyncCache | null {
+  if (typeof indexedDB === "undefined") return null;
+  let opened: Promise<IDBDatabase> | null = null;
+  const db = (): Promise<IDBDatabase> => {
+    opened ??= new Promise((resolve, reject) => {
+      const req = indexedDB.open(DB_NAME, 1);
+      req.onupgradeneeded = () => {
+        const d = req.result;
+        d.createObjectStore("docs", { keyPath: "docId" });
+        d.createObjectStore("batches", { keyPath: ["q", "n"] }).createIndex("docId", "docId");
+        d.createObjectStore("queues", { keyPath: "q" });
+      };
+      req.onsuccess = () => resolve(req.result);
+      req.onerror = () => reject(req.error ?? new Error("IndexedDB would not open"));
+    });
+    // A failed open is retried by the next call rather than cached.
+    opened.catch(() => (opened = null));
+    return opened;
+  };
+  return {
+    async confirmed(docId) {
+      const tx = (await db()).transaction("docs", "readonly");
+      return ((await done(tx.objectStore("docs").get(docId))) as SyncConfirmed | undefined) ?? null;
+    },
+    async saveConfirmed(c) {
+      const tx = (await db()).transaction("docs", "readwrite");
+      tx.objectStore("docs").put({ ...c, savedAt: Date.now() });
+      await committed(tx);
+    },
+    async putBatch(b) {
+      const tx = (await db()).transaction(["batches", "queues"], "readwrite");
+      tx.objectStore("batches").put(b);
+      tx.objectStore("queues").put({ q: b.q, docId: b.docId });
+      await committed(tx);
+    },
+    async dropBatches(q, from, to) {
+      const tx = (await db()).transaction("batches", "readwrite");
+      tx.objectStore("batches").delete(IDBKeyRange.bound([q, from], [q, to]));
+      await committed(tx);
+    },
+    async confirmedByName(name) {
+      const tx = (await db()).transaction("docs", "readonly");
+      const all = (await done(tx.objectStore("docs").getAll())) as SyncConfirmed[];
+      return newestNamed(all, name);
+    },
+    async batchesOf(docId) {
+      const tx = (await db()).transaction("batches", "readonly");
+      return (await done(tx.objectStore("batches").index("docId").getAll(docId))) as SyncStoredBatch[];
+    },
+    async queuesOf(docId) {
+      const tx = (await db()).transaction("queues", "readonly");
+      const rows = (await done(tx.objectStore("queues").getAll())) as Array<{ q: string; docId: string }>;
+      return rows.filter((r) => r.docId === docId).map((r) => r.q);
+    },
+    async dropQueue(q) {
+      const tx = (await db()).transaction(["batches", "queues"], "readwrite");
+      tx.objectStore("batches").delete(IDBKeyRange.bound([q, 0], [q, Number.MAX_SAFE_INTEGER]));
+      tx.objectStore("queues").delete(q);
+      await committed(tx);
+    },
+    async prune(keepDocId) {
+      const tx = (await db()).transaction("docs", "readwrite");
+      const store = tx.objectStore("docs");
+      for (const key of (await done(store.getAllKeys())) as string[]) if (key !== keepDocId) store.delete(key);
+      await committed(tx);
+    },
+  };
+}

package/src/state/triangles.ts

@@ -48,6 +48,19 @@ export function sumTriangles(byLayer: Readonly<Record<string, number>>): number
   return total;
 }
 
+const TRIANGLE_TOTALS = new WeakMap<object, number>();
+
+/** The same total, cached by the store record's immutable identity. A GPU
+ * report replaces the record, so identity invalidation follows the write
+ * without making every outline row repeat the sum. */
+export function sumTrianglesCached(byLayer: Readonly<Record<string, number>>): number {
+  const found = TRIANGLE_TOTALS.get(byLayer);
+  if (found !== undefined) return found;
+  const total = sumTriangles(byLayer);
+  TRIANGLE_TOTALS.set(byLayer, total);
+  return total;
+}
+
 /** `12.4k`, `1.2M`. Short enough for a row that already carries an icon, a
  *  name and two toggles. */
 export function formatTriangles(count: number): string {