@luckydye/calendar 1.3.1 → 1.3.2

package/src/GoogleCalendarSource.ts

@@ -429,7 +429,8 @@ export class GoogleCalendarSource implements CalendarSource {
   /**
    * Update an existing event in Google Calendar.
    */
-  async updateEvent(id: string, updates: Partial<CalendarEvent>): Promise<CalendarEvent> {
+  async updateEvent(event: CalendarEvent, updates: Partial<CalendarEvent>): Promise<CalendarEvent> {
+    const id = event.id;
     const isRsvpOnly = Object.keys(updates).length === 1 && updates.attendees !== undefined;
 
     if (isRsvpOnly) {

package/src/ICal.ts

@@ -1,5 +1,6 @@
 import type { CalendarCredentials } from './CalendarIntegration.js';
 import type { CalendarEvent, Attendee, Organizer, NotificationConfig } from './CalendarInternal.js';
+import { sanitizeEventDescription } from './DescriptionSanitizer.js';
 
 export interface ParseResult {
   events: CalendarEvent[];
@@ -50,7 +51,9 @@ export function parseICalEventsWithNotifications(icalText: string, color: string
           end: (currentEvent.end instanceof Date ? currentEvent.end : currentEvent.start) as Date,
           color,
           calendar,
-          description: currentEvent.description ? String(currentEvent.description) : undefined,
+          description: currentEvent.description
+            ? sanitizeEventDescription(String(currentEvent.description))
+            : undefined,
           location: currentEvent.location ? String(currentEvent.location) : undefined,
           url: currentEvent.url ? String(currentEvent.url) : undefined,
           organizer: currentEvent.organizer as Organizer | undefined,
@@ -203,7 +206,9 @@ export function parseSingleICalEvent(icalText: string): Partial<CalendarEvent> {
         if (keyPart.includes("VALUE=DATE")) raw.isAllDay = true;
         break;
       case "DTEND": raw.end = parseICalDate(value, keyPart); break;
-      case "DESCRIPTION": raw.description = value.replace(/\\n/g, "\n"); break;
+      case "DESCRIPTION":
+        raw.description = sanitizeEventDescription(value.replace(/\\n/g, "\n"));
+        break;
       case "LOCATION": raw.location = value; break;
       case "URL": raw.url = value; break;
       case "RRULE": raw.rrule = value.trim(); break;

package/src/InMemorySource.ts

@@ -44,17 +44,17 @@ export class InMemorySource implements CalendarSource {
     return newEvent;
   }
 
-  async updateEvent(id: string, updates: Partial<CalendarEvent>): Promise<CalendarEvent> {
-    const event = this.events.get(id);
-    if (!event) {
-      throw new Error(`Event ${id} not found`);
+  async updateEvent(event: CalendarEvent, updates: Partial<CalendarEvent>): Promise<CalendarEvent> {
+    const existing = this.events.get(event.id);
+    if (!existing) {
+      throw new Error(`Event ${event.id} not found`);
     }
 
     const updated = {
-      ...event,
+      ...existing,
       ...updates,
     };
-    this.events.set(id, updated);
+    this.events.set(event.id, updated);
     return updated;
   }
 

package/src/IndexedDBStorage.ts

@@ -22,6 +22,7 @@ interface SerializedEvent {
   isAllDay?: boolean;
   reminders?: NotificationConfig[];
   visualStyle?: 'heatmap';
+  resourceUrl?: string;
 }
 
 interface SerializedMetadata {
@@ -328,6 +329,7 @@ export class IndexedDBStorage implements CalendarStorage {
       isAllDay: event.isAllDay,
       reminders: event.reminders,
       visualStyle: event.visualStyle,
+      resourceUrl: event.resourceUrl,
     };
   }
 
@@ -378,6 +380,7 @@ export class IndexedDBStorage implements CalendarStorage {
       isAllDay: serialized.isAllDay,
       reminders: serialized.reminders,
       visualStyle: serialized.visualStyle,
+      resourceUrl: serialized.resourceUrl,
     };
   }
 

package/src/InhouseBookingSource.ts

@@ -432,11 +432,12 @@ export class InhouseBookingSource implements CalendarSource {
   /**
    * Update an existing booking in the Inhouse Booking System.
    */
-  async updateEvent(id: string, updates: Partial<CalendarEvent>): Promise<CalendarEvent> {
+  async updateEvent(event: CalendarEvent, updates: Partial<CalendarEvent>): Promise<CalendarEvent> {
     if (!this.enabled) {
       throw new Error('Inhouse Booking System source is disabled');
     }
 
+    const id = event.id;
     const parsedId = this.parseEventId(id);
     if (!parsedId) {
       throw new Error(`Invalid event ID format: ${id}`);

package/src/app.ts

@@ -16,6 +16,7 @@ import { fetchTimeseriesJsonEvents } from "./TimeseriesJson.js";
 import { queueStatus } from "./StatusMessage.js";
 import { activeCalendarStore } from "./ActiveCalendarStore.js";
 import type { CalendarEvent } from "./CalendarInternal.js";
+import { sanitizeEventDescription } from "./DescriptionSanitizer.js";
 import { registerKeybinds } from "./Keybinds.js";
 import "./StatusBar.js";
 import { NotificationScheduler } from "./NotificationScheduler.js";
@@ -36,6 +37,136 @@ const calendarElement = document.querySelector(
 ) as CalendarViewElement;
 const calendar = calendarElement.internal;
 
+type PromptApiLanguageModel = {
+	availability?: () => Promise<string>;
+	create: (options?: unknown) => Promise<{
+		promptStreaming: (
+			prompt: string,
+			options?: unknown,
+		) => Promise<ReadableStream<string>> | ReadableStream<string>;
+		destroy?: () => void;
+	}>;
+};
+
+function getPromptApiLanguageModel(): PromptApiLanguageModel | null {
+	const fromGlobal = (globalThis as { LanguageModel?: unknown }).LanguageModel;
+	if (fromGlobal) return fromGlobal as PromptApiLanguageModel;
+
+	const fromWindow = (
+		window as { ai?: { languageModel?: unknown } }
+	).ai?.languageModel;
+	if (!fromWindow) return null;
+	return fromWindow as PromptApiLanguageModel;
+}
+
+let summaryAbortController: AbortController | null = null;
+let summarySession: { destroy?: () => void } | null = null;
+let summaryRequestToken = 0;
+let activeSummaryKey: string | null = null;
+
+function abortActiveDescriptionSummary(): void {
+	if (summaryAbortController) {
+		summaryAbortController.abort();
+		summaryAbortController = null;
+	}
+	if (summarySession) {
+		summarySession.destroy?.();
+		summarySession = null;
+	}
+	if (activeSummaryKey) {
+		calendarElement.cancelDescriptionSummary(activeSummaryKey);
+		activeSummaryKey = null;
+	}
+	summaryRequestToken++;
+}
+
+async function streamDescriptionSummary(key: string, description: string): Promise<void> {
+	const sanitizedDescription = sanitizeEventDescription(description);
+	abortActiveDescriptionSummary();
+	activeSummaryKey = key;
+	const token = summaryRequestToken;
+	calendarElement.startDescriptionSummary(key);
+
+	const languageModel = getPromptApiLanguageModel();
+	if (!languageModel) {
+		calendarElement.failDescriptionSummary(key, "Prompt API not available in this browser.");
+		activeSummaryKey = null;
+		return;
+	}
+
+	const controller = new AbortController();
+	summaryAbortController = controller;
+	let session: { destroy?: () => void } | null = null;
+
+	try {
+		const availability = await languageModel.availability?.();
+		if (token !== summaryRequestToken || key !== activeSummaryKey) return;
+		if (availability === "unavailable") {
+			throw new Error("Prompt API model is unavailable.");
+		}
+
+		session = await languageModel.create();
+		summarySession = session;
+		const prompt = [
+			"Summarize this calendar event description in 2-3 concise sentences.",
+			"Keep critical details like dates, times, links, and action items.",
+			"Return plain text only.",
+			"",
+			sanitizedDescription,
+		].join("\n");
+
+		const stream = await Promise.resolve(
+			session.promptStreaming(prompt, { signal: controller.signal }),
+		);
+		const reader = stream.getReader();
+		try {
+			while (true) {
+				const { value, done } = await reader.read();
+				if (done) break;
+				if (
+					token !== summaryRequestToken ||
+					key !== activeSummaryKey ||
+					controller.signal.aborted
+				) {
+					return;
+				}
+				if (value) {
+					calendarElement.appendDescriptionSummaryChunk(key, value);
+				}
+			}
+		} finally {
+			reader.releaseLock();
+		}
+
+		if (token !== summaryRequestToken || key !== activeSummaryKey) return;
+		calendarElement.finishDescriptionSummary(key);
+		activeSummaryKey = null;
+	} catch (error) {
+		if (
+			controller.signal.aborted ||
+			token !== summaryRequestToken ||
+			key !== activeSummaryKey
+		) {
+			return;
+		}
+		calendarElement.failDescriptionSummary(
+			key,
+			error instanceof Error
+				? error.message
+				: "Failed to generate description summary.",
+		);
+		activeSummaryKey = null;
+	} finally {
+		if (summaryAbortController === controller) {
+			summaryAbortController = null;
+		}
+		if (summarySession === session) {
+			summarySession = null;
+		}
+		session?.destroy?.();
+	}
+}
+
 registerKeybinds(
 	[
 		{ key: "r", cmdOrCtrl: true, shift: true, action: () => calendarElement.forceSync() },
@@ -109,6 +240,21 @@ calendarElement.addEventListener("event-click", () => {
 	requestNotificationPermission();
 }, { once: true });
 
+calendarElement.addEventListener("request-description-summary", (e: Event) => {
+	const { key, description } = (e as CustomEvent).detail as {
+		key: string;
+		description: string;
+	};
+	void streamDescriptionSummary(key, description);
+});
+
+calendarElement.addEventListener("cancel-description-summary", (e: Event) => {
+	const { key } = (e as CustomEvent).detail as { key: string };
+	if (key === activeSummaryKey) {
+		abortActiveDescriptionSummary();
+	}
+});
+
 // Load iCal files
 const integration = new CalendarIntegration(calendar);
 
@@ -277,10 +423,10 @@ async function createCalDAVCalendars(
 			},
 
 			async updateEvent(
-				id: string,
+				event: CalendarEvent,
 				updates: Partial<CalendarEvent>,
 			): Promise<CalendarEvent> {
-				return caldavSource.updateEvent(id, { ...updates, calendarId: calInfo.url });
+				return caldavSource.updateEvent(event, { ...updates, calendarId: calInfo.url });
 			},
 
 			async deleteEvent(id: string): Promise<void> {
@@ -372,10 +518,10 @@ function createGoogleCalendar(source: CalendarSource): Calendar {
 		},
 
 		async updateEvent(
-			id: string,
+			event: CalendarEvent,
 			updates: Partial<CalendarEvent>,
 		): Promise<CalendarEvent> {
-			return googleSource.updateEvent(id, updates);
+			return googleSource.updateEvent(event, updates);
 		},
 
 		async deleteEvent(id: string): Promise<void> {
@@ -419,10 +565,10 @@ function createInhouseCalendar(source: CalendarSource): Calendar {
 		},
 
 		async updateEvent(
-			id: string,
+			event: CalendarEvent,
 			updates: Partial<CalendarEvent>,
 		): Promise<CalendarEvent> {
-			return inhouseSource.updateEvent(id, updates);
+			return inhouseSource.updateEvent(event, updates);
 		},
 
 		async deleteEvent(id: string): Promise<void> {
@@ -458,12 +604,12 @@ function createInMemoryCalendar(source: InMemorySource): Calendar {
 		},
 
 		async updateEvent(
-			id: string,
+			event: CalendarEvent,
 			updates: Partial<CalendarEvent>,
 		): Promise<CalendarEvent> {
 			if (!source.updateEvent)
 				throw new Error("Source does not support updateEvent");
-			return source.updateEvent(id, updates);
+			return source.updateEvent(event, updates);
 		},
 
 		async deleteEvent(id: string): Promise<void> {
@@ -806,41 +952,6 @@ calendarElement.addEventListener("create-event", async (e) => {
 	}
 });
 
-calendarElement.addEventListener("move-event", async (e) => {
-	const { event, start, end } = e.detail;
-
-	const calendar = findCalendarForEvent(event);
-
-	if (!calendar) {
-		queueStatus("Cannot move event: calendar not found.");
-		return;
-	}
-
-	if (!calendar.updateEvent) {
-		queueStatus(`Calendar "${calendar.name}" does not support moving events.`);
-		return;
-	}
-
-	console.log(
-		"Moving event:",
-		event.id,
-		"from",
-		event.start,
-		"to",
-		start,
-		"on calendar:",
-		calendar.name,
-	);
-	try {
-		calendarElement.internal.applyEventOptimistically({ ...event, start, end });
-		await withMutation(calendar, () => calendar.updateEvent(event.id, { start, end }));
-	} catch (error) {
-		calendarElement.internal.applyEventOptimistically(event);
-		console.error("Failed to move event:", error);
-		queueStatus(`Failed to move event: ${error instanceof Error ? error.message : String(error)}`);
-	}
-});
-
 calendarElement.addEventListener("update-event", async (e) => {
 	const { event, updates } = e.detail;
 
@@ -864,7 +975,7 @@ calendarElement.addEventListener("update-event", async (e) => {
 	);
 	try {
 		calendarElement.internal.applyEventOptimistically({ ...event, ...updates });
-		await withMutation(calendar, () => calendar.updateEvent(event.id, updates));
+		await withMutation(calendar, () => calendar.updateEvent(event, updates));
 
 		if ("reminders" in updates) {
 			const eventWithReminders = { ...event, ...updates };