@nkzw/fate-indexeddb 1.5.0

package/lib/index.d.mts

@@ -0,0 +1,7 @@
+import { PersistenceStorage } from "@nkzw/fate/persistence";
+//#region src/index.d.ts
+declare function indexedDB({ name }?: {
+  name?: string;
+}): PersistenceStorage;
+//#endregion
+export { indexedDB };

package/lib/index.mjs

@@ -0,0 +1,137 @@
+import { openDB } from "idb";
+//#region src/index.ts
+function indexedDB({ name = "fate" } = {}) {
+	let leases = 0;
+	let connection;
+	const release = () => {
+		if (--leases === 0) {
+			const previous = connection;
+			connection = void 0;
+			previous?.then((db) => db.close(), () => {});
+		}
+	};
+	const database = async () => {
+		leases++;
+		try {
+			return await (connection ??= openDB(name, 1, { upgrade(db) {
+				db.createObjectStore("fate");
+			} }));
+		} catch (error) {
+			release();
+			throw error;
+		}
+	};
+	const listeners = /* @__PURE__ */ new Map();
+	let channel;
+	const notify = (key) => {
+		for (const listener of listeners.get(key) ?? []) try {
+			listener();
+		} catch {}
+	};
+	const broadcast = (keys) => {
+		try {
+			const sender = channel ?? (typeof BroadcastChannel !== "undefined" ? new BroadcastChannel(`fate:${name}`) : void 0);
+			try {
+				sender?.postMessage(keys);
+			} finally {
+				if (sender !== channel) sender?.close();
+			}
+		} catch {}
+		for (const key of keys) notify(key);
+	};
+	return {
+		exclusive(key, run) {
+			if (typeof navigator === "undefined" || !navigator.locks) throw new Error("fate(indexeddb): Web Locks are required for safe durable writes across tabs.");
+			return navigator.locks.request(`fate:${JSON.stringify([name, key])}`, async () => {
+				leases++;
+				try {
+					return await run();
+				} finally {
+					release();
+				}
+			});
+		},
+		async read(key) {
+			const db = await database();
+			try {
+				return await db.get("fate", key);
+			} finally {
+				release();
+			}
+		},
+		async scan(prefix, after, limit = 64) {
+			const db = await database();
+			try {
+				const range = IDBKeyRange.lowerBound(after !== void 0 && after >= prefix ? after : prefix, after !== void 0 && after >= prefix);
+				const transaction = db.transaction("fate");
+				const entries = [];
+				let cursor = await transaction.store.openCursor(range);
+				while (cursor && String(cursor.key).startsWith(prefix) && entries.length < limit) {
+					entries.push({
+						key: String(cursor.key),
+						value: cursor.value
+					});
+					cursor = await cursor.continue();
+				}
+				await transaction.done;
+				return entries;
+			} finally {
+				release();
+			}
+		},
+		subscribe(key, listener) {
+			if (!channel && typeof BroadcastChannel !== "undefined") {
+				channel = new BroadcastChannel(`fate:${name}`);
+				channel.onmessage = ({ data }) => {
+					for (const key of Array.isArray(data) ? data : [data]) if (typeof key === "string") notify(key);
+				};
+			}
+			let set = listeners.get(key);
+			if (!set) {
+				set = /* @__PURE__ */ new Set();
+				listeners.set(key, set);
+			}
+			set.add(listener);
+			return () => {
+				set.delete(listener);
+				if (!set.size) listeners.delete(key);
+				if (!listeners.size) {
+					channel?.close();
+					channel = void 0;
+				}
+			};
+		},
+		async write(key, value) {
+			const db = await database();
+			try {
+				const transaction = db.transaction("fate", "readwrite");
+				await transaction.store.put(value, key);
+				await transaction.done;
+			} finally {
+				release();
+			}
+			broadcast([key]);
+		},
+		async writeBatch(entries) {
+			const db = await database();
+			try {
+				const transaction = db.transaction("fate", "readwrite");
+				try {
+					await Promise.all(entries.map(async ([key, value]) => value === void 0 ? transaction.store.delete(key) : transaction.store.put(value, key)));
+					await transaction.done;
+				} catch (error) {
+					try {
+						transaction.abort();
+					} catch {}
+					await transaction.done.catch(() => {});
+					throw error;
+				}
+			} finally {
+				release();
+			}
+			broadcast([...new Set(entries.map(([key]) => key))]);
+		}
+	};
+}
+//#endregion
+export { indexedDB };

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@nkzw/fate-indexeddb",
+  "version": "1.5.0",
+  "description": "Optional IndexedDB persistence adapter for fate.",
+  "license": "MIT",
+  "files": [
+    "lib"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "@nkzw/source": "./src/index.ts",
+      "types": "./lib/index.d.mts",
+      "default": "./lib/index.mjs"
+    }
+  },
+  "dependencies": {
+    "idb": "^8.0.3"
+  },
+  "devDependencies": {
+    "fake-indexeddb": "^6.2.4",
+    "vite": "npm:@voidzero-dev/vite-plus-core@0.3.0",
+    "vite-plus": "0.3.0",
+    "@nkzw/fate": "1.5.0"
+  },
+  "peerDependencies": {
+    "@nkzw/fate": "^1.4.0"
+  },
+  "scripts": {
+    "build": "vp pack --tsconfig tsconfig.json -d lib src/index.ts"
+  }
+}