annotate-kit 0.1.0

package/dist/firebase.js

@@ -0,0 +1,200 @@
+// src/adapters/firebase.ts
+import {
+  collection,
+  doc,
+  getDoc,
+  getDocs,
+  setDoc,
+  updateDoc,
+  deleteDoc,
+  query,
+  where,
+  orderBy,
+  limit,
+  arrayUnion,
+  runTransaction,
+  onSnapshot
+} from "firebase/firestore";
+import { ref, uploadBytes, getDownloadURL, deleteObject } from "firebase/storage";
+function prune(o) {
+  if (Array.isArray(o)) return o.map((v) => prune(v));
+  if (o && typeof o === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(o)) if (v !== void 0) out[k] = prune(v);
+    return out;
+  }
+  return o;
+}
+function createFirebaseAdapter(config) {
+  const db = config.firestore;
+  const storage = config.storage;
+  const auth = config.auth;
+  const collPath = config.collectionPath ?? "annotations";
+  const settingsFullPath = config.settingsPath ?? "annotate_settings/global";
+  if (settingsFullPath.split("/").filter(Boolean).length % 2 !== 0) {
+    throw new Error(`annotate: settingsPath must be a document path like 'collection/doc' (got '${settingsFullPath}')`);
+  }
+  const storageDir = config.storagePath ?? "annotations";
+  const listLimit = config.listLimit ?? 1e3;
+  const col = collection(db, collPath);
+  const settingsRef = doc(db, settingsFullPath);
+  const urlCache = /* @__PURE__ */ new Map();
+  async function claims() {
+    if (!auth?.currentUser) return {};
+    try {
+      return (await auth.currentUser.getIdTokenResult()).claims;
+    } catch {
+      return {};
+    }
+  }
+  async function resolveUser() {
+    if (config.currentUser) return await config.currentUser() ?? {};
+    const u = auth?.currentUser;
+    if (!u) return {};
+    const c = await claims();
+    return { email: u.email ?? void 0, name: u.displayName ?? u.email ?? void 0, role: c.role || void 0 };
+  }
+  async function resolveIsAdmin(user) {
+    if (typeof config.isAdmin === "boolean") return config.isAdmin;
+    if (typeof config.isAdmin === "function") return !!await config.isAdmin(user);
+    const c = await claims();
+    return c.admin === true || c.role === "admin";
+  }
+  async function urlFor(path) {
+    if (!path) return null;
+    const hit = urlCache.get(path);
+    if (hit) return hit;
+    try {
+      const u = await getDownloadURL(ref(storage, path));
+      urlCache.set(path, u);
+      return u;
+    } catch {
+      return null;
+    }
+  }
+  return {
+    async getAccess() {
+      const me = await resolveUser();
+      const isAdmin = await resolveIsAdmin(me);
+      let enabled = false;
+      try {
+        const snap = await getDoc(settingsRef);
+        if (snap.exists() && typeof snap.data().enabled === "boolean") enabled = snap.data().enabled;
+      } catch {
+      }
+      return { enabled, isAdmin, canUse: enabled || isAdmin, seeAll: isAdmin, me };
+    },
+    async setAccess(enabled) {
+      await setDoc(settingsRef, { enabled }, { merge: true });
+      return { message: enabled ? "Enabled for all users" : "ADMIN-only" };
+    },
+    async list() {
+      const me = await resolveUser();
+      const isAdmin = await resolveIsAdmin(me);
+      const seen = /* @__PURE__ */ new Map();
+      const collect = (docs) => {
+        for (const d of docs) {
+          const data = d.data();
+          const id = typeof data.id === "number" ? data.id : Number(d.id);
+          seen.set(id, { ...data, id });
+        }
+      };
+      if (isAdmin) {
+        const s = await getDocs(query(col, orderBy("id", "desc"), limit(listLimit)));
+        collect(s.docs);
+      } else {
+        const [pub, mine] = await Promise.all([
+          getDocs(query(col, where("visibility", "==", "public"), orderBy("id", "desc"), limit(listLimit))),
+          me.email ? getDocs(query(col, where("created_by", "==", me.email), orderBy("id", "desc"), limit(listLimit))) : Promise.resolve({ docs: [] })
+        ]);
+        collect(pub.docs);
+        collect(mine.docs);
+      }
+      const rows = [...seen.values()].sort((a, b) => b.id - a.id);
+      await Promise.all(rows.map(async (r) => {
+        if (r.screenshot_path) r.screenshot_url = await urlFor(r.screenshot_path);
+      }));
+      return rows;
+    },
+    async save(input) {
+      const me = await resolveUser();
+      const base = {
+        ...input,
+        status: "open",
+        created_by: me.email ?? "",
+        created_by_name: me.name ?? me.email ?? "",
+        created_by_role: me.role ?? null,
+        created_at: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      let id = 0;
+      await runTransaction(db, async (tx) => {
+        for (let i = 0; i < 6; i++) {
+          const cand = Date.now() * 1e3 + Math.floor(Math.random() * 1e3);
+          const dref = doc(col, String(cand));
+          const snap = await tx.get(dref);
+          if (!snap.exists()) {
+            id = cand;
+            tx.set(dref, prune({ ...base, id }));
+            return;
+          }
+        }
+        throw new Error("annotate: could not allocate a unique id \u2014 retry");
+      });
+      return { id };
+    },
+    async update(patch) {
+      const { id, ...rest } = patch;
+      await updateDoc(doc(col, String(id)), { ...prune(rest), updated_at: (/* @__PURE__ */ new Date()).toISOString() });
+    },
+    async remove(id) {
+      const snap = await getDoc(doc(col, String(id)));
+      const path = snap.exists() ? snap.data().screenshot_path : void 0;
+      await deleteDoc(doc(col, String(id)));
+      if (path) {
+        urlCache.delete(path);
+        try {
+          await deleteObject(ref(storage, path));
+        } catch (e) {
+          console.warn("[annotate] screenshot delete failed", e);
+        }
+      }
+    },
+    async addReply(id, note) {
+      const me = await resolveUser();
+      const reply = { note: note.slice(0, 2e3), author: me.name ?? me.email ?? "", at: (/* @__PURE__ */ new Date()).toISOString() };
+      await updateDoc(doc(col, String(id)), { replies: arrayUnion(reply), updated_at: (/* @__PURE__ */ new Date()).toISOString() });
+    },
+    async clearResolved() {
+      const s = await getDocs(query(col, where("status", "in", ["done", "dismissed"])));
+      await Promise.all(s.docs.map(async (d) => {
+        const path = d.data().screenshot_path;
+        await deleteDoc(d.ref);
+        if (path) {
+          urlCache.delete(path);
+          try {
+            await deleteObject(ref(storage, path));
+          } catch (e) {
+            console.warn("[annotate] screenshot delete failed", e);
+          }
+        }
+      }));
+      return { message: `Cleared ${s.docs.length} resolved` };
+    },
+    async uploadScreenshot(file, opts) {
+      const vis = opts?.visibility === "public" ? "public" : "private";
+      const uid = auth?.currentUser?.uid;
+      if (!uid) throw new Error("annotate: must be signed in to upload a screenshot");
+      const rand = Math.random().toString(36).slice(2, 8);
+      const path = `${storageDir}/${vis}/${uid}/${Date.now()}-${rand}.png`;
+      await uploadBytes(ref(storage, path), file, { contentType: file.type || "image/png" });
+      return { path };
+    },
+    subscribe(onChange) {
+      return onSnapshot(query(col, where("visibility", "==", "public")), () => onChange(), () => {
+      });
+    }
+  };
+}
+export {
+  createFirebaseAdapter
+};

package/dist/idb.d.ts

@@ -0,0 +1,18 @@
+import { S as StorageAdapter } from './adapter-Cyqfwj6F.js';
+import './types-BLXmj4Oi.js';
+
+type IdbAdapterConfig = {
+    /** Database name (default 'annotate-kit'). */
+    dbName?: string;
+    /** The single local user shown as author. */
+    me?: {
+        email?: string;
+        name?: string;
+        role?: string;
+    };
+    /** IndexedDB factory (default globalThis.indexedDB). Inject a fake for tests / non-browser envs. */
+    factory?: IDBFactory;
+};
+declare function createIdbAdapter(config?: IdbAdapterConfig): StorageAdapter;
+
+export { type IdbAdapterConfig, createIdbAdapter };

package/dist/idb.js

@@ -0,0 +1,202 @@
+// src/adapters/idb.ts
+var MARKS = "marks";
+var SHOTS = "shots";
+var SETTINGS = "settings";
+function createIdbAdapter(config = {}) {
+  const dbName = config.dbName ?? "annotate-kit";
+  const me = config.me ?? { email: "you@local", name: "You" };
+  const idb = config.factory ?? (typeof indexedDB !== "undefined" ? indexedDB : void 0);
+  const now = () => (/* @__PURE__ */ new Date()).toISOString();
+  const canObjectUrl = typeof URL !== "undefined" && typeof URL.createObjectURL === "function";
+  const urlCache = /* @__PURE__ */ new Map();
+  let dbp = null;
+  function db() {
+    if (!idb) return Promise.reject(new Error("annotate: IndexedDB is unavailable \u2014 pass config.factory or use another adapter"));
+    if (!dbp) dbp = new Promise((resolve, reject) => {
+      const req = idb.open(dbName, 1);
+      req.onupgradeneeded = () => {
+        const d = req.result;
+        if (!d.objectStoreNames.contains(MARKS)) d.createObjectStore(MARKS, { keyPath: "id", autoIncrement: true });
+        if (!d.objectStoreNames.contains(SHOTS)) d.createObjectStore(SHOTS);
+        if (!d.objectStoreNames.contains(SETTINGS)) d.createObjectStore(SETTINGS);
+      };
+      req.onsuccess = () => resolve(req.result);
+      req.onerror = () => reject(req.error);
+    });
+    return dbp;
+  }
+  function run(stores, mode, body) {
+    return db().then((d) => new Promise((resolve, reject) => {
+      const t = d.transaction(stores, mode);
+      const out = {};
+      try {
+        body(t, out);
+      } catch (e) {
+        reject(e);
+        try {
+          t.abort();
+        } catch {
+        }
+        return;
+      }
+      t.oncomplete = () => resolve(out.value);
+      t.onerror = () => reject(t.error);
+      t.onabort = () => reject(t.error);
+    }));
+  }
+  return {
+    async getAccess() {
+      const enabled = await run([SETTINGS], "readonly", (t, out) => {
+        const g = t.objectStore(SETTINGS).get("enabled");
+        g.onsuccess = () => {
+          out.value = g.result === void 0 ? true : !!g.result;
+        };
+      });
+      return { enabled: enabled ?? true, isAdmin: true, canUse: true, seeAll: true, me };
+    },
+    async setAccess(enabled) {
+      await run([SETTINGS], "readwrite", (t) => {
+        t.objectStore(SETTINGS).put(enabled, "enabled");
+      });
+      return { message: enabled ? "Enabled" : "Disabled" };
+    },
+    async list() {
+      const rows = await run([MARKS, SHOTS], "readonly", (t, out) => {
+        const shots = t.objectStore(SHOTS);
+        const ga = t.objectStore(MARKS).getAll();
+        ga.onsuccess = () => {
+          const all = ga.result || [];
+          for (const r of all) {
+            if (r.screenshot_path && canObjectUrl) {
+              const cached = urlCache.get(r.screenshot_path);
+              if (cached) r.screenshot_url = cached;
+              else {
+                const sr = shots.get(r.screenshot_path);
+                sr.onsuccess = () => {
+                  const b = sr.result;
+                  if (b) {
+                    const u = URL.createObjectURL(b);
+                    urlCache.set(r.screenshot_path, u);
+                    r.screenshot_url = u;
+                  }
+                };
+              }
+            }
+          }
+          out.value = all;
+        };
+      });
+      return (rows ?? []).sort((a, b) => b.id - a.id);
+    },
+    async save(input) {
+      const row = {
+        ...input,
+        status: "open",
+        created_by: me.email ?? "",
+        created_by_name: me.name ?? me.email ?? "",
+        created_by_role: me.role ?? null,
+        created_at: now(),
+        updated_at: now()
+      };
+      const id = await run([MARKS], "readwrite", (t, out) => {
+        const add = t.objectStore(MARKS).add(row);
+        add.onsuccess = () => {
+          out.value = Number(add.result);
+        };
+      });
+      return { id: id ?? 0 };
+    },
+    async update(patch) {
+      const { id, ...rest } = patch;
+      await run([MARKS], "readwrite", (t) => {
+        const store = t.objectStore(MARKS);
+        const g = store.get(id);
+        g.onsuccess = () => {
+          const row = g.result;
+          if (row) {
+            Object.assign(row, rest, { updated_at: now() });
+            store.put(row);
+          }
+        };
+      });
+    },
+    async remove(id) {
+      await run([MARKS, SHOTS], "readwrite", (t) => {
+        const marks = t.objectStore(MARKS);
+        const g = marks.get(id);
+        g.onsuccess = () => {
+          const row = g.result;
+          marks.delete(id);
+          if (row?.screenshot_path) {
+            t.objectStore(SHOTS).delete(row.screenshot_path);
+            const u = urlCache.get(row.screenshot_path);
+            if (u && canObjectUrl) URL.revokeObjectURL(u);
+            urlCache.delete(row.screenshot_path);
+          }
+        };
+      });
+    },
+    async addReply(id, note) {
+      await run([MARKS], "readwrite", (t) => {
+        const store = t.objectStore(MARKS);
+        const g = store.get(id);
+        g.onsuccess = () => {
+          const row = g.result;
+          if (row) {
+            const reply = { note: note.slice(0, 2e3), author: me.name ?? me.email ?? "", at: now() };
+            row.replies = [...Array.isArray(row.replies) ? row.replies : [], reply];
+            row.updated_at = now();
+            store.put(row);
+          }
+        };
+      });
+    },
+    async clearResolved() {
+      const removed = await run([MARKS, SHOTS], "readwrite", (t, out) => {
+        const marks = t.objectStore(MARKS);
+        const shots = t.objectStore(SHOTS);
+        const ga = marks.getAll();
+        ga.onsuccess = () => {
+          const all = ga.result || [];
+          let n = 0;
+          const referenced = /* @__PURE__ */ new Set();
+          for (const r of all) {
+            if (r.status === "done" || r.status === "dismissed") {
+              marks.delete(r.id);
+              n++;
+              if (r.screenshot_path) {
+                const u = urlCache.get(r.screenshot_path);
+                if (u && canObjectUrl) URL.revokeObjectURL(u);
+                urlCache.delete(r.screenshot_path);
+              }
+            } else if (r.screenshot_path) referenced.add(r.screenshot_path);
+          }
+          const gk = shots.getAllKeys();
+          gk.onsuccess = () => {
+            for (const k of gk.result || []) {
+              const key = String(k);
+              if (!referenced.has(key)) {
+                shots.delete(k);
+                const u = urlCache.get(key);
+                if (u && canObjectUrl) URL.revokeObjectURL(u);
+                urlCache.delete(key);
+              }
+            }
+          };
+          out.value = n;
+        };
+      });
+      return { message: `Cleared ${removed ?? 0} resolved` };
+    },
+    async uploadScreenshot(file, _opts) {
+      const path = `shot-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+      await run([SHOTS], "readwrite", (t) => {
+        t.objectStore(SHOTS).put(file, path);
+      });
+      return { path };
+    }
+  };
+}
+export {
+  createIdbAdapter
+};