@luckydye/calendar 1.1.0 → 1.1.2

package/src/lib.ts

@@ -0,0 +1,4 @@
+export * from "./CalendarView.js";
+export * from "./InMemorySource.js";
+export * from "./CalendarInternal.js";
+export * from "./CalendarIntegration.js";

package/src/service-worker.js

@@ -0,0 +1,177 @@
+const SW_VERSION = "1.0.0";
+const DB_NAME = "calendar-notifications";
+const STORE_NAME = "notification-schedule";
+const DB_VERSION = 1;
+
+console.log(`Service Worker ${SW_VERSION} installing`);
+
+self.addEventListener("install", () => {
+	console.log(`Service Worker ${SW_VERSION} installed`);
+	self.skipWaiting();
+});
+self.addEventListener("activate", () => {
+	console.log(`Service Worker ${SW_VERSION} activated`);
+	self.clients.claim();
+});
+
+// Message handling from app
+self.addEventListener("message", async (event) => {
+	const { type, ...data } = event.data;
+
+	try {
+		if (type === "SCHEDULE_NOTIFICATIONS") {
+			await scheduleNotifications(data.notifications);
+			event.ports[0].postMessage({
+				type: "SUCCESS",
+				count: data.notifications.length,
+			});
+		} else if (type === "CANCEL_EVENT_NOTIFICATIONS") {
+			await cancelEventNotifications(data.eventId);
+			event.ports[0].postMessage({ type: "SUCCESS" });
+		} else if (type === "GET_SCHEDULED_NOTIFICATIONS") {
+			const notifications = await getScheduledNotifications();
+			event.ports[0].postMessage({ type: "SUCCESS", notifications });
+		}
+	} catch (error) {
+		event.ports[0].postMessage({ type: "ERROR", message: error.message });
+	}
+});
+
+// Periodic check every minute
+let checkInterval;
+self.addEventListener("activate", () => {
+	checkInterval = setInterval(checkAndFireNotifications, 60000);
+	checkAndFireNotifications(); // Initial check
+});
+
+// IndexedDB operations
+async function openDB() {
+	return new Promise((resolve, reject) => {
+		const request = indexedDB.open(DB_NAME, DB_VERSION);
+		request.onsuccess = () => resolve(request.result);
+		request.onerror = () => reject(request.error);
+		request.onupgradeneeded = (e) => {
+			const db = e.target.result;
+			const store = db.createObjectStore(STORE_NAME, {
+				keyPath: "notificationId",
+			});
+			store.createIndex("triggerTime", "triggerTime");
+			store.createIndex("eventId", "eventId");
+		};
+	});
+}
+
+async function scheduleNotifications(notifications) {
+	const db = await openDB();
+	const tx = db.transaction(STORE_NAME, "readwrite");
+	const store = tx.objectStore(STORE_NAME);
+	const now = new Date();
+
+	for (const notif of notifications) {
+		if (new Date(notif.triggerTime) > now) {
+			await store.put(notif);
+		}
+	}
+
+	return new Promise((resolve, reject) => {
+		tx.oncomplete = () => resolve();
+		tx.onerror = () => reject(tx.error);
+	});
+}
+
+async function cancelEventNotifications(eventId) {
+	const db = await openDB();
+	const tx = db.transaction(STORE_NAME, "readwrite");
+	const index = tx.objectStore(STORE_NAME).index("eventId");
+
+	return new Promise((resolve, reject) => {
+		const request = index.openCursor(IDBKeyRange.only(eventId));
+		request.onsuccess = (e) => {
+			const cursor = e.target.result;
+			if (cursor) {
+				cursor.delete();
+				cursor.continue();
+			}
+		};
+		tx.oncomplete = () => resolve();
+		tx.onerror = () => reject(tx.error);
+	});
+}
+
+async function getScheduledNotifications() {
+	const db = await openDB();
+	const tx = db.transaction(STORE_NAME, "readonly");
+	const store = tx.objectStore(STORE_NAME);
+	const index = store.index("triggerTime");
+
+	return new Promise((resolve, reject) => {
+		const request = index.getAll();
+		request.onsuccess = () => {
+			const notifications = request.result || [];
+			// Sort by trigger time
+			notifications.sort((a, b) =>
+				new Date(a.triggerTime).getTime() - new Date(b.triggerTime).getTime()
+			);
+			resolve(notifications);
+		};
+		request.onerror = () => reject(request.error);
+	});
+}
+
+async function checkAndFireNotifications() {
+	const db = await openDB();
+	const tx = db.transaction(STORE_NAME, "readwrite");
+	const store = tx.objectStore(STORE_NAME);
+	const index = store.index("triggerTime");
+
+	const now = new Date().toISOString();
+	const range = IDBKeyRange.upperBound(now);
+
+	return new Promise((resolve, reject) => {
+		const request = index.openCursor(range);
+		const toFire = [];
+
+		request.onsuccess = (e) => {
+			const cursor = e.target.result;
+			if (cursor) {
+				toFire.push(cursor.value);
+				cursor.delete();
+				cursor.continue();
+			}
+		};
+
+		tx.oncomplete = () => {
+			toFire.forEach(fireNotification);
+			resolve();
+		};
+		tx.onerror = () => reject(tx.error);
+	});
+}
+
+function fireNotification(notif) {
+	const eventDate = new Date(notif.eventStart);
+	const timeStr = eventDate.toLocaleTimeString([], {
+		hour: "numeric",
+		minute: "2-digit",
+	});
+	const dateStr = eventDate.toLocaleDateString([], {
+		month: "short",
+		day: "numeric",
+	});
+
+	const body = notif.eventLocation
+		? `${dateStr} at ${timeStr}\n${notif.eventLocation}`
+		: `${dateStr} at ${timeStr}`;
+
+	self.registration.showNotification(notif.eventTitle, {
+		body,
+		icon: "/icon.svg",
+		tag: notif.eventId,
+		requireInteraction: false,
+	});
+}
+
+self.addEventListener("notificationclick", (event) => {
+	event.notification.close();
+	event.waitUntil(clients.openWindow("/"));
+});