@open-webapp/calendar 0.0.0-stage → 0.2.0

package/dist/core/events.js

@@ -0,0 +1,257 @@
+const MS_PER_DAY = 24 * 60 * 60 * 1000;
+export const DEFAULT_RSVP_STATUSES = ['accepted', 'tentative', 'needsAction'];
+/** Keeps stored calendar selections that still exist, defaulting to the primary calendar. */
+export function reconcileSelectedCalendarIds(storedIds, calendars) {
+    const availableIds = new Set(calendars.map((calendar) => calendar.id));
+    const selectedIds = (storedIds ?? []).filter((id) => availableIds.has(id));
+    if (selectedIds.length > 0)
+        return selectedIds;
+    const fallback = calendars.find((calendar) => calendar.primary) ?? calendars[0];
+    return fallback ? [fallback.id] : [];
+}
+/** Filters calendars by a case-insensitive substring of their display name. */
+export function filterCalendarsByName(calendars, query) {
+    const normalizedQuery = query.toLocaleLowerCase();
+    return normalizedQuery === ''
+        ? calendars
+        : calendars.filter((calendar) => calendar.summary.toLocaleLowerCase().includes(normalizedQuery));
+}
+/** Event IDs are unique only within their calendar and source. */
+export function getCalendarEventKey(event) {
+    return `${event.sourceId}:${event.calendarId ?? ""}:${event.id}`;
+}
+/** Produces the compact calendar-selection label shown in the filter control. */
+export function summarizeCalendarSelection(selectedIds, calendars) {
+    if (selectedIds.length !== 1)
+        return `${selectedIds.length} calendars`;
+    return calendars.find((calendar) => calendar.id === selectedIds[0])?.summary ?? '1 calendar';
+}
+/** True iff the event is an all-day event. Passthrough of the package-computed flag. */
+export function isAllDay(event) {
+    return event.isAllDay;
+}
+/**
+ * Rolling fetch window: now-30d to now+30d, as full RFC3339 timestamps.
+ * Google Calendar's `timeMin`/`timeMax` reject bare `YYYY-MM-DD` dates.
+ */
+export function getRollingWindow(now) {
+    const start = new Date(now.getTime() - 30 * MS_PER_DAY);
+    const end = new Date(now.getTime() + 30 * MS_PER_DAY);
+    return { start: start.toISOString(), end: end.toISOString() };
+}
+function toIsoDate(d) {
+    return d.toISOString().slice(0, 10);
+}
+/**
+ * Returns events whose `selfResponseStatus` is a member of `selected` —
+ * declined is a normal, independently-selectable status now, not hard-excluded.
+ */
+export function filterByRsvp(events, selected) {
+    return events.filter((e) => selected.has(e.selfResponseStatus));
+}
+/** displayName -> email -> "You" (only when organizer.self is true and both above are absent). */
+export function getOrganizerLabel(event) {
+    const { organizer } = event;
+    if (organizer.displayName)
+        return organizer.displayName;
+    if (organizer.email)
+        return organizer.email;
+    if (organizer.self === true)
+        return 'You';
+    return '';
+}
+/**
+ * True iff `event` is a timed (non-all-day) event currently in progress at `now`:
+ * both `start.dateTime` and `end.dateTime` exist and parse to valid instants,
+ * start <= now < end.
+ */
+export function isEventCurrent(event, now) {
+    if (isAllDay(event))
+        return false;
+    const { start, end } = event;
+    if (!start.dateTime || !end.dateTime)
+        return false;
+    const startMs = new Date(start.dateTime).getTime();
+    const endMs = new Date(end.dateTime).getTime();
+    if (Number.isNaN(startMs) || Number.isNaN(endMs))
+        return false;
+    const nowMs = now.getTime();
+    return startMs <= nowMs && nowMs < endMs;
+}
+/**
+ * Finds the soonest strictly-future timed event: `!isAllDay(event)`,
+ * `start.dateTime` exists and parses valid, and `startMs > now.getTime()`.
+ * Returns the smallest `startMs`; ties keep first-encountered array order.
+ * Returns `null` if none qualify.
+ */
+export function findNextUpcomingEvent(events, now) {
+    const nowMs = now.getTime();
+    let best = null;
+    let bestMs = Infinity;
+    for (const event of events) {
+        if (isAllDay(event))
+            continue;
+        const { dateTime } = event.start;
+        if (!dateTime)
+            continue;
+        const startMs = new Date(dateTime).getTime();
+        if (Number.isNaN(startMs))
+            continue;
+        if (startMs <= nowMs)
+            continue;
+        if (startMs < bestMs) {
+            bestMs = startMs;
+            best = event;
+        }
+    }
+    return best;
+}
+function getStartDateKey(event) {
+    const { start } = event;
+    if (start.date)
+        return start.date;
+    if (start.dateTime)
+        return start.dateTime.slice(0, 10);
+    return '';
+}
+function getStartTimeSortKey(event) {
+    const { start } = event;
+    if (start.dateTime)
+        return new Date(start.dateTime).getTime();
+    return -Infinity; // all-day events sort first
+}
+/**
+ * Group by local calendar date, sorted ascending by day. Within a day,
+ * all-day events come first (in list order), then timed events sorted by
+ * start time ascending.
+ *
+ * When `todayIso` is given and has no events, an empty group for it is
+ * still included (so a "Today" header can always be rendered / scrolled
+ * to), inserted in correct sorted position.
+ */
+export function groupByDay(events, todayIso) {
+    const byDate = new Map();
+    for (const event of events) {
+        const key = getStartDateKey(event);
+        const list = byDate.get(key);
+        if (list) {
+            list.push(event);
+        }
+        else {
+            byDate.set(key, [event]);
+        }
+    }
+    if (todayIso !== undefined && !byDate.has(todayIso)) {
+        byDate.set(todayIso, []);
+    }
+    const dateKeys = Array.from(byDate.keys()).sort();
+    return dateKeys.map((dateKey) => {
+        const dayEvents = byDate.get(dateKey);
+        const allDayEvents = dayEvents.filter((e) => isAllDay(e));
+        const timedEvents = dayEvents
+            .filter((e) => !isAllDay(e))
+            .sort((a, b) => getStartTimeSortKey(a) - getStartTimeSortKey(b));
+        return { dateKey, events: [...allDayEvents, ...timedEvents] };
+    });
+}
+const MONTH_NAMES = [
+    'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
+    'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec',
+];
+function parseIsoDateParts(dateKey) {
+    const [year, month, day] = dateKey.split('-').map(Number);
+    return { year, month, day };
+}
+function formatMonthDay(dateKey, includeYear) {
+    const { year, month, day } = parseIsoDateParts(dateKey);
+    const monthName = MONTH_NAMES[month - 1];
+    const base = `${monthName} ${day}`;
+    return includeYear ? `${base}, ${year}` : base;
+}
+function addDaysToIso(dateKey, days) {
+    const { year, month, day } = parseIsoDateParts(dateKey);
+    const d = new Date(Date.UTC(year, month - 1, day));
+    d.setUTCDate(d.getUTCDate() + days);
+    return toIsoDate(d);
+}
+/**
+ * "Today · Sept 26" / "Tomorrow · Sept 27" / else "Sept 28"-style.
+ * Includes year only when the event's year differs from today's year.
+ */
+export function formatDayHeader(dateKey, today) {
+    const { year: todayYear } = parseIsoDateParts(today);
+    const { year: eventYear } = parseIsoDateParts(dateKey);
+    const includeYear = eventYear !== todayYear;
+    const monthDay = formatMonthDay(dateKey, includeYear);
+    if (dateKey === today)
+        return `Today · ${monthDay}`;
+    if (dateKey === addDaysToIso(today, 1))
+        return `Tomorrow · ${monthDay}`;
+    return monthDay;
+}
+const JOIN_URL_REGEX = /https?:\/\/[^\s<>"']*(?:zoom\.us|meet\.google\.com|teams\.microsoft\.com)[^\s<>"']*/i;
+export function deriveSelfResponseStatus(raw) {
+    if (!Array.isArray(raw.attendees))
+        return 'accepted';
+    const status = raw.attendees.find((a) => a?.self === true)?.responseStatus;
+    if (status === 'accepted' || status === 'tentative' || status === 'needsAction' || status === 'declined') {
+        return status;
+    }
+    return 'needsAction';
+}
+export function extractJoinUrl(raw) {
+    if (raw.hangoutLink)
+        return raw.hangoutLink;
+    const video = raw.conferenceData?.entryPoints?.find((ep) => ep.entryPointType === 'video');
+    if (video?.uri)
+        return video.uri;
+    const loc = typeof raw.location === 'string' ? raw.location.match(JOIN_URL_REGEX) : null;
+    if (loc)
+        return loc[0];
+    const desc = typeof raw.description === 'string' ? raw.description.match(JOIN_URL_REGEX) : null;
+    return desc ? desc[0] : null;
+}
+/** Parses a raw Google Calendar event. Returns null for cancelled/malformed input; never throws. */
+export function parseEvent(raw, ctx) {
+    try {
+        if (!raw || typeof raw !== 'object')
+            return null;
+        if (typeof raw.id !== 'string' || raw.id === '')
+            return null;
+        if (raw.status === 'cancelled')
+            return null;
+        const start = raw.start ?? {};
+        const end = raw.end ?? {};
+        return {
+            id: raw.id,
+            sourceId: ctx.sourceId,
+            calendarId: ctx.calendarId,
+            summary: raw.summary ?? '',
+            start: { dateTime: start.dateTime, date: start.date, timeZone: start.timeZone },
+            end: { dateTime: end.dateTime, date: end.date, timeZone: end.timeZone },
+            isAllDay: Boolean(start.date && !start.dateTime),
+            selfResponseStatus: deriveSelfResponseStatus(raw),
+            joinUrl: extractJoinUrl(raw),
+            organizer: {
+                displayName: raw.organizer?.displayName,
+                email: raw.organizer?.email,
+                self: Boolean(raw.organizer?.self),
+            },
+            htmlLink: raw.htmlLink ?? '',
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function parseEvents(items, ctx) {
+    const out = [];
+    if (!Array.isArray(items))
+        return out;
+    for (const item of items) {
+        const e = parseEvent(item, ctx);
+        if (e)
+            out.push(e);
+    }
+    return out;
+}

package/dist/core/fetch.d.ts

@@ -0,0 +1,23 @@
+import type { CalendarInfo } from './types.js';
+export declare class CalendarFetchError extends Error {
+    kind: 'network' | 'auth' | 'scope' | 'gone' | 'http';
+    status: number;
+    constructor(kind: 'network' | 'auth' | 'scope' | 'gone' | 'http', status?: number);
+}
+/** Thrown by a host's getToken when a token refresh was deferred (e.g. app inactive). Aborts a pass quietly. */
+export declare class RefreshDeferredError extends Error {
+    readonly deferred = true;
+    constructor(message?: string);
+}
+export declare function isRefreshDeferredError(e: unknown): boolean;
+export declare function fetchCalendarList(token: string): Promise<CalendarInfo[]>;
+export interface EventsPage {
+    items: any[];
+    nextSyncToken?: string;
+}
+/** Fetches all pages of events. With syncToken, no time bounds are sent (the API forbids them). */
+export declare function fetchEvents(token: string, calendarId: string, opts: {
+    syncToken?: string;
+    timeMin?: string;
+    timeMax?: string;
+}): Promise<EventsPage>;

package/dist/core/fetch.js

@@ -0,0 +1,108 @@
+const BASE = 'https://www.googleapis.com/calendar/v3';
+export class CalendarFetchError extends Error {
+    kind;
+    status;
+    constructor(kind, status = 0) {
+        super(`calendar fetch failed: ${kind} ${status}`);
+        this.kind = kind;
+        this.status = status;
+    }
+}
+/** Thrown by a host's getToken when a token refresh was deferred (e.g. app inactive). Aborts a pass quietly. */
+export class RefreshDeferredError extends Error {
+    deferred = true;
+    constructor(message = 'token refresh deferred') {
+        super(message);
+        this.name = 'RefreshDeferredError';
+    }
+}
+export function isRefreshDeferredError(e) {
+    if (e instanceof RefreshDeferredError)
+        return true;
+    const x = e;
+    return !!x && (x.deferred === true || x.name === 'RefreshDeferredError');
+}
+async function request(url, token) {
+    let res;
+    try {
+        res = await fetch(url, { headers: { Authorization: `Bearer ${token}` } });
+    }
+    catch {
+        throw new CalendarFetchError('network');
+    }
+    if (res.ok) {
+        try {
+            return await res.json();
+        }
+        catch {
+            throw new CalendarFetchError('http', res.status);
+        }
+    }
+    if (res.status === 410)
+        throw new CalendarFetchError('gone', 410);
+    if (res.status === 401)
+        throw new CalendarFetchError('auth', 401);
+    if (res.status === 403) {
+        let body = null;
+        try {
+            body = await res.json();
+        }
+        catch {
+            /* ignore */
+        }
+        const insufficient = JSON.stringify(body ?? {}).includes('insufficientPermissions');
+        throw new CalendarFetchError(insufficient ? 'scope' : 'http', 403);
+    }
+    throw new CalendarFetchError('http', res.status);
+}
+export async function fetchCalendarList(token) {
+    const out = [];
+    let pageToken;
+    do {
+        const u = new URL(`${BASE}/users/me/calendarList`);
+        if (pageToken)
+            u.searchParams.set('pageToken', pageToken);
+        const body = await request(u.toString(), token);
+        for (const c of body.items ?? []) {
+            out.push({
+                id: c.id,
+                summary: c.summaryOverride ?? c.summary ?? c.id,
+                backgroundColor: c.backgroundColor,
+                foregroundColor: c.foregroundColor,
+                primary: Boolean(c.primary),
+                accessRole: c.accessRole ?? '',
+                selected: c.selected,
+            });
+        }
+        pageToken = body.nextPageToken;
+    } while (pageToken);
+    return out;
+}
+const noMillis = (iso) => iso.replace(/\.\d{3}Z$/, 'Z');
+/** Fetches all pages of events. With syncToken, no time bounds are sent (the API forbids them). */
+export async function fetchEvents(token, calendarId, opts) {
+    const items = [];
+    let pageToken;
+    let nextSyncToken;
+    do {
+        const u = new URL(`${BASE}/calendars/${encodeURIComponent(calendarId)}/events`);
+        u.searchParams.set('maxResults', '250');
+        if (opts.syncToken) {
+            u.searchParams.set('syncToken', opts.syncToken);
+        }
+        else {
+            u.searchParams.set('singleEvents', 'true');
+            if (opts.timeMin)
+                u.searchParams.set('timeMin', noMillis(opts.timeMin));
+            if (opts.timeMax)
+                u.searchParams.set('timeMax', noMillis(opts.timeMax));
+        }
+        if (pageToken)
+            u.searchParams.set('pageToken', pageToken);
+        const body = await request(u.toString(), token);
+        items.push(...(body.items ?? []));
+        pageToken = body.nextPageToken;
+        nextSyncToken = body.nextSyncToken ?? nextSyncToken;
+    } while (pageToken);
+    return { items, nextSyncToken };
+}

package/dist/core/reconcile.d.ts

@@ -0,0 +1,8 @@
+import type { CalendarEvent, CalendarInfo } from './types.js';
+/** Stored selection filtered to existing calendars; falls back to primary (else first). Primary is not forced. */
+export declare function reconcileSelection(stored: string[] | null, calendars: CalendarInfo[]): string[];
+/** Applies an incremental page of raw items to one calendar's events (cancelled items remove). */
+export declare function applyChanges(existing: CalendarEvent[], items: any[], ctx: {
+    sourceId: string;
+    calendarId: string;
+}): CalendarEvent[];

package/dist/core/reconcile.js

@@ -0,0 +1,20 @@
+import { reconcileSelectedCalendarIds } from './events.js';
+import { parseEvent } from './events.js';
+/** Stored selection filtered to existing calendars; falls back to primary (else first). Primary is not forced. */
+export function reconcileSelection(stored, calendars) {
+    return reconcileSelectedCalendarIds(stored, calendars);
+}
+/** Applies an incremental page of raw items to one calendar's events (cancelled items remove). */
+export function applyChanges(existing, items, ctx) {
+    const map = new Map(existing.map((e) => [e.id, e]));
+    for (const raw of items) {
+        if (!raw || typeof raw.id !== 'string')
+            continue;
+        const parsed = parseEvent(raw, ctx);
+        if (parsed)
+            map.set(parsed.id, parsed);
+        else
+            map.delete(raw.id);
+    }
+    return [...map.values()];
+}

package/dist/core/storage.d.ts

@@ -0,0 +1,25 @@
+import type { CalendarEvent } from './types.js';
+export interface SyncState {
+    /** Per-calendar incremental sync tokens. */
+    tokens: Record<string, string>;
+    /** Per-calendar ms epoch of last full sync (optional; absent on 0.1.0 rows). */
+    lastFullSyncAt?: Record<string, number>;
+    /** ms epoch of last successful sync pass (optional; absent on 0.1.0 rows). */
+    lastSyncAt?: number;
+}
+/** Persisted per-source row. `events` is an encrypted JSON string when written by the controller. */
+export interface StorageRow {
+    events: CalendarEvent[] | string | unknown[];
+    syncState: SyncState | string | null | unknown;
+    selectedIds: string[];
+}
+export interface StorageAdapter {
+    get(sourceId: string): Promise<StorageRow | null>;
+    put(sourceId: string, row: StorageRow): Promise<void>;
+    delete(sourceId: string): Promise<void>;
+    clear(sourceId: string): Promise<void>;
+}
+export interface CryptoAdapter {
+    encrypt(plaintext: string): Promise<string>;
+    decrypt(ciphertext: string): Promise<string>;
+}

package/dist/core/storage.js

@@ -0,0 +1 @@
+export {};

package/dist/core/sync.d.ts

@@ -0,0 +1,18 @@
+import type { CalendarEvent } from './types.js';
+export interface CalendarSyncResult {
+    events: CalendarEvent[];
+    syncToken?: string;
+    /** True when a full (windowed) sync was performed. */
+    full: boolean;
+}
+export declare const FULL_SYNC_MAX_AGE_MS: number;
+/** Syncs one calendar: incremental when a token exists, full (windowed) otherwise or on 410. */
+export declare function syncCalendar(args: {
+    token: string;
+    sourceId: string;
+    calendarId: string;
+    existing: CalendarEvent[];
+    syncToken?: string;
+    lastFullSyncAt?: number;
+    now: Date;
+}): Promise<CalendarSyncResult>;

package/dist/core/sync.js

@@ -0,0 +1,30 @@
+import { CalendarFetchError, fetchEvents } from './fetch.js';
+import { getRollingWindow, parseEvents } from './events.js';
+import { applyChanges } from './reconcile.js';
+export const FULL_SYNC_MAX_AGE_MS = 24 * 3600_000;
+/** Syncs one calendar: incremental when a token exists, full (windowed) otherwise or on 410. */
+export async function syncCalendar(args) {
+    const { token, sourceId, calendarId, existing, syncToken, lastFullSyncAt, now } = args;
+    const ctx = { sourceId, calendarId };
+    const full = async () => {
+        const w = getRollingWindow(now);
+        const page = await fetchEvents(token, calendarId, { timeMin: w.start, timeMax: w.end });
+        return { events: parseEvents(page.items, ctx), syncToken: page.nextSyncToken, full: true };
+    };
+    const stale = lastFullSyncAt === undefined || now.getTime() - lastFullSyncAt > FULL_SYNC_MAX_AGE_MS;
+    if (!syncToken || stale)
+        return full();
+    try {
+        const page = await fetchEvents(token, calendarId, { syncToken });
+        return {
+            events: applyChanges(existing, page.items, ctx),
+            syncToken: page.nextSyncToken ?? syncToken,
+            full: false,
+        };
+    }
+    catch (e) {
+        if (e instanceof CalendarFetchError && e.kind === 'gone')
+            return full();
+        throw e;
+    }
+}

package/dist/core/types.d.ts

@@ -0,0 +1,45 @@
+/** A connected account that calendars are read from. */
+export interface Source {
+    id: string;
+    email: string;
+    label?: string;
+}
+export type RsvpStatus = 'accepted' | 'tentative' | 'needsAction' | 'declined';
+export interface CalendarEventDateTime {
+    dateTime?: string;
+    date?: string;
+    timeZone?: string;
+}
+export interface CalendarEvent {
+    id: string;
+    /** ID of the Source (account) this event came from. */
+    sourceId: string;
+    /** ID of the calendar this event belongs to. */
+    calendarId?: string;
+    summary: string;
+    start: CalendarEventDateTime;
+    end: CalendarEventDateTime;
+    /** True iff `start.date` is present with no `start.dateTime`. */
+    isAllDay: boolean;
+    selfResponseStatus: RsvpStatus;
+    joinUrl: string | null;
+    organizer: {
+        displayName?: string;
+        email?: string;
+        self: boolean;
+    };
+    htmlLink: string;
+}
+export interface CalendarInfo {
+    id: string;
+    summary: string;
+    backgroundColor?: string;
+    foregroundColor?: string;
+    primary: boolean;
+    accessRole: string;
+    selected?: boolean;
+}
+export interface ParseContext {
+    sourceId: string;
+    calendarId: string;
+}

package/dist/core/types.js

@@ -0,0 +1 @@
+export {};

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export * from './core/types.js';
+export * from './core/events.js';
+export * from './core/storage.js';
+export * from './core/fetch.js';
+export * from './core/sync.js';
+export * from './core/reconcile.js';
+export * from './core/controller.js';
+export * from './react/index.js';

package/dist/index.js

@@ -0,0 +1,8 @@
+export * from './core/types.js';
+export * from './core/events.js';
+export * from './core/storage.js';
+export * from './core/fetch.js';
+export * from './core/sync.js';
+export * from './core/reconcile.js';
+export * from './core/controller.js';
+export * from './react/index.js';

package/dist/react/CalendarPane.d.ts

@@ -0,0 +1,23 @@
+import { type JSX, type ReactNode } from 'react';
+import type { CalendarEvent, RsvpStatus, Source } from '../core/types.js';
+import type { CalendarController } from '../core/controller.js';
+export type RsvpSelection = Set<RsvpStatus>;
+export interface CalendarPaneProps {
+    sources: Source[];
+    controller: CalendarController;
+    selectedRsvpStatuses: RsvpSelection;
+    onRsvpStatusesChange: (next: RsvpSelection) => void;
+    renderEventAction?: (event: CalendarEvent) => ReactNode;
+    emptyState?: ReactNode;
+    sourceNotice?: (source: Source) => ReactNode;
+    onClose?: () => void;
+    /** Whether Google Calendar is connected. Defaults to `sources.length > 0`. */
+    connected?: boolean;
+    /** Whether the connection needs reauthorization. Defaults to all sources being 'needs-scope'. */
+    needsReauth?: boolean;
+    onConnect?: () => void;
+    onReconnect?: () => void;
+    /** Window name used for the event popup. */
+    popupName?: string;
+}
+export declare function CalendarPane(props: CalendarPaneProps): JSX.Element;