@craftguild/jscalendar 0.1.0

package/dist/__tests__/search.test.js

@@ -0,0 +1,237 @@
+import { describe, expect, it } from "vitest";
+import { filterByDateRange, filterByText, findByUid, groupByType, } from "../search.js";
+import { JsCal } from "../jscal.js";
+const event = {
+    "@type": "Event",
+    uid: "e1",
+    updated: "2026-02-01T00:00:00Z",
+    title: "Sprint planning",
+    description: "Discuss backlog",
+    start: "2026-02-01T10:00:00",
+    duration: "PT1H",
+};
+const task = {
+    "@type": "Task",
+    uid: "t1",
+    updated: "2026-02-01T00:00:00Z",
+    title: "Write notes",
+    start: "2026-02-02T09:00:00",
+};
+describe("search helpers", () => {
+    it("finds by uid", () => {
+        expect(findByUid([event, task], "t1")?.uid).toBe("t1");
+    });
+    it("groups by type", () => {
+        const grouped = groupByType([event, task]);
+        const events = grouped.Event ?? [];
+        const tasks = grouped.Task ?? [];
+        expect(events.length).toBe(1);
+        expect(tasks.length).toBe(1);
+    });
+    it("filters by text", () => {
+        const results = filterByText([event, task], "backlog");
+        expect(results.length).toBe(1);
+        const first = results[0];
+        expect(first).toBeDefined();
+        if (!first)
+            throw new Error("Missing result");
+        expect(first.uid).toBe("e1");
+    });
+    it("returns all items for empty text query", () => {
+        const results = filterByText([event, task], "   ");
+        expect(results.length).toBe(2);
+    });
+    it("indexes locations, virtual locations, and participants for text search", () => {
+        const item = new JsCal.Event({
+            start: "2026-02-01T10:00:00",
+            title: "Meeting",
+            locations: {
+                l1: { "@type": "Location", name: "Room A", description: "Main room" },
+            },
+            virtualLocations: {
+                v1: { "@type": "VirtualLocation", name: "Zoom", uri: "https://example.com" },
+            },
+            participants: {
+                p1: { "@type": "Participant", roles: { attendee: true }, name: "Alice", email: "a@example.com" },
+            },
+        }).eject();
+        const results = filterByText([item], "example.com");
+        expect(results.length).toBe(1);
+    });
+    it("accepts JsCal instances via JsCal.filterByText", () => {
+        const instance = new JsCal.Event({ start: "2026-02-01T10:00:00", title: "Planning" });
+        const results = JsCal.filterByText([instance], "planning");
+        expect(results.length).toBe(1);
+        expect(results[0]?.uid).toBe(instance.data.uid);
+    });
+    it("uses JsCal.findByUid and JsCal.filterByType wrappers", () => {
+        const items = [event, task];
+        const found = JsCal.findByUid(items, "t1");
+        expect(found?.uid).toBe("t1");
+        const events = JsCal.filterByType(items, "Event");
+        expect(events.length).toBe(1);
+        expect(events[0]?.uid).toBe("e1");
+    });
+    it("filters by date range", () => {
+        const results = filterByDateRange([event, task], {
+            start: "2026-02-01T09:30:00",
+            end: "2026-02-01T10:30:00",
+        });
+        expect(results.length).toBe(1);
+        const first = results[0];
+        expect(first).toBeDefined();
+        if (!first)
+            throw new Error("Missing result");
+        expect(first.uid).toBe("e1");
+    });
+    it("uses JsCal.groupByType wrapper", () => {
+        const grouped = JsCal.groupByType([event, task]);
+        expect(Object.keys(grouped)).toContain("Event");
+        expect(Object.keys(grouped)).toContain("Task");
+    });
+    it("includes incomparable when requested", () => {
+        const noDateTask = new JsCal.Task({ uid: "t2", title: "No date" });
+        const results = JsCal.filterByDateRange([noDateTask, event], { start: "2026-02-01T00:00:00" }, { includeIncomparable: true });
+        expect(results.map((item) => item.uid).sort()).toEqual(["e1", "t2"]);
+    });
+    it("computes group range from entries", () => {
+        const group = new JsCal.Group({
+            uid: "g1",
+            entries: [
+                new JsCal.Event({ uid: "e2", start: "2026-02-01T10:00:00" }).eject(),
+                new JsCal.Event({ uid: "e3", start: "2026-02-03T10:00:00" }).eject(),
+            ],
+        });
+        const results = JsCal.filterByDateRange([group], { start: "2026-02-02T00:00:00" });
+        expect(results.map((item) => item.uid)).toEqual(["g1"]);
+    });
+    it("excludes groups with no dated entries", () => {
+        const group = new JsCal.Group({
+            uid: "g2",
+            entries: [],
+        });
+        const results = JsCal.filterByDateRange([group], { start: "2026-02-01T00:00:00" });
+        expect(results.length).toBe(0);
+    });
+    it("handles duration ranges with time zones", () => {
+        const tzEvent = new JsCal.Event({
+            uid: "e4",
+            start: "2026-02-01T10:00:00",
+            timeZone: "Asia/Tokyo",
+            duration: "PT1H",
+        });
+        const results = JsCal.filterByDateRange([tzEvent], { start: new Date("2026-02-01T01:30:00Z") });
+        expect(results.map((item) => item.uid)).toEqual(["e4"]);
+    });
+    it("converts Date range into event time zone", () => {
+        const eventWithTz = new JsCal.Event({
+            uid: "e7",
+            start: "2026-02-01T10:00:00",
+            timeZone: "Asia/Tokyo",
+        });
+        const results = JsCal.filterByDateRange([eventWithTz], { start: new Date("2026-02-01T01:00:00Z"), end: new Date("2026-02-01T01:00:00Z") });
+        expect(results.map((item) => item.uid)).toEqual(["e7"]);
+    });
+    it("excludes local floating events when Date range is used", () => {
+        const floating = new JsCal.Event({
+            uid: "e8",
+            start: "2026-02-01T10:00:00",
+        });
+        const results = JsCal.filterByDateRange([floating], { start: new Date("2026-02-01T01:00:00Z") });
+        expect(results.length).toBe(0);
+    });
+    it("handles Date range with task time zone", () => {
+        const taskWithTz = new JsCal.Task({
+            uid: "t3",
+            start: "2026-02-01T10:00:00",
+            timeZone: "Asia/Tokyo",
+        });
+        const results = JsCal.filterByDateRange([taskWithTz], { start: new Date("2026-02-01T01:00:00Z"), end: new Date("2026-02-01T01:00:00Z") });
+        expect(results.map((item) => item.uid)).toEqual(["t3"]);
+    });
+    it("handles Date range for groups using entry time zones", () => {
+        const group = new JsCal.Group({
+            uid: "g3",
+            entries: [
+                new JsCal.Event({ uid: "e9", start: "2026-02-01T10:00:00", timeZone: "Asia/Tokyo" }).eject(),
+            ],
+        });
+        const results = JsCal.filterByDateRange([group], { start: new Date("2026-02-01T01:00:00Z"), end: new Date("2026-02-01T01:00:00Z") });
+        expect(results.map((item) => item.uid)).toEqual(["g3"]);
+    });
+    it("handles Date range for time zone events and tasks", () => {
+        const utcEvent = new JsCal.Event({
+            uid: "e10",
+            start: "2026-02-01T10:00:00",
+            timeZone: "Asia/Tokyo",
+            duration: "PT1H",
+        });
+        const utcTask = new JsCal.Task({
+            uid: "t5",
+            start: "2026-02-01T10:00:00",
+            timeZone: "Asia/Tokyo",
+        });
+        const results = filterByDateRange([utcEvent.eject(), utcTask.eject()], { start: new Date("2026-02-01T01:00:00Z"), end: new Date("2026-02-01T01:00:00Z") });
+        expect(results.map((item) => item.uid).sort()).toEqual(["e10", "t5"]);
+    });
+    it("handles local duration without UTC end calculation", () => {
+        const localEvent = new JsCal.Event({
+            uid: "e5",
+            start: "2026-02-01T10:00:00",
+            duration: "PT1H",
+        });
+        const results = JsCal.filterByDateRange([localEvent], { end: "2026-02-01T09:00:00" });
+        expect(results.length).toBe(0);
+    });
+    it("excludes items outside range bounds", () => {
+        const utcEvent = new JsCal.Event({
+            uid: "e6",
+            start: "2026-02-01T10:00:00",
+            duration: "PT1H",
+        });
+        const afterRange = filterByDateRange([utcEvent.eject()], { start: "2026-02-01T12:30:00" });
+        expect(afterRange.length).toBe(0);
+        const beforeRange = filterByDateRange([utcEvent.eject()], { end: "2026-02-01T09:30:00" });
+        expect(beforeRange.length).toBe(0);
+    });
+    it("treats unknown types as incomparable", () => {
+        const unknownObject = {
+            "@type": "Unknown",
+            uid: "u1",
+            updated: "2026-02-01T00:00:00Z",
+        };
+        // @ts-expect-error unknown object type
+        const results = filterByDateRange([unknownObject], { start: "2026-02-01T00:00:00Z" }, { includeIncomparable: true });
+        expect(results.length).toBe(1);
+    });
+    it("handles Date range for unknown types", () => {
+        const unknownObject = {
+            "@type": "Unknown",
+            uid: "u2",
+            updated: "2026-02-01T00:00:00Z",
+        };
+        // @ts-expect-error unknown object type
+        const included = filterByDateRange([unknownObject], { start: new Date("2026-02-01T00:00:00Z") }, { includeIncomparable: true });
+        expect(included.length).toBe(1);
+        // @ts-expect-error unknown object type
+        const excluded = filterByDateRange([unknownObject], { start: new Date("2026-02-01T00:00:00Z") });
+        expect(excluded.length).toBe(0);
+    });
+    it("handles Date range for local tasks as incomparable", () => {
+        const localTask = new JsCal.Task({
+            uid: "t4",
+            start: "2026-02-01T10:00:00",
+        });
+        const included = JsCal.filterByDateRange([localTask], { start: new Date("2026-02-01T00:00:00Z") }, { includeIncomparable: true });
+        expect(included.length).toBe(1);
+        const excluded = JsCal.filterByDateRange([localTask], { start: new Date("2026-02-01T00:00:00Z") });
+        expect(excluded.length).toBe(0);
+    });
+    it("handles incomparable date-times", () => {
+        const results = filterByDateRange([event, task], {
+            start: "2026-02-01T09:30:00",
+            end: "2026-02-01T10:30:00",
+        }, { includeIncomparable: true });
+        expect(results.length).toBe(1);
+    });
+});

package/dist/__tests__/timezones.test.d.ts

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

package/dist/__tests__/timezones.test.js

@@ -0,0 +1,12 @@
+import { describe, expect, it } from "vitest";
+import { JsCal } from "../jscal.js";
+import { resolveTimeZone } from "../timezones.js";
+describe("time zones", () => {
+    it("resolves lowercase inputs", () => {
+        expect(resolveTimeZone("asia/tokyo")).toBe("Asia/Tokyo");
+    });
+    it("throws on unknown time zones", () => {
+        // @ts-expect-error invalid time zone input
+        expect(() => JsCal.timeZone("Invalid/Zone")).toThrow();
+    });
+});

package/dist/__tests__/utils.test.d.ts

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

package/dist/__tests__/utils.test.js

@@ -0,0 +1,116 @@
+import { describe, expect, it } from "vitest";
+import { compareDateTime, dateTimeInTimeZone, deepClone, durationToMilliseconds, isUtcDateTime, localDateTimeFromDate, localDateTimeToUtcDate, normalizeUtcDateTime, } from "../utils.js";
+import { JsCal } from "../jscal.js";
+describe("utils", () => {
+    it("detects UTC date-time", () => {
+        expect(isUtcDateTime("2026-02-01T00:00:00Z")).toBe(true);
+        expect(isUtcDateTime("2026-02-01T00:00:00")).toBe(false);
+    });
+    it("normalizes UTC date-time", () => {
+        expect(normalizeUtcDateTime("2026-02-01T00:00:00.000Z")).toBe("2026-02-01T00:00:00Z");
+    });
+    it("formats local date-time from Date", () => {
+        const value = localDateTimeFromDate(new Date("2026-02-01T10:00:00Z"));
+        expect(value).toMatch(/^2026-02-01T/);
+    });
+    it("formats date-time in time zone", () => {
+        const value = dateTimeInTimeZone(new Date("2026-02-01T10:00:00Z"), "UTC");
+        expect(value).toBe("2026-02-01T10:00:00");
+    });
+    it("rejects invalid LocalDateTime in time zone conversion", () => {
+        expect(() => localDateTimeToUtcDate("invalid", "Asia/Tokyo")).toThrow();
+    });
+    it("compares UTC date-times", () => {
+        expect(compareDateTime("2026-02-01T00:00:00Z", "2026-02-01T00:00:00Z")).toBe(0);
+        expect(compareDateTime("2026-02-01T00:00:00Z", "2026-02-01T01:00:00Z")).toBe(-1);
+        expect(compareDateTime("2026-02-01T01:00:00Z", "2026-02-01T00:00:00Z")).toBe(1);
+    });
+    it("compares local date-times lexicographically", () => {
+        expect(compareDateTime("2026-02-01T00:00:00", "2026-02-01T00:00:00")).toBe(0);
+        expect(compareDateTime("2026-02-01T00:00:00", "2026-02-02T00:00:00")).toBe(-1);
+    });
+    it("returns null when comparing mixed UTC/local", () => {
+        expect(compareDateTime("2026-02-01T00:00:00", "2026-02-01T00:00:00Z")).toBeNull();
+    });
+    it("parses durations", () => {
+        expect(durationToMilliseconds("PT1H")).toBe(60 * 60 * 1000);
+        expect(durationToMilliseconds("P1DT30M")).toBe(24 * 60 * 60 * 1000 + 30 * 60 * 1000);
+    });
+    it("rejects invalid durations", () => {
+        expect(durationToMilliseconds("invalid")).toBeNull();
+    });
+    it("builds duration strings", () => {
+        expect(JsCal.duration.seconds(90)).toBe("PT1M30S");
+        expect(JsCal.duration.minutes(90)).toBe("PT1H30M");
+        expect(JsCal.duration.hours(1)).toBe("PT1H");
+        expect(JsCal.duration.days(1)).toBe("P1D");
+        expect(JsCal.duration.from({ hours: 1, minutes: 15 })).toBe("PT1H15M");
+    });
+    it("creates base64url ids", () => {
+        const id = JsCal.createId();
+        expect(id).toMatch(/^[A-Za-z0-9_-]+$/);
+    });
+    it("falls back to random bytes when randomUUID is unavailable", () => {
+        const original = globalThis.crypto;
+        const fakeCrypto = {
+            getRandomValues(values) {
+                for (let i = 0; i < values.length; i += 1) {
+                    values[i] = i & 0xff;
+                }
+                return values;
+            },
+        };
+        Object.defineProperty(globalThis, "crypto", {
+            value: fakeCrypto,
+            configurable: true,
+        });
+        try {
+            const uid = JsCal.createUid();
+            expect(uid).toMatch(/^[0-9a-f-]+$/);
+        }
+        finally {
+            Object.defineProperty(globalThis, "crypto", {
+                value: original,
+                configurable: true,
+            });
+        }
+    });
+    it("uses Math.random fallback when crypto is missing", () => {
+        const original = globalThis.crypto;
+        Object.defineProperty(globalThis, "crypto", {
+            value: undefined,
+            configurable: true,
+        });
+        try {
+            const id = JsCal.createId();
+            expect(id).toMatch(/^[A-Za-z0-9_-]+$/);
+        }
+        finally {
+            Object.defineProperty(globalThis, "crypto", {
+                value: original,
+                configurable: true,
+            });
+        }
+    });
+    it("resolves time zones", () => {
+        const tz = JsCal.timeZone("asia/tokyo");
+        expect(tz).toBe("Asia/Tokyo");
+        expect(JsCal.timeZones.includes("Asia/Tokyo")).toBe(true);
+    });
+    it("throws when structuredClone is unavailable", () => {
+        const original = globalThis.structuredClone;
+        Object.defineProperty(globalThis, "structuredClone", {
+            value: undefined,
+            configurable: true,
+        });
+        try {
+            expect(() => deepClone({ value: 1 })).toThrow();
+        }
+        finally {
+            Object.defineProperty(globalThis, "structuredClone", {
+                value: original,
+                configurable: true,
+            });
+        }
+    });
+});

package/dist/__tests__/validation.test.d.ts

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

package/dist/__tests__/validation.test.js

@@ -0,0 +1,91 @@
+import { describe, expect, it } from "vitest";
+import { JsCal, ValidationError } from "../index.js";
+describe("validation", () => {
+    it("rejects LocalDateTime with time zone offset", () => {
+        expect(() => new JsCal.Event({ start: "2026-02-01T10:00:00Z" })).toThrowError("object.start: must not include time zone offset");
+    });
+    it("rejects UTCDateTime with trailing zero fractional seconds", () => {
+        expect(() => new JsCal.Event({
+            start: "2026-02-01T10:00:00",
+            updated: "2026-02-01T00:00:00.120Z",
+        })).toThrowError("object.updated: fractional seconds must not have trailing zeros");
+    });
+    it("rejects invalid description content type", () => {
+        expect(() => new JsCal.Event({
+            start: "2026-02-01T10:00:00",
+            descriptionContentType: "application/json",
+        })).toThrowError("object.descriptionContentType: must be a text/* media type");
+    });
+    it("allows validation to be disabled for create, update, and patch", () => {
+        const event = new JsCal.Event({ start: "2026-02-01T10:00:00Z" }, { validate: false });
+        expect(event.get("start")).toBe("2026-02-01T10:00:00Z");
+        event.update({ start: "2026-02-01T10:00:00Z" }, { validate: false });
+        event.patch({ "/start": "2026-02-01T10:00:00Z" }, { validate: false });
+    });
+    it("throws ValidationError with path and message", () => {
+        expect(() => new JsCal.Event({ start: "2026-02-01T10:00:00Z" })).toThrowError(ValidationError);
+    });
+    it("accepts nested objects with valid ids and media types", () => {
+        const event = new JsCal.Event({
+            uid: "evt_1",
+            start: "2026-02-01T10:00:00",
+            descriptionContentType: "text/plain; charset=utf-8",
+            locations: {
+                loc1: { "@type": "Location", name: "Room A" },
+            },
+            virtualLocations: {
+                v1: { "@type": "VirtualLocation", uri: "https://example.com" },
+            },
+            links: {
+                l1: { "@type": "Link", href: "https://example.com", contentType: "text/plain; charset=utf-8" },
+            },
+            participants: {
+                p1: { "@type": "Participant", roles: { attendee: true }, email: "a@example.com" },
+            },
+            alerts: {
+                a1: {
+                    "@type": "Alert",
+                    trigger: { "@type": "OffsetTrigger", offset: "-PT15M" },
+                },
+            },
+            relatedTo: {
+                rel1: { "@type": "Relation", relation: { first: true } },
+            },
+        });
+        expect(event.get("uid")).toBe("evt_1");
+    });
+    it("rejects invalid map key ids", () => {
+        expect(() => new JsCal.Event({
+            start: "2026-02-01T10:00:00",
+            locations: {
+                "bad id": { "@type": "Location", name: "Room A" },
+            },
+        })).toThrowError("object.locations.bad id: must use base64url characters");
+    });
+    it("rejects non-gregorian rscale values", () => {
+        expect(() => new JsCal.Event({
+            start: "2026-02-01T10:00:00",
+            recurrenceRules: [{ "@type": "RecurrenceRule", frequency: "daily", rscale: "hebrew" }],
+        })).toThrowError("object.recurrenceRules[0].rscale: only gregorian is supported");
+    });
+    it("accepts time zone objects", () => {
+        const event = new JsCal.Event({
+            start: "2026-02-01T10:00:00",
+            timeZones: {
+                "Asia/Tokyo": {
+                    "@type": "TimeZone",
+                    tzId: "Asia/Tokyo",
+                    standard: [
+                        {
+                            "@type": "TimeZoneRule",
+                            start: "2026-01-01T00:00:00",
+                            offsetFrom: "+09:00",
+                            offsetTo: "+09:00",
+                        },
+                    ],
+                },
+            },
+        });
+        expect(event.get("timeZones")?.["Asia/Tokyo"]?.tzId).toBe("Asia/Tokyo");
+    });
+});

package/dist/ical.d.ts

@@ -0,0 +1,7 @@
+import type { JSCalendarObject } from "./types.js";
+export type ICalOptions = {
+    prodId?: string;
+    method?: string;
+    includeXJSCalendar?: boolean;
+};
+export declare function toICal(objects: JSCalendarObject[], options?: ICalOptions): string;

package/dist/ical.js

@@ -0,0 +1,202 @@
+import { normalizeUtcDateTime } from "./utils.js";
+const DEFAULT_PRODID = "-//craftguild//EN";
+export function toICal(objects, options = {}) {
+    const lines = [];
+    const includeX = options.includeXJSCalendar !== false;
+    lines.push("BEGIN:VCALENDAR");
+    lines.push("VERSION:2.0");
+    lines.push(`PRODID:${options.prodId ?? DEFAULT_PRODID}`);
+    const method = options.method ?? findMethod(objects);
+    if (method)
+        lines.push(`METHOD:${method.toUpperCase()}`);
+    for (const object of objects) {
+        if (object["@type"] === "Group") {
+            const group = object;
+            if (includeX) {
+                lines.push(`X-JSCALENDAR-GROUP:${escapeText(JSON.stringify(stripEntries(group)))}`);
+            }
+            for (const entry of group.entries) {
+                lines.push(...buildComponent(entry, includeX));
+            }
+        }
+        else {
+            lines.push(...buildComponent(object, includeX));
+        }
+    }
+    lines.push("END:VCALENDAR");
+    return foldLines(lines).join("\r\n");
+}
+function findMethod(objects) {
+    for (const object of objects) {
+        if (object.method)
+            return object.method;
+    }
+    return undefined;
+}
+function buildComponent(object, includeX) {
+    if (object["@type"] === "Event")
+        return buildEvent(object, includeX);
+    if (object["@type"] === "Task")
+        return buildTask(object, includeX);
+    return [];
+}
+function buildEvent(event, includeX) {
+    const lines = [];
+    lines.push("BEGIN:VEVENT");
+    lines.push(`UID:${escapeText(event.uid)}`);
+    lines.push(`DTSTAMP:${formatUtcDateTime(event.updated)}`);
+    if (event.sequence !== undefined)
+        lines.push(`SEQUENCE:${event.sequence}`);
+    if (event.title)
+        lines.push(`SUMMARY:${escapeText(event.title)}`);
+    if (event.description)
+        lines.push(`DESCRIPTION:${escapeText(event.description)}`);
+    const dtStart = formatLocalDateTime(event.start);
+    if (event.timeZone) {
+        lines.push(`DTSTART;TZID=${event.timeZone}:${dtStart}`);
+    }
+    else {
+        lines.push(`DTSTART:${dtStart}`);
+    }
+    if (event.duration)
+        lines.push(`DURATION:${event.duration}`);
+    if (event.status)
+        lines.push(`STATUS:${event.status.toUpperCase()}`);
+    appendRecurrence(lines, event.recurrenceRules);
+    if (includeX) {
+        lines.push(`X-JSCALENDAR:${escapeText(JSON.stringify(event))}`);
+    }
+    lines.push("END:VEVENT");
+    return lines;
+}
+function buildTask(task, includeX) {
+    const lines = [];
+    lines.push("BEGIN:VTODO");
+    lines.push(`UID:${escapeText(task.uid)}`);
+    lines.push(`DTSTAMP:${formatUtcDateTime(task.updated)}`);
+    if (task.sequence !== undefined)
+        lines.push(`SEQUENCE:${task.sequence}`);
+    if (task.title)
+        lines.push(`SUMMARY:${escapeText(task.title)}`);
+    if (task.description)
+        lines.push(`DESCRIPTION:${escapeText(task.description)}`);
+    if (task.start) {
+        const dtStart = formatLocalDateTime(task.start);
+        if (task.timeZone) {
+            lines.push(`DTSTART;TZID=${task.timeZone}:${dtStart}`);
+        }
+        else {
+            lines.push(`DTSTART:${dtStart}`);
+        }
+    }
+    if (task.due) {
+        const due = formatLocalDateTime(task.due);
+        if (task.timeZone) {
+            lines.push(`DUE;TZID=${task.timeZone}:${due}`);
+        }
+        else {
+            lines.push(`DUE:${due}`);
+        }
+    }
+    if (task.percentComplete !== undefined) {
+        lines.push(`PERCENT-COMPLETE:${task.percentComplete}`);
+    }
+    if (task.progress) {
+        lines.push(`STATUS:${task.progress.toUpperCase()}`);
+    }
+    appendRecurrence(lines, task.recurrenceRules);
+    if (includeX) {
+        lines.push(`X-JSCALENDAR:${escapeText(JSON.stringify(task))}`);
+    }
+    lines.push("END:VTODO");
+    return lines;
+}
+function appendRecurrence(lines, rules) {
+    if (!rules)
+        return;
+    for (const rule of rules) {
+        const rrule = recurrenceRuleToRRule(rule);
+        if (rrule)
+            lines.push(`RRULE:${rrule}`);
+    }
+}
+function recurrenceRuleToRRule(rule) {
+    const parts = [];
+    parts.push(`FREQ=${rule.frequency.toUpperCase()}`);
+    if (rule.interval)
+        parts.push(`INTERVAL=${rule.interval}`);
+    if (rule.count)
+        parts.push(`COUNT=${rule.count}`);
+    if (rule.until)
+        parts.push(`UNTIL=${formatLocalDateTime(rule.until)}`);
+    if (rule.byDay?.length) {
+        const days = rule.byDay
+            .map((day) => `${day.nthOfPeriod ?? ""}${day.day.toUpperCase()}`)
+            .join(",");
+        parts.push(`BYDAY=${days}`);
+    }
+    if (rule.byMonthDay?.length)
+        parts.push(`BYMONTHDAY=${rule.byMonthDay.join(",")}`);
+    if (rule.byMonth?.length)
+        parts.push(`BYMONTH=${rule.byMonth.join(",")}`);
+    if (rule.byYearDay?.length)
+        parts.push(`BYYEARDAY=${rule.byYearDay.join(",")}`);
+    if (rule.byWeekNo?.length)
+        parts.push(`BYWEEKNO=${rule.byWeekNo.join(",")}`);
+    if (rule.byHour?.length)
+        parts.push(`BYHOUR=${rule.byHour.join(",")}`);
+    if (rule.byMinute?.length)
+        parts.push(`BYMINUTE=${rule.byMinute.join(",")}`);
+    if (rule.bySecond?.length)
+        parts.push(`BYSECOND=${rule.bySecond.join(",")}`);
+    if (rule.bySetPosition?.length)
+        parts.push(`BYSETPOS=${rule.bySetPosition.join(",")}`);
+    if (rule.firstDayOfWeek)
+        parts.push(`WKST=${rule.firstDayOfWeek.toUpperCase()}`);
+    if (rule.rscale)
+        parts.push(`RSCALE=${rule.rscale.toUpperCase()}`);
+    if (rule.skip)
+        parts.push(`SKIP=${rule.skip.toUpperCase()}`);
+    return parts.join(";");
+}
+function formatUtcDateTime(value) {
+    const normalized = normalizeUtcDateTime(value);
+    return normalized
+        .replace(/[-:]/g, "")
+        .replace(/\.\d+Z$/, "Z")
+        .replace(/Z$/, "Z");
+}
+function formatLocalDateTime(value) {
+    return value
+        .replace(/[-:]/g, "")
+        .replace(/\.\d+$/, "")
+        .replace(/Z$/, "");
+}
+function escapeText(value) {
+    return value
+        .replace(/\\/g, "\\\\")
+        .replace(/\n/g, "\\n")
+        .replace(/;/g, "\\;")
+        .replace(/,/g, "\\,");
+}
+function foldLines(lines) {
+    const result = [];
+    for (const line of lines) {
+        if (line.length <= 75) {
+            result.push(line);
+            continue;
+        }
+        let remaining = line;
+        result.push(remaining.slice(0, 75));
+        remaining = remaining.slice(75);
+        while (remaining.length > 0) {
+            result.push(` ${remaining.slice(0, 74)}`);
+            remaining = remaining.slice(74);
+        }
+    }
+    return result;
+}
+function stripEntries(group) {
+    const { entries: _entries, ...rest } = group;
+    return rest;
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { JsCal } from "./jscal.js";
+export { ValidationError } from "./validate.js";
+export type * from "./types.js";