@scrawl-board/board 0.1.0-beta.1 → 0.1.0-beta.10

package/dist/local.js

@@ -0,0 +1,342 @@
+//#region src/persistence/shared/documentCollections.ts
+var COLLECTION_FIELD = {
+	stroke: "strokes",
+	note: "notes",
+	text: "textBlocks",
+	table: "tables",
+	image: "images",
+	timer: "timers",
+	rectangle: "rectangles",
+	ellipse: "ellipses",
+	group: "groups",
+	line: "lines",
+	arrow: "arrows",
+	polygon: "polygons",
+	star: "stars",
+	heart: "hearts",
+	custom: "customObjects"
+};
+var FIELD_OBJECT_TYPE = Object.fromEntries(Object.entries(COLLECTION_FIELD).map(([objectType, field]) => [field, objectType]));
+function serializeObjects(objects) {
+	const collections = {
+		strokes: [],
+		notes: [],
+		textBlocks: [],
+		tables: [],
+		images: [],
+		timers: [],
+		rectangles: [],
+		ellipses: [],
+		groups: [],
+		lines: [],
+		arrows: [],
+		polygons: [],
+		stars: [],
+		hearts: [],
+		customObjects: []
+	};
+	let objectOrder = [];
+	const entries = [...objects];
+	const pages = [];
+	let pageName;
+	let pageSectionId;
+	const notebooks = [];
+	const sections = [];
+	for (const object of entries) {
+		if (object.objectType === "notebook") {
+			notebooks.push(object.payload);
+			continue;
+		}
+		if (object.objectType === "section") {
+			sections.push(object.payload);
+			continue;
+		}
+		if (object.objectType === "page") {
+			const metadata = object.payload;
+			if (object.objectId === "default") {
+				pageName = metadata.name;
+				pageSectionId = metadata.sectionId;
+			} else pages.push({
+				id: object.objectId,
+				name: metadata.name,
+				...metadata.sectionId ? { sectionId: metadata.sectionId } : {},
+				content: serializeObjects(entries.filter((entry) => entry.pageId === object.objectId).map((entry) => ({
+					...entry,
+					pageId: void 0
+				})))
+			});
+			continue;
+		}
+		if (object.pageId && object.pageId !== "default") continue;
+		if (object.objectType === "order") {
+			objectOrder = object.payload?.order ?? [];
+			continue;
+		}
+		collections[COLLECTION_FIELD[object.objectType]].push(object.payload);
+	}
+	return {
+		schemaVersion: 1,
+		...collections,
+		objectOrder,
+		...pageName ? { pageName } : {},
+		...pageSectionId ? { pageSectionId } : {},
+		...notebooks.length ? { notebooks } : {},
+		...sections.length ? { sections } : {},
+		...pages.length ? { pages } : {}
+	};
+}
+/** The inverse of `serializeObjects` — one `StoredObject` per collection entry, keyed by that entry's own `id`. Malformed entries (no string `id`) are skipped. */
+function objectsFromDocument(document) {
+	const result = [];
+	const record = document;
+	for (const [field, objectType] of Object.entries(FIELD_OBJECT_TYPE)) {
+		const items = record[field];
+		if (!Array.isArray(items)) continue;
+		for (const item of items) {
+			const objectId = item?.id;
+			if (typeof objectId !== "string") continue;
+			result.push({
+				objectType,
+				objectId,
+				payload: item
+			});
+		}
+	}
+	if (Array.isArray(document.objectOrder) && document.objectOrder.length) result.push({
+		objectType: "order",
+		objectId: "order",
+		payload: { order: [...document.objectOrder] }
+	});
+	for (const notebook of document.notebooks ?? []) result.push({
+		objectType: "notebook",
+		objectId: notebook.id,
+		payload: notebook
+	});
+	for (const section of document.sections ?? []) result.push({
+		objectType: "section",
+		objectId: section.id,
+		payload: section
+	});
+	if (document.pageName || document.pageSectionId) result.push({
+		objectType: "page",
+		objectId: "default",
+		payload: {
+			id: "default",
+			name: document.pageName ?? "Page 1",
+			...document.pageSectionId ? { sectionId: document.pageSectionId } : {}
+		}
+	});
+	for (const page of document.pages ?? []) {
+		result.push({
+			objectType: "page",
+			objectId: page.id,
+			payload: {
+				id: page.id,
+				name: page.name,
+				...page.sectionId ? { sectionId: page.sectionId } : {}
+			}
+		});
+		result.push(...objectsFromDocument(page.content).map((object) => ({
+			...object,
+			pageId: page.id
+		})));
+	}
+	return result;
+}
+/** Collision-free identity for metadata and content on any page. */
+function storedObjectKey(object) {
+	return [
+		"page",
+		"notebook",
+		"section"
+	].includes(object.objectType) ? JSON.stringify([object.objectType, object.objectId]) : JSON.stringify([
+		"content",
+		object.pageId ?? "default",
+		object.objectId
+	]);
+}
+//#endregion
+//#region src/persistence/local/indexedDBPersistenceAdapter.ts
+var OBJECT_STORE = "objects";
+var DOCUMENT_STORE = "documents";
+var DB_VERSION = 2;
+function objectKey(documentId, objectId) {
+	return JSON.stringify([documentId, objectId]);
+}
+function requestToPromise(request) {
+	return new Promise((resolve, reject) => {
+		request.onsuccess = () => resolve(request.result);
+		request.onerror = () => reject(request.error);
+	});
+}
+function openDatabase(factory, databaseName) {
+	return new Promise((resolve, reject) => {
+		const request = factory.open(databaseName, DB_VERSION);
+		request.onupgradeneeded = (event) => {
+			const db = request.result;
+			if (!db.objectStoreNames.contains(OBJECT_STORE)) db.createObjectStore(OBJECT_STORE, { keyPath: "key" }).createIndex("documentId", "documentId");
+			if (!db.objectStoreNames.contains(DOCUMENT_STORE)) db.createObjectStore(DOCUMENT_STORE, { keyPath: "documentId" });
+			if (event.oldVersion === 1) {
+				const objects = request.transaction.objectStore(OBJECT_STORE);
+				const records = objects.getAll();
+				records.onsuccess = () => {
+					objects.clear();
+					for (const record of records.result) objects.put({
+						...record,
+						key: objectKey(record.documentId, storedObjectKey(record))
+					});
+				};
+				const cursor = request.transaction.objectStore(DOCUMENT_STORE).openCursor();
+				cursor.onsuccess = () => {
+					if (!cursor.result) return;
+					const record = cursor.result.value;
+					cursor.result.update({
+						...record,
+						tombstones: record.tombstones.map((id) => storedObjectKey({
+							objectType: "note",
+							objectId: id
+						}))
+					});
+					cursor.result.continue();
+				};
+			}
+		};
+		request.onsuccess = () => resolve(request.result);
+		request.onerror = () => reject(request.error);
+	});
+}
+/**
+* Creates a `PersistenceAdapter` backed by the browser's IndexedDB. One
+* instance can back multiple documents (keyed by
+* `DocumentContext.documentId`), stored in object-level records so a
+* partial save never corrupts unrelated objects.
+*/
+function createIndexedDBPersistence(options = {}) {
+	const maybeFactory = options.indexedDB ?? (typeof indexedDB !== "undefined" ? indexedDB : void 0);
+	if (!maybeFactory) throw new Error("createIndexedDBPersistence: no IndexedDB implementation found. Pass `indexedDB` explicitly outside a browser (e.g. in tests), or use createMemoryPersistence instead.");
+	const factory = maybeFactory;
+	const databaseName = options.databaseName ?? "scrawl-board";
+	let dbPromise = null;
+	function db() {
+		if (!dbPromise) dbPromise = openDatabase(factory, databaseName);
+		return dbPromise;
+	}
+	async function readDocumentRecord(database, documentId) {
+		return requestToPromise(database.transaction(DOCUMENT_STORE, "readonly").objectStore(DOCUMENT_STORE).get(documentId));
+	}
+	async function readObjects(database, documentId) {
+		return requestToPromise(database.transaction(OBJECT_STORE, "readonly").objectStore(OBJECT_STORE).index("documentId").getAll(documentId));
+	}
+	return {
+		async load(context) {
+			const database = await db();
+			const record = await readDocumentRecord(database, context.documentId);
+			if (!record || record.version === 0) return { state: "missing" };
+			return {
+				state: "found",
+				document: serializeObjects(await readObjects(database, context.documentId)),
+				revision: String(record.version)
+			};
+		},
+		async applyOps(context, ops) {
+			const database = await db();
+			const existing = await readDocumentRecord(database, context.documentId) ?? {
+				documentId: context.documentId,
+				version: 0,
+				tombstones: []
+			};
+			const tombstones = new Set(existing.tombstones);
+			const rejectedOpIds = [];
+			let reason = null;
+			const tx = database.transaction([OBJECT_STORE, DOCUMENT_STORE], "readwrite");
+			const objectStore = tx.objectStore(OBJECT_STORE);
+			for (const op of ops) {
+				const scopedId = storedObjectKey(op);
+				if (op.kind === "upsert" && tombstones.has(scopedId)) {
+					rejectedOpIds.push(op.id);
+					reason = "tombstone";
+					continue;
+				}
+				const key = objectKey(context.documentId, scopedId);
+				if (op.kind === "remove") {
+					objectStore.delete(key);
+					tombstones.add(scopedId);
+				} else {
+					if (op.kind === "restore") tombstones.delete(scopedId);
+					const record = {
+						key,
+						documentId: context.documentId,
+						objectType: op.objectType,
+						objectId: op.objectId,
+						...op.pageId ? { pageId: op.pageId } : {},
+						payload: op.payload
+					};
+					objectStore.put(record);
+				}
+			}
+			const nextVersion = ops.length ? existing.version + 1 : existing.version;
+			const nextRecord = {
+				documentId: context.documentId,
+				version: nextVersion,
+				tombstones: [...tombstones]
+			};
+			tx.objectStore(DOCUMENT_STORE).put(nextRecord);
+			await new Promise((resolve, reject) => {
+				tx.oncomplete = () => resolve();
+				tx.onerror = () => reject(tx.error);
+				tx.onabort = () => reject(tx.error);
+			});
+			if (rejectedOpIds.length && reason) return {
+				state: "reconcile",
+				revision: String(nextVersion),
+				rejectedOpIds,
+				reason
+			};
+			return {
+				state: "applied",
+				revision: String(nextVersion)
+			};
+		},
+		async replace(context, document, baseRevision) {
+			const database = await db();
+			const existing = await readDocumentRecord(database, context.documentId) ?? {
+				documentId: context.documentId,
+				version: 0,
+				tombstones: []
+			};
+			if (String(existing.version) !== baseRevision) return {
+				state: "conflict",
+				currentRevision: String(existing.version)
+			};
+			const tx = database.transaction([OBJECT_STORE, DOCUMENT_STORE], "readwrite");
+			const objectStore = tx.objectStore(OBJECT_STORE);
+			const existingKeys = await requestToPromise(objectStore.index("documentId").getAllKeys(context.documentId));
+			for (const key of existingKeys) objectStore.delete(key);
+			for (const object of objectsFromDocument(document)) {
+				const record = {
+					key: objectKey(context.documentId, storedObjectKey(object)),
+					documentId: context.documentId,
+					...object
+				};
+				objectStore.put(record);
+			}
+			const nextVersion = existing.version + 1;
+			tx.objectStore(DOCUMENT_STORE).put({
+				documentId: context.documentId,
+				version: nextVersion,
+				tombstones: []
+			});
+			await new Promise((resolve, reject) => {
+				tx.oncomplete = () => resolve();
+				tx.onerror = () => reject(tx.error);
+				tx.onabort = () => reject(tx.error);
+			});
+			return {
+				state: "applied",
+				revision: String(nextVersion)
+			};
+		}
+	};
+}
+//#endregion
+export { createIndexedDBPersistence };