@bobfrankston/rmfmail 1.2.272 → 1.2.276

package/packages/mailx-types/index.ts

@@ -848,3 +848,195 @@ export function formatSender(addr: { name?: string; address: string } | null | u
     if (name.toLowerCase() === address.toLowerCase()) return { text: address, claimed: null };
     return { text: `${name} <${address}>`, claimed: displayNameClaimsOtherAddress(name, address) };
 }
+
+
+// ── Calendar invites (text/calendar) ──────────────────────────────────────
+
+export interface InviteAttendee {
+    name: string;
+    email: string;
+    /** NEEDS-ACTION | ACCEPTED | DECLINED | TENTATIVE | DELEGATED */
+    status: string;
+    rsvp: boolean;
+}
+
+export interface ParsedInvite {
+    /** REQUEST (an invitation), REPLY (someone's RSVP), CANCEL, PUBLISH… */
+    method: string;
+    uid: string;
+    sequence: number;
+    summary: string;
+    description: string;
+    location: string;
+    /** ISO 8601. All-day events carry a bare date (no time part). */
+    start: string;
+    end: string;
+    /** IANA zone from TZID, when the invite specified one. */
+    tzid: string;
+    allDay: boolean;
+    organizer: { name: string; email: string };
+    attendees: InviteAttendee[];
+    /** Raw RRULE, if the event repeats. Rendered verbatim — turning it into
+     *  prose is a separate job and getting it subtly wrong is worse than
+     *  showing the rule. */
+    rrule: string;
+    status: string;
+    /** True when the invite was produced by Google Calendar. Google's own
+     *  HTML body carries working Yes/No/Maybe links, so the UI must NOT add a
+     *  second set of RSVP controls for these — see inviteHasGoogleRsvp. */
+    fromGoogle: boolean;
+}
+
+/** Unfold RFC 5545 continuation lines: a line beginning with a space or tab
+ *  continues the previous one. Google folds ATTENDEE lines mid-parameter, so
+ *  skipping this loses attendees entirely. */
+function unfoldIcs(text: string): string[] {
+    const raw = (text || "").replace(/\r\n/g, "\n").split("\n");
+    const out: string[] = [];
+    for (const line of raw) {
+        if (/^[ \t]/.test(line) && out.length) out[out.length - 1] += line.slice(1);
+        else out.push(line);
+    }
+    return out;
+}
+
+/** RFC 5545 TEXT unescaping: \\n is a newline, and \\, \\; \\, are literals. */
+function unescapeIcs(v: string): string {
+    return (v || "")
+        .replace(/\\n/gi, "\n")
+        .replace(/\\([;,\\])/g, "$1");
+}
+
+/** Split "KEY;PARAM=x;PARAM2=y:value" into its three pieces. */
+function splitIcsLine(line: string): { key: string; params: Record<string, string>; value: string } | null {
+    // The first colon that is not inside a quoted parameter ends the name part.
+    let inQuote = false, colon = -1;
+    for (let i = 0; i < line.length; i++) {
+        const c = line[i];
+        if (c === '"') inQuote = !inQuote;
+        else if (c === ":" && !inQuote) { colon = i; break; }
+    }
+    if (colon < 0) return null;
+    const namePart = line.slice(0, colon);
+    const value = line.slice(colon + 1);
+    const bits = namePart.split(";");
+    const key = (bits.shift() || "").toUpperCase();
+    const params: Record<string, string> = {};
+    for (const b of bits) {
+        const eq = b.indexOf("=");
+        if (eq < 0) continue;
+        params[b.slice(0, eq).toUpperCase()] = b.slice(eq + 1).replace(/^"|"$/g, "");
+    }
+    return { key, params, value };
+}
+
+/** ICS timestamp → ISO 8601. Handles 20260823T080000 (local/zoned),
+ *  20260823T133939Z (UTC) and 20260823 (all-day). Zoned values keep their
+ *  wall-clock reading; the caller pairs them with `tzid`. */
+function icsDateToIso(v: string, isUtc: boolean): string {
+    const m = (v || "").match(/^(\d{4})(\d{2})(\d{2})(?:T(\d{2})(\d{2})(\d{2})(Z)?)?$/);
+    if (!m) return "";
+    const [, y, mo, d, hh, mm, ss, z] = m;
+    if (!hh) return `${y}-${mo}-${d}`;
+    const base = `${y}-${mo}-${d}T${hh}:${mm}:${ss}`;
+    return (z || isUtc) ? base + "Z" : base;
+}
+
+function parseCalAddress(value: string, params: Record<string, string>): { name: string; email: string } {
+    const email = (value || "").replace(/^mailto:/i, "").trim();
+    return { name: (params.CN || "").trim() || email, email };
+}
+
+/**
+ * Parse the VEVENT out of a text/calendar part.
+ *
+ * Deliberately hand-rolled rather than pulling in an ICS library: mailx-types
+ * is the zero-dependency package shared with Android, and an invite card needs
+ * a dozen properties, not full RFC 5545 coverage. Returns null when there is
+ * no VEVENT to show.
+ */
+export function parseInvite(ics: string): ParsedInvite | null {
+    if (!ics || !/BEGIN:VEVENT/i.test(ics)) return null;
+    const lines = unfoldIcs(ics);
+
+    const out: ParsedInvite = {
+        method: "", uid: "", sequence: 0, summary: "", description: "", location: "",
+        start: "", end: "", tzid: "", allDay: false,
+        organizer: { name: "", email: "" }, attendees: [], rrule: "", status: "",
+        fromGoogle: false,
+    };
+
+    let inEvent = false;
+    // VTIMEZONE blocks contain their own DTSTART/RRULE — those describe the
+    // zone's DST rules, not the meeting. Ignore everything inside them.
+    let depthNonEvent = 0;
+
+    for (const line of lines) {
+        const up = line.toUpperCase();
+        if (up.startsWith("BEGIN:VEVENT")) { inEvent = true; continue; }
+        if (up.startsWith("END:VEVENT")) { inEvent = false; continue; }
+        if (!inEvent && (up.startsWith("BEGIN:VTIMEZONE") || up.startsWith("BEGIN:VALARM"))) { depthNonEvent++; continue; }
+        if (up.startsWith("END:VTIMEZONE") || up.startsWith("END:VALARM")) { if (depthNonEvent) depthNonEvent--; continue; }
+        if (inEvent && up.startsWith("BEGIN:VALARM")) { depthNonEvent++; continue; }
+
+        const p = splitIcsLine(line);
+        if (!p) continue;
+
+        if (!inEvent) {
+            if (p.key === "METHOD") out.method = p.value.trim().toUpperCase();
+            else if (p.key === "PRODID" && /google/i.test(p.value)) out.fromGoogle = true;
+            continue;
+        }
+        if (depthNonEvent) continue;   // inside VALARM
+
+        switch (p.key) {
+            case "SUMMARY":     out.summary = unescapeIcs(p.value); break;
+            case "DESCRIPTION": out.description = unescapeIcs(p.value); break;
+            case "LOCATION":    out.location = unescapeIcs(p.value); break;
+            case "UID":         out.uid = p.value.trim(); break;
+            case "STATUS":      out.status = p.value.trim().toUpperCase(); break;
+            case "RRULE":       out.rrule = p.value.trim(); break;
+            case "SEQUENCE":    out.sequence = parseInt(p.value, 10) || 0; break;
+            case "DTSTART":
+                out.start = icsDateToIso(p.value.trim(), false);
+                out.tzid = p.params.TZID || out.tzid;
+                out.allDay = (p.params.VALUE || "").toUpperCase() === "DATE" || !/T/.test(p.value);
+                break;
+            case "DTEND":
+                out.end = icsDateToIso(p.value.trim(), false);
+                out.tzid = out.tzid || p.params.TZID || "";
+                break;
+            case "ORGANIZER":
+                out.organizer = parseCalAddress(p.value, p.params);
+                break;
+            case "ATTENDEE": {
+                const a = parseCalAddress(p.value, p.params);
+                out.attendees.push({
+                    name: a.name,
+                    email: a.email,
+                    status: (p.params.PARTSTAT || "NEEDS-ACTION").toUpperCase(),
+                    rsvp: (p.params.RSVP || "").toUpperCase() === "TRUE",
+                });
+                break;
+            }
+        }
+    }
+
+    if (!out.summary && !out.start) return null;
+    return out;
+}
+
+/**
+ * Does the message body already carry Google's own Yes/No/Maybe controls?
+ *
+ * Google Calendar invitations embed working RSVP links
+ * (`calendar.google.com/calendar/event?action=RESPOND&rst=1|2|3`). When they
+ * are present the UI must show the invite summary but NOT a second set of RSVP
+ * buttons — two responders racing to set PARTSTAT is worse than one
+ * (Bob 2026-08-22: "Google's own responder handles it so you might detect that
+ * case specially").
+ */
+export function inviteHasGoogleRsvp(bodyHtml: string): boolean {
+    if (!bodyHtml) return false;
+    return /calendar\.google\.com\/calendar\/event\?action=RESPOND/i.test(bodyHtml);
+}

package/packages/mailx-types/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx-types",
-  "version": "0.1.57",
+  "version": "0.1.59",
   "type": "module",
   "main": "index.js",
   "types": "index.d.ts",