@remit/calendar-service 0.0.18 → 0.0.19

package/dist/memory-store.d.ts

@@ -0,0 +1,105 @@
+import type { CalendarRepositories, CalendarWrite, ICalendarStore, ICalendarSuggestionRepository } from "@remit/data-ports";
+import { NotFoundError } from "@remit/data-ports/errors";
+export declare class MissingRow extends NotFoundError {
+}
+/**
+ * The calendar store over plain maps. A commit applies its writes in order;
+ * that they stand or fall together on a real database is proven in
+ * drizzle-service's calendar-put.sqlite.test.ts.
+ */
+export declare class MemoryCalendarStore implements ICalendarStore {
+    readonly collections: Map<string, {
+        displayName: string;
+        accountConfigId: string;
+        createdAt: number;
+        updatedAt: number;
+        source: "Default" | "UserCreated" | "MailDerived" | "Subscribed";
+        color: "Cal1" | "Cal2" | "Cal3" | "Cal4" | "Cal5" | "Cal6";
+        calendarId: string;
+        urlSegment: string;
+        componentSet: "VeventOnly";
+        timezone: string;
+        syncSequence: number;
+        subscriptionUrl: string;
+        subscriptionEnabled: boolean;
+        subscriptionCheckedAt: number;
+        subscriptionFetchedAt: number;
+        subscriptionError: string;
+    }>;
+    readonly objects: Map<string, {
+        status: "Confirmed" | "Tentative" | "Cancelled";
+        createdAt: number;
+        updatedAt: number;
+        summary: string;
+        calendarId: string;
+        syncSequence: number;
+        etag: string;
+        icalData: string;
+        calendarObjectId: string;
+        icalUid: string;
+        allDay: boolean;
+        transparency: "Opaque" | "Transparent";
+        zoneCertainty: "Local" | "Explicit" | "Ambiguous";
+        hasRecurrence: boolean;
+        resourceName: string;
+        sequence: number;
+        dtStart: string;
+        dtEnd: string;
+        expandedThrough: string;
+    }>;
+    readonly occurrences: Map<string, {
+        status: "Confirmed" | "Tentative" | "Cancelled";
+        createdAt: number;
+        updatedAt: number;
+        summary: string;
+        calendarId: string;
+        calendarObjectId: string;
+        recurrenceId: string;
+        allDay: boolean;
+        transparency: "Opaque" | "Transparent";
+        startAt: string;
+        endAt: string;
+    }[]>;
+    readonly suggestions: Map<string, {
+        accountConfigId: string;
+        state: "Pending" | "Tentative" | "Accepted" | "Declined" | "Dismissed" | "Superseded";
+        createdAt: number;
+        updatedAt: number;
+        source: "IcalendarPart" | "IcalendarAttachment" | "TextHeuristic";
+        summary: string;
+        icalData: string;
+        icalUid: string;
+        allDay: boolean;
+        zoneCertainty: "Local" | "Explicit" | "Ambiguous";
+        location: string;
+        sequence: number;
+        dtStart: string;
+        dtEnd: string;
+        messageId: string;
+        bodyPartId: string;
+        suggestionId: string;
+        method: "None" | "Request" | "Reply" | "Cancel" | "Counter" | "Publish";
+        endsAtUtc: string;
+        organizer: string;
+        acceptedCalendarObjectId: string;
+        supersededByMessageId: string;
+    }>;
+    readonly feedTokens: Map<string, {
+        accountConfigId: string;
+        createdAt: number;
+        updatedAt: number;
+        calendarId: string;
+        rotatedAt: number;
+        feedTokenId: string;
+        tokenHash: string;
+    }>;
+    private readonly collectionRepo;
+    private readonly objectRepo;
+    private readonly eventIndexRepo;
+    private readonly suggestionRepo;
+    private readonly feedTokenRepo;
+    get calendarSuggestion(): ICalendarSuggestionRepository;
+    get repos(): CalendarRepositories;
+    commit(writes: readonly CalendarWrite[]): Promise<void>;
+    private apply;
+}

package/dist/memory-store.js

@@ -0,0 +1,319 @@
+import { NotFoundError } from "@remit/data-ports/errors";
+import { deriveCalendarFeedTokenId, deriveCalendarId, deriveCalendarObjectId, deriveCalendarSuggestionId, normalizeCalendarUrlSegment, } from "@remit/data-ports/id";
+import { CalendarSuggestionState } from "@remit/domain-enums";
+// The class the port's conformance suite requires a repository to throw for an
+// absent row, so a caller that branches on it — the calendar feed answers 404 to
+// a token whose collection is gone — behaves the same against this double as
+// against a real one.
+export class MissingRow extends NotFoundError {
+}
+/**
+ * The calendar store over plain maps. A commit applies its writes in order;
+ * that they stand or fall together on a real database is proven in
+ * drizzle-service's calendar-put.sqlite.test.ts.
+ */
+export class MemoryCalendarStore {
+    collections = new Map();
+    objects = new Map();
+    occurrences = new Map();
+    suggestions = new Map();
+    feedTokens = new Map();
+    collectionRepo = {
+        create: async (input) => {
+            const urlSegment = normalizeCalendarUrlSegment(input.urlSegment);
+            const calendarId = deriveCalendarId(input.accountConfigId, urlSegment);
+            const existing = this.collections.get(calendarId);
+            if (existing)
+                return existing;
+            const now = Date.now();
+            const collection = {
+                calendarId,
+                accountConfigId: input.accountConfigId,
+                urlSegment,
+                displayName: input.displayName,
+                color: input.color ?? "Cal1",
+                componentSet: input.componentSet ?? "VeventOnly",
+                source: input.source ?? "UserCreated",
+                timezone: input.timezone ?? "",
+                syncSequence: 0,
+                subscriptionUrl: input.subscriptionUrl ?? "",
+                subscriptionEnabled: input.subscriptionEnabled ?? false,
+                subscriptionCheckedAt: 0,
+                subscriptionFetchedAt: 0,
+                subscriptionError: "",
+                createdAt: now,
+                updatedAt: now,
+            };
+            this.collections.set(calendarId, collection);
+            return collection;
+        },
+        get: async (_accountConfigId, calendarId) => {
+            const collection = this.collections.get(calendarId);
+            if (!collection)
+                throw new MissingRow(calendarId);
+            return collection;
+        },
+        update: async (_accountConfigId, calendarId, input) => {
+            const collection = this.collections.get(calendarId);
+            if (!collection)
+                throw new MissingRow(calendarId);
+            const updated = { ...collection, ...input };
+            this.collections.set(calendarId, updated);
+            return updated;
+        },
+        delete: async (_accountConfigId, calendarId) => {
+            this.collections.delete(calendarId);
+        },
+        listByAccountConfig: async (accountConfigId) => [...this.collections.values()].filter((collection) => collection.accountConfigId === accountConfigId),
+        createExclusive: async (input) => {
+            const calendarId = deriveCalendarId(input.accountConfigId, input.urlSegment);
+            if (this.collections.has(calendarId))
+                return null;
+            return this.collectionRepo.create(input);
+        },
+        listEnabledSubscriptions: async () => [...this.collections.values()].filter((collection) => collection.source === "Subscribed" && collection.subscriptionEnabled),
+        findByUrlSegment: async (accountConfigId, urlSegment) => this.collections.get(deriveCalendarId(accountConfigId, urlSegment)) ??
+            null,
+        bumpSyncSequence: async (_accountConfigId, calendarId) => {
+            const collection = this.collections.get(calendarId);
+            if (!collection)
+                throw new MissingRow(calendarId);
+            const bumped = {
+                ...collection,
+                syncSequence: collection.syncSequence + 1,
+                updatedAt: Date.now(),
+            };
+            this.collections.set(calendarId, bumped);
+            return bumped.syncSequence;
+        },
+    };
+    objectRepo = {
+        put: async (input) => {
+            const calendarObjectId = deriveCalendarObjectId(input.calendarId, input.resourceName);
+            const now = Date.now();
+            const object = {
+                ...input,
+                calendarObjectId,
+                createdAt: this.objects.get(calendarObjectId)?.createdAt ?? now,
+                updatedAt: now,
+            };
+            this.objects.set(calendarObjectId, object);
+            return object;
+        },
+        listIncompleteExpansions: async (calendarId, instant) => [...this.objects.values()].filter((object) => object.calendarId === calendarId &&
+            object.expandedThrough !== "" &&
+            object.expandedThrough < instant),
+        find: async (_calendarId, calendarObjectId) => this.objects.get(calendarObjectId) ?? null,
+        get: async (_calendarId, calendarObjectId) => {
+            const object = this.objects.get(calendarObjectId);
+            if (!object)
+                throw new MissingRow(calendarObjectId);
+            return object;
+        },
+        delete: async (_calendarId, calendarObjectId) => {
+            this.objects.delete(calendarObjectId);
+        },
+        findByResourceName: async (calendarId, resourceName) => this.objects.get(deriveCalendarObjectId(calendarId, resourceName)) ??
+            null,
+        findByUid: async (calendarId, icalUid) => [...this.objects.values()].find((object) => object.calendarId === calendarId && object.icalUid === icalUid) ?? null,
+        listByUidPrefix: async (calendarId, prefix) => [...this.objects.values()].filter((object) => object.calendarId === calendarId && object.icalUid.startsWith(prefix)),
+        listByCalendar: async (calendarId) => [...this.objects.values()].filter((object) => object.calendarId === calendarId),
+        listChangedSince: async (calendarId, syncSequence) => [...this.objects.values()]
+            .filter((object) => object.calendarId === calendarId &&
+            object.syncSequence > syncSequence)
+            .sort((left, right) => left.syncSequence - right.syncSequence),
+    };
+    eventIndexRepo = {
+        replaceForObject: async (calendarId, calendarObjectId, occurrences) => {
+            const now = Date.now();
+            this.occurrences.set(calendarObjectId, occurrences.map((occurrence) => ({
+                ...occurrence,
+                calendarId,
+                calendarObjectId,
+                createdAt: now,
+                updatedAt: now,
+            })));
+        },
+        deleteForObject: async (_calendarId, calendarObjectId) => {
+            this.occurrences.delete(calendarObjectId);
+        },
+        listForObject: async (_calendarId, calendarObjectId) => this.occurrences.get(calendarObjectId) ?? [],
+        listByStartRange: async (calendarId, startAt, endAt) => [...this.occurrences.values()]
+            .flat()
+            .filter((row) => row.calendarId === calendarId &&
+            row.startAt >= startAt &&
+            row.startAt < endAt)
+            .sort((left, right) => left.startAt.localeCompare(right.startAt)),
+    };
+    suggestionRepo = {
+        put: async (input) => {
+            const suggestionId = deriveCalendarSuggestionId(input.messageId, input.bodyPartId, input.icalUid);
+            const now = Date.now();
+            const existing = this.suggestions.get(suggestionId);
+            const suggestion = {
+                ...input,
+                suggestionId,
+                state: existing?.state ?? CalendarSuggestionState.Pending,
+                acceptedCalendarObjectId: existing?.acceptedCalendarObjectId ?? "",
+                supersededByMessageId: existing?.supersededByMessageId ?? "",
+                createdAt: existing?.createdAt ?? now,
+                updatedAt: now,
+            };
+            this.suggestions.set(suggestionId, suggestion);
+            return suggestion;
+        },
+        get: async (accountConfigId, suggestionId) => {
+            const suggestion = this.suggestions.get(suggestionId);
+            if (!suggestion || suggestion.accountConfigId !== accountConfigId) {
+                throw new MissingRow(suggestionId);
+            }
+            return suggestion;
+        },
+        listByAcceptedCalendarObjects: async (accountConfigId, calendarObjectIds) => [...this.suggestions.values()].filter((suggestion) => suggestion.accountConfigId === accountConfigId &&
+            calendarObjectIds.includes(suggestion.acceptedCalendarObjectId)),
+        listByMessage: async (accountConfigId, messageId) => [...this.suggestions.values()].filter((suggestion) => suggestion.accountConfigId === accountConfigId &&
+            suggestion.messageId === messageId),
+        listByState: async (accountConfigId, state, options) => ({
+            items: [...this.suggestions.values()].filter((suggestion) => suggestion.accountConfigId === accountConfigId &&
+                suggestion.state === state &&
+                suggestion.endsAtUtc >= options.endsAfter),
+            continuationToken: undefined,
+        }),
+        settle: async (accountConfigId, suggestionId, input) => {
+            const suggestion = this.suggestions.get(suggestionId);
+            if (!suggestion || suggestion.accountConfigId !== accountConfigId) {
+                throw new MissingRow(suggestionId);
+            }
+            const settled = { ...suggestion, ...input, updatedAt: Date.now() };
+            this.suggestions.set(suggestionId, settled);
+            return settled;
+        },
+        supersedeIfPending: async (accountConfigId, suggestionId, supersededByMessageId) => {
+            const suggestion = this.suggestions.get(suggestionId);
+            if (!suggestion ||
+                suggestion.accountConfigId !== accountConfigId ||
+                suggestion.state !== CalendarSuggestionState.Pending) {
+                return null;
+            }
+            const retired = {
+                ...suggestion,
+                state: CalendarSuggestionState.Superseded,
+                acceptedCalendarObjectId: "",
+                supersededByMessageId,
+                updatedAt: Date.now(),
+            };
+            this.suggestions.set(suggestionId, retired);
+            return retired;
+        },
+        repointSuperseded: async (accountConfigId, suggestionId, supersededByMessageId) => {
+            const suggestion = this.suggestions.get(suggestionId);
+            if (!suggestion ||
+                suggestion.accountConfigId !== accountConfigId ||
+                suggestion.state !== CalendarSuggestionState.Superseded) {
+                return null;
+            }
+            const repointed = {
+                ...suggestion,
+                supersededByMessageId,
+                updatedAt: Date.now(),
+            };
+            this.suggestions.set(suggestionId, repointed);
+            return repointed;
+        },
+    };
+    feedTokenRepo = {
+        put: async (input) => {
+            const feedTokenId = deriveCalendarFeedTokenId(input.calendarId);
+            const now = Date.now();
+            const existing = this.feedTokens.get(feedTokenId);
+            const token = {
+                feedTokenId,
+                accountConfigId: input.accountConfigId,
+                calendarId: input.calendarId,
+                tokenHash: input.tokenHash,
+                createdAt: existing?.createdAt ?? now,
+                rotatedAt: existing ? now : 0,
+                updatedAt: now,
+            };
+            this.feedTokens.set(feedTokenId, token);
+            return token;
+        },
+        findByCalendar: async (accountConfigId, calendarId) => {
+            const token = this.feedTokens.get(deriveCalendarFeedTokenId(calendarId));
+            if (!token || token.accountConfigId !== accountConfigId)
+                return null;
+            return token;
+        },
+        findByTokenHash: async (tokenHash) => [...this.feedTokens.values()].find((token) => token.tokenHash === tokenHash) ?? null,
+        delete: async (accountConfigId, calendarId) => {
+            const feedTokenId = deriveCalendarFeedTokenId(calendarId);
+            const token = this.feedTokens.get(feedTokenId);
+            if (!token || token.accountConfigId !== accountConfigId)
+                return;
+            this.feedTokens.delete(feedTokenId);
+        },
+    };
+    get calendarSuggestion() {
+        return this.suggestionRepo;
+    }
+    get repos() {
+        return {
+            calendarCollection: this.collectionRepo,
+            calendarObject: this.objectRepo,
+            calendarEventIndex: this.eventIndexRepo,
+            calendarSuggestion: this.suggestionRepo,
+            calendarFeedToken: this.feedTokenRepo,
+        };
+    }
+    async commit(writes) {
+        for (const write of writes)
+            await this.apply(write);
+    }
+    async apply(write) {
+        switch (write.kind) {
+            case "PutObject": {
+                const { calendarId } = write.object;
+                const syncSequence = await this.collectionRepo.bumpSyncSequence(write.accountConfigId, calendarId);
+                const object = await this.objectRepo.put({
+                    ...write.object,
+                    syncSequence,
+                });
+                await this.eventIndexRepo.replaceForObject(calendarId, object.calendarObjectId, write.occurrences);
+                return;
+            }
+            case "ReprojectObject": {
+                const { calendarId, resourceName } = write.object;
+                const stored = await this.objectRepo.findByResourceName(calendarId, resourceName);
+                if (stored === null || stored.etag !== write.readEtag)
+                    return;
+                await this.apply({
+                    kind: "PutObject",
+                    accountConfigId: write.accountConfigId,
+                    object: write.object,
+                    occurrences: write.occurrences,
+                });
+                return;
+            }
+            case "DeleteObject":
+                await this.eventIndexRepo.deleteForObject(write.calendarId, write.calendarObjectId);
+                await this.objectRepo.delete(write.calendarId, write.calendarObjectId);
+                await this.collectionRepo.bumpSyncSequence(write.accountConfigId, write.calendarId);
+                return;
+            case "SettleSuggestion":
+                await this.suggestionRepo.settle(write.accountConfigId, write.suggestionId, write.settle);
+                return;
+            case "UpdateCollection":
+                await this.collectionRepo.update(write.accountConfigId, write.calendarId, write.patch);
+                return;
+            case "DeleteCollection": {
+                for (const object of await this.objectRepo.listByCalendar(write.calendarId)) {
+                    await this.eventIndexRepo.deleteForObject(write.calendarId, object.calendarObjectId);
+                    await this.objectRepo.delete(write.calendarId, object.calendarObjectId);
+                }
+                await this.feedTokenRepo.delete(write.accountConfigId, write.calendarId);
+                await this.collectionRepo.delete(write.accountConfigId, write.calendarId);
+                return;
+            }
+        }
+    }
+}

package/dist/parse.d.ts

@@ -0,0 +1,39 @@
+import ICAL from "ical.js";
+import { type CalendarResult } from "./errors.js";
+export interface ParsedCalendar {
+    /** The VCALENDAR, with every property and component the input carried. */
+    component: ICAL.Component;
+    /** The VEVENT without a RECURRENCE-ID. */
+    master: ICAL.Component;
+    /** The VEVENTs carrying a RECURRENCE-ID, in document order. */
+    overrides: ICAL.Component[];
+    uid: string;
+}
+/**
+ * Serializes a VCALENDAR back to iCalendar text.
+ *
+ * Lossless by construction: ical.js keeps every property it parsed, including
+ * ones it has no design rule for, so an X- property or a whole unknown
+ * component survives the round trip. The output is always CRLF (RFC 5545 3.1),
+ * whatever the input used.
+ *
+ * The write path does not call this. A resource is stored as the bytes it
+ * arrived in — LF-only ones included — because the etag is a digest of exactly
+ * what the writer sent; running a stored resource through here would rewrite
+ * its line endings, refold its long lines, and move the tag of a resource
+ * nobody edited. This is for building a VCALENDAR, not for keeping one.
+ */
+export declare const serializeCalendar: (component: ICAL.Component) => string;
+/**
+ * ical.js's parser in a promise, so unreadable bytes arrive as a rejection to
+ * branch on rather than a synchronous throw.
+ */
+export declare const readCalendarComponent: (icalData: string) => Promise<CalendarResult<ICAL.Component>>;
+/**
+ * Reads and validates a VCALENDAR carrying exactly one event.
+ *
+ * Every refusal is a returned value. The input is client-supplied bytes, so a
+ * malformed resource is an ordinary outcome of this function rather than a
+ * fault.
+ */
+export declare const parseCalendar: (icalData: string) => Promise<CalendarResult<ParsedCalendar>>;

package/dist/parse.js

@@ -0,0 +1,87 @@
+import ICAL from "ical.js";
+import { calendarFailure } from "./errors.js";
+/** Components a VEVENT-only collection accepts at the top level of a resource. */
+const ACCEPTED_COMPONENTS = new Set(["vevent", "vtimezone"]);
+/**
+ * Serializes a VCALENDAR back to iCalendar text.
+ *
+ * Lossless by construction: ical.js keeps every property it parsed, including
+ * ones it has no design rule for, so an X- property or a whole unknown
+ * component survives the round trip. The output is always CRLF (RFC 5545 3.1),
+ * whatever the input used.
+ *
+ * The write path does not call this. A resource is stored as the bytes it
+ * arrived in — LF-only ones included — because the etag is a digest of exactly
+ * what the writer sent; running a stored resource through here would rewrite
+ * its line endings, refold its long lines, and move the tag of a resource
+ * nobody edited. This is for building a VCALENDAR, not for keeping one.
+ */
+export const serializeCalendar = (component) => component.toString();
+/**
+ * ical.js's parser in a promise, so unreadable bytes arrive as a rejection to
+ * branch on rather than a synchronous throw.
+ */
+export const readCalendarComponent = (icalData) => new Promise((resolve) => {
+    resolve(new ICAL.Component(ICAL.parse(icalData)));
+}).then((component) => ({ ok: true, value: component }), (error) => calendarFailure("MalformedIcalendar", error instanceof Error ? error.message : "unreadable iCalendar data"));
+/**
+ * Reads and validates a VCALENDAR carrying exactly one event.
+ *
+ * Every refusal is a returned value. The input is client-supplied bytes, so a
+ * malformed resource is an ordinary outcome of this function rather than a
+ * fault.
+ */
+export const parseCalendar = async (icalData) => {
+    const read = await readCalendarComponent(icalData);
+    if (!read.ok)
+        return read;
+    const component = read.value;
+    if (component.name !== "vcalendar") {
+        // A document with nothing in it names nothing: ical.js reads empty bytes
+        // as a component with no name at all, and a suggestion read out of prose
+        // carries exactly that. Naming what arrived is for a document that has a
+        // root to name.
+        return calendarFailure("NotACalendar", component.name
+            ? `expected a VCALENDAR, found ${component.name.toUpperCase()}`
+            : "expected a VCALENDAR, found nothing");
+    }
+    const unsupported = component
+        .getAllSubcomponents()
+        .map((child) => child.name)
+        .find((name) => !ACCEPTED_COMPONENTS.has(name));
+    if (unsupported) {
+        return calendarFailure("UnsupportedComponent", `this calendar stores VEVENT only, and the resource carries a ${unsupported.toUpperCase()}`);
+    }
+    const events = component.getAllSubcomponents("vevent");
+    if (events.length === 0) {
+        return calendarFailure("NoEvent", "the resource carries no VEVENT");
+    }
+    const masters = events.filter((event) => !event.hasProperty("recurrence-id"));
+    if (masters.length === 0) {
+        return calendarFailure("NoMasterEvent", "every VEVENT carries a RECURRENCE-ID, so there is no event for them to override");
+    }
+    if (masters.length > 1) {
+        return calendarFailure("MultipleMasterEvents", `one resource holds one event, and this one holds ${masters.length}`);
+    }
+    const master = masters[0];
+    const uid = master.getFirstPropertyValue("uid");
+    if (typeof uid !== "string" || uid === "") {
+        return calendarFailure("MissingUid", "the VEVENT declares no UID");
+    }
+    const mismatched = events.find((event) => event.getFirstPropertyValue("uid") !== uid);
+    if (mismatched) {
+        return calendarFailure("MismatchedUid", "the VEVENTs in this resource declare different UIDs");
+    }
+    if (!master.hasProperty("dtstart")) {
+        return calendarFailure("MissingDtStart", "the VEVENT declares no DTSTART");
+    }
+    return {
+        ok: true,
+        value: {
+            component,
+            master,
+            overrides: events.filter((event) => event.hasProperty("recurrence-id")),
+            uid,
+        },
+    };
+};

package/dist/project.d.ts

@@ -0,0 +1,30 @@
+import type { CalendarObjectItem } from "@remit/data-ports";
+import ICAL from "ical.js";
+import { type CalendarResult } from "./errors.js";
+import type { ParsedCalendar } from "./parse.js";
+/**
+ * The columns `CalendarObject` carries beside its bytes. Every one of them is
+ * read out of the VEVENT here and nowhere else, so the row can only ever
+ * describe the `icalData` it was written with.
+ */
+export type CalendarObjectProjection = Pick<CalendarObjectItem, "icalUid" | "summary" | "dtStart" | "dtEnd" | "allDay" | "zoneCertainty" | "status" | "transparency" | "hasRecurrence" | "sequence">;
+export declare const readString: (component: ICAL.Component, name: string) => string;
+/**
+ * The fields that describe one VEVENT rather than the series it belongs to.
+ *
+ * Read per occurrence as well as per resource: an override VEVENT carries its
+ * own summary, status and transparency, and a range read that took them from
+ * the master would draw the old title over an edited instance and count a
+ * cancelled one as busy time.
+ */
+export type CalendarEventDisplay = Pick<CalendarObjectItem, "summary" | "status" | "transparency">;
+export declare const projectEventDisplay: (component: ICAL.Component) => CalendarEventDisplay;
+/**
+ * Whether the resource expands to more than its master instance — an RRULE, an
+ * RDATE, or an override VEVENT. The overrides count: a client that edits one
+ * instance of a series and then deletes the rule leaves a resource with nothing
+ * but a master and its exceptions, and every one of those is still an
+ * occurrence somebody has to see.
+ */
+export declare const hasRecurrence: (calendar: ParsedCalendar) => boolean;
+export declare const projectCalendar: (calendar: ParsedCalendar, collectionTimezone: string) => CalendarResult<CalendarObjectProjection>;

package/dist/project.js

@@ -0,0 +1,57 @@
+import { CalendarEventStatus, CalendarTransparency } from "@remit/domain-enums";
+import ICAL from "ical.js";
+import { calendarFailure } from "./errors.js";
+import { resolveTime, tzidOf } from "./time.js";
+const STATUS_BY_ICAL = {
+    CONFIRMED: CalendarEventStatus.Confirmed,
+    TENTATIVE: CalendarEventStatus.Tentative,
+    CANCELLED: CalendarEventStatus.Cancelled,
+};
+const TRANSPARENCY_BY_ICAL = {
+    OPAQUE: CalendarTransparency.Opaque,
+    TRANSPARENT: CalendarTransparency.Transparent,
+};
+export const readString = (component, name) => {
+    const value = component.getFirstPropertyValue(name);
+    return typeof value === "string" ? value : "";
+};
+export const projectEventDisplay = (component) => ({
+    summary: readString(component, "summary"),
+    status: STATUS_BY_ICAL[readString(component, "status").toUpperCase()] ??
+        CalendarEventStatus.Confirmed,
+    transparency: TRANSPARENCY_BY_ICAL[readString(component, "transp").toUpperCase()] ??
+        CalendarTransparency.Opaque,
+});
+/**
+ * Whether the resource expands to more than its master instance — an RRULE, an
+ * RDATE, or an override VEVENT. The overrides count: a client that edits one
+ * instance of a series and then deletes the rule leaves a resource with nothing
+ * but a master and its exceptions, and every one of those is still an
+ * occurrence somebody has to see.
+ */
+export const hasRecurrence = (calendar) => calendar.master.hasProperty("rrule") ||
+    calendar.master.hasProperty("rdate") ||
+    calendar.overrides.length > 0;
+export const projectCalendar = (calendar, collectionTimezone) => {
+    const event = new ICAL.Event(calendar.master);
+    const start = resolveTime(event.startDate, tzidOf(calendar.master.getFirstProperty("dtstart")), collectionTimezone);
+    const end = resolveTime(event.endDate, tzidOf(calendar.master.getFirstProperty("dtend") ??
+        calendar.master.getFirstProperty("dtstart")), collectionTimezone);
+    if (end.instantMs < start.instantMs) {
+        return calendarFailure("BackwardsEnd", `the event ends at ${end.isoUtc}, before it starts at ${start.isoUtc}`);
+    }
+    const sequence = calendar.master.getFirstPropertyValue("sequence");
+    return {
+        ok: true,
+        value: {
+            icalUid: calendar.uid,
+            dtStart: start.isoOffset,
+            dtEnd: end.isoOffset,
+            allDay: start.isDate,
+            zoneCertainty: start.certainty,
+            ...projectEventDisplay(calendar.master),
+            hasRecurrence: hasRecurrence(calendar),
+            sequence: typeof sequence === "number" ? sequence : 0,
+        },
+    };
+};