@craftguild/jscalendar 0.5.2 → 0.5.4

package/package.json

@@ -1,34 +1,49 @@
 {
-  "name": "@craftguild/jscalendar",
-  "version": "0.5.2",
-  "description": "RFC 8984 (JSCalendar) data model helpers for TypeScript",
-  "license": "MIT",
-  "type": "module",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "default": "./dist/index.js"
+    "name": "@craftguild/jscalendar",
+    "version": "0.5.4",
+    "description": "RFC 8984 (JSCalendar) data model helpers for TypeScript",
+    "license": "MIT",
+    "type": "module",
+    "main": "dist/index.cjs",
+    "module": "dist/index.mjs",
+    "types": "dist/index.d.mts",
+    "exports": {
+        ".": {
+            "types": {
+                "import": "./dist/index.d.mts",
+                "require": "./dist/index.d.cts"
+            },
+            "import": "./dist/index.mjs",
+            "require": "./dist/index.cjs",
+            "default": "./dist/index.mjs"
+        }
+    },
+    "files": [
+        "dist"
+    ],
+    "scripts": {
+        "prepublish": "tsdown",
+        "build": "tsc -p tsconfig.json",
+        "test": "vitest run",
+        "test:watch": "vitest",
+        "test:coverage": "vitest run --coverage",
+        "prepare": "husky"
+    },
+    "devDependencies": {
+        "@vitest/coverage-v8": "^2.1.9",
+        "husky": "^9.1.7",
+        "lint-staged": "^16.2.7",
+        "prettier": "3.8.1",
+        "tsdown": "^0.20.1",
+        "tsx": "^4.21.0",
+        "typescript": "^5.6.2",
+        "vitest": "^2.1.9"
+    },
+    "dependencies": {
+        "date-fns": "^4.1.0",
+        "date-fns-tz": "^3.2.0"
+    },
+    "lint-staged": {
+        "**/*": "prettier --write --ignore-unknown"
     }
-  },
-  "files": [
-    "dist"
-  ],
-  "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "test:coverage": "vitest run --coverage"
-  },
-  "devDependencies": {
-    "@vitest/coverage-v8": "^2.1.9",
-    "tsx": "^4.21.0",
-    "typescript": "^5.6.2",
-    "vitest": "^2.1.9"
-  },
-  "dependencies": {
-    "date-fns": "^4.1.0",
-    "date-fns-tz": "^3.2.0"
-  }
 }

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

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

package/dist/__tests__/builders.test.js

@@ -1,101 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { JsCal } from "../jscal.js";
-import { buildAbsoluteTrigger, buildAlert, buildIdMap, buildLink, buildLocation, buildNDay, buildOffsetTrigger, buildRecurrenceRule, buildRelation, buildTimeZone, buildTimeZoneMap, buildTimeZoneRule, buildVirtualLocation, } from "../jscal/builders.js";
-describe("builders", () => {
-    it("builds strict objects with @type", () => {
-        const participant = JsCal.Participant({ name: "Alice", roles: { attendee: true } });
-        const location = buildLocation({ name: "Room A" });
-        const vloc = buildVirtualLocation({ name: "Zoom", uri: "https://example.com" });
-        const link = buildLink({ href: "https://example.com" });
-        const relation = buildRelation({ relation: { parent: true } });
-        const alert = buildAlert({ trigger: buildOffsetTrigger({ offset: JsCal.duration.minutes(-15) }) });
-        const absoluteTrigger = buildAbsoluteTrigger({ when: "2026-02-01T00:00:00Z" });
-        const nday = buildNDay({ day: "mo" });
-        const rule = buildRecurrenceRule({ frequency: "daily" });
-        const tzRule = buildTimeZoneRule({
-            start: "2026-01-01T00:00:00",
-            offsetFrom: "+09:00",
-            offsetTo: "+09:00",
-        });
-        const tz = buildTimeZone({
-            tzId: "Asia/Tokyo",
-            standard: [tzRule],
-        });
-        expect(participant["@type"]).toBe("Participant");
-        expect(location["@type"]).toBe("Location");
-        expect(vloc["@type"]).toBe("VirtualLocation");
-        expect(link["@type"]).toBe("Link");
-        expect(relation["@type"]).toBe("Relation");
-        expect(alert["@type"]).toBe("Alert");
-        expect(absoluteTrigger["@type"]).toBe("AbsoluteTrigger");
-        expect(nday["@type"]).toBe("NDay");
-        expect(rule["@type"]).toBe("RecurrenceRule");
-        expect(tz["@type"]).toBe("TimeZone");
-    });
-    it("builds id maps with generated ids", () => {
-        const participants = JsCal.participants([
-            { value: { name: "Alice", roles: { attendee: true } } },
-            { value: { name: "Bob", roles: { attendee: true } } },
-        ]);
-        expect(Object.keys(participants).length).toBe(2);
-        const locations = JsCal.locations([{ value: { name: "Room A" } }]);
-        expect(Object.keys(locations).length).toBe(1);
-        const links = JsCal.links([{ value: { href: "https://example.com" } }]);
-        expect(Object.keys(links).length).toBe(1);
-        const related = JsCal.relatedTo([{ value: { relation: { parent: true } } }]);
-        expect(Object.keys(related).length).toBe(1);
-    });
-    it("merges id maps with explicit ids", () => {
-        const existing = JsCal.locations([{ id: "loc-1", value: { name: "Room A" } }]);
-        const merged = JsCal.locations([
-            { id: "loc-1", value: { name: "Room A Updated" } },
-            { value: { name: "Room B" } },
-        ], existing);
-        expect(existing["loc-1"]?.name).toBe("Room A");
-        expect(merged["loc-1"]?.name).toBe("Room A Updated");
-        expect(Object.keys(merged).length).toBe(2);
-    });
-    it("rejects wrapper inputs that mix value and direct fields", () => {
-        expect(() => JsCal.locations([{ name: "Room A" }])).toThrowError();
-    });
-    it("builds a time zone map keyed by tzId", () => {
-        const map = buildTimeZoneMap([
-            { tzId: "Asia/Tokyo", standard: [{ "@type": "TimeZoneRule", start: "2026-01-01T00:00:00", offsetFrom: "+09:00", offsetTo: "+09:00" }] },
-        ]);
-        expect(map["Asia/Tokyo"]?.tzId).toBe("Asia/Tokyo");
-    });
-    it("buildIdMap uses a custom id function", () => {
-        const map = buildIdMap([{ value: { name: "A" } }], (item) => item, (_item, index) => `id-${index}`);
-        expect(Object.keys(map)).toEqual(["id-0"]);
-    });
-    it("throws when @type mismatches", () => {
-        // Intentionally bypass type safety to assert @type validation errors.
-        const bad = { "@type": "Location" };
-        expect(() => JsCal.Participant(bad)).toThrowError("participant: must have @type Participant");
-    });
-    it("throws for mismatched @type across builders", () => {
-        // Intentionally bypass type safety to assert @type validation errors.
-        expect(() => buildLocation({ "@type": "Participant" }))
-            .toThrowError("location: must have @type Location");
-        expect(() => buildVirtualLocation({ "@type": "Location" }))
-            .toThrowError("virtualLocation: must have @type VirtualLocation");
-        expect(() => buildAlert({ "@type": "Link" }))
-            .toThrowError("alert: must have @type Alert");
-        expect(() => buildOffsetTrigger({ "@type": "Alert" }))
-            .toThrowError("offsetTrigger: must have @type OffsetTrigger");
-        expect(() => buildAbsoluteTrigger({ "@type": "Alert" }))
-            .toThrowError("absoluteTrigger: must have @type AbsoluteTrigger");
-        expect(() => buildRelation({ "@type": "Link" }))
-            .toThrowError("relation: must have @type Relation");
-        expect(() => buildLink({ "@type": "Relation" }))
-            .toThrowError("link: must have @type Link");
-        expect(() => buildTimeZone({ "@type": "Alert" }))
-            .toThrowError("timeZone: must have @type TimeZone");
-        expect(() => buildTimeZoneRule({ "@type": "TimeZone" }))
-            .toThrowError("timeZoneRule: must have @type TimeZoneRule");
-        expect(() => buildRecurrenceRule({ "@type": "NDay" }))
-            .toThrowError("recurrenceRule: must have @type RecurrenceRule");
-        expect(() => buildNDay({ "@type": "RecurrenceRule" }))
-            .toThrowError("nday: must have @type NDay");
-    });
-});

package/dist/__tests__/calendar-extra.test.d.ts

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

package/dist/__tests__/calendar-extra.test.js

@@ -1,221 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { JsCal, createId, isEvent, isGroup, isTask } from "../jscal.js";
-const fixedNow = () => "2026-02-01T00:00:00Z";
-function makeEvent() {
-    return new JsCal.Event({
-        title: "Kickoff",
-        start: "2026-02-02T10:00:00",
-    }, { now: fixedNow });
-}
-describe("JsCal helpers", () => {
-    it("creates group and adds entry", () => {
-        const group = new JsCal.Group({ entries: [] }, { now: fixedNow });
-        const event = makeEvent();
-        const nextGroup = group.addEntry(event.data);
-        expect(group.data.entries.length).toBe(0);
-        expect(nextGroup.data.entries.length).toBe(1);
-    });
-    it("accepts JsCal instances and ejected entries in groups", () => {
-        const event = makeEvent();
-        const task = new JsCal.Task({ title: "Task", start: "2026-02-02T10:00:00" }, { now: fixedNow });
-        const group = new JsCal.Group({
-            entries: [event, task.eject()],
-        }, { now: fixedNow });
-        expect(group.data.entries.length).toBe(2);
-        expect(group.data.entries[0]?.["@type"]).toBe("Event");
-        expect(group.data.entries[1]?.["@type"]).toBe("Task");
-    });
-    it("does not expose addEntry on non-group", () => {
-        const event = makeEvent();
-        expect("addEntry" in event).toBe(false);
-    });
-    it("adds locations and virtual locations", () => {
-        const event = makeEvent();
-        const locId = "loc-1";
-        const vlocId = "vloc-1";
-        const withLocation = event.addLocation({ name: "Room A" }, locId);
-        const withVirtualLocation = withLocation.addVirtualLocation({ name: "Zoom", uri: "https://example.com" }, vlocId);
-        const locations = withVirtualLocation.data.locations;
-        const virtualLocations = withVirtualLocation.data.virtualLocations;
-        expect(locations).toBeDefined();
-        expect(virtualLocations).toBeDefined();
-        if (!locations || !virtualLocations)
-            throw new Error("Missing locations");
-        expect(locations[locId]?.name).toBe("Room A");
-        expect(virtualLocations[vlocId]?.uri).toBe("https://example.com");
-    });
-    it("adds participants and alerts", () => {
-        const event = makeEvent();
-        const participantId = "p1";
-        const alertId = "a1";
-        const withParticipant = event.addParticipant({ roles: { attendee: true }, email: "a@example.com" }, participantId);
-        const withAlert = withParticipant.addAlert({ trigger: { "@type": "AbsoluteTrigger", when: "2026-02-01T01:00:00Z" } }, alertId);
-        const participants = withAlert.data.participants;
-        const alerts = withAlert.data.alerts;
-        expect(participants).toBeDefined();
-        expect(alerts).toBeDefined();
-        if (!participants || !alerts)
-            throw new Error("Missing participants/alerts");
-        expect(participants[participantId]?.email).toBe("a@example.com");
-        expect(alerts[alertId]?.trigger).toBeTruthy();
-        expect(participants[participantId]?.participationStatus).toBe("needs-action");
-        expect(participants[participantId]?.expectReply).toBe(false);
-        expect(participants[participantId]?.scheduleAgent).toBe("server");
-        expect(participants[participantId]?.scheduleForceSend).toBe(false);
-        expect(participants[participantId]?.scheduleSequence).toBe(0);
-        expect(alerts[alertId]?.action).toBe("display");
-    });
-    it("defaults relativeTo for offset triggers", () => {
-        const event = makeEvent();
-        const alertId = "a1";
-        const withAlert = event.addAlert({ trigger: { "@type": "OffsetTrigger", offset: "PT15M" } }, alertId);
-        const alerts = withAlert.data.alerts;
-        expect(alerts).toBeDefined();
-        if (!alerts)
-            throw new Error("Missing alerts");
-        const trigger = alerts[alertId]?.trigger;
-        if (!trigger || trigger["@type"] !== "OffsetTrigger")
-            throw new Error("Missing trigger");
-        expect(trigger.relativeTo).toBe("start");
-    });
-    it("updates sequence for alerts but not for participants", () => {
-        const event = makeEvent();
-        const initialSequence = event.data.sequence ?? 0;
-        const withParticipant = event.addParticipant({ roles: { attendee: true }, email: "a@example.com" }, "p1");
-        expect(withParticipant.data.sequence ?? 0).toBe(initialSequence);
-        const withAlert = withParticipant.addAlert({ trigger: { "@type": "AbsoluteTrigger", when: "2026-02-01T01:00:00Z" } }, "a1");
-        expect(withAlert.data.sequence ?? 0).toBe(initialSequence + 1);
-    });
-    it("clones and eject return deep copies", () => {
-        const event = makeEvent();
-        const clone = event.clone();
-        clone.data.title = "Changed";
-        expect(event.data.title).toBe("Kickoff");
-        const json = event.eject();
-        json.title = "Changed";
-        expect(event.data.title).toBe("Kickoff");
-    });
-    it("builds participant inputs without @type", () => {
-        const participant = JsCal.Participant({ name: "Alice", roles: { attendee: true } });
-        const task = new JsCal.Task({
-            start: "2026-02-02T10:00:00",
-            participants: { p1: participant },
-        });
-        expect(task.data.participants?.p1?.["@type"]).toBe("Participant");
-    });
-    it("builds participant maps with stable ids", () => {
-        const participants = JsCal.participants([
-            { value: { name: "Alice", roles: { attendee: true } } },
-            { value: { name: "Bob", roles: { attendee: true } } },
-        ]);
-        const task = new JsCal.Task({
-            start: "2026-02-02T10:00:00",
-            participants,
-        });
-        expect(Object.keys(task.data.participants ?? {}).length).toBe(2);
-    });
-    it("createId returns base64url without padding", () => {
-        const id = createId();
-        expect(id).toMatch(/^[A-Za-z0-9_-]+$/);
-        expect(id).not.toContain("=");
-    });
-    it("supports task creation", () => {
-        const task = new JsCal.Task({
-            title: "Do work",
-            start: "2026-02-02T10:00:00",
-        }, { now: fixedNow });
-        expect(task.data["@type"]).toBe("Task");
-        expect(task.data.created).toBe("2026-02-01T00:00:00Z");
-    });
-    it("supports group creation", () => {
-        const group = new JsCal.Group({ entries: [] }, { now: fixedNow });
-        expect(group.data["@type"]).toBe("Group");
-        expect(group.data.created).toBe("2026-02-01T00:00:00Z");
-    });
-    it("accepts Date inputs and null time zones", () => {
-        const start = new Date("2026-02-02T10:00:00");
-        const event = new JsCal.Event({ title: "Date input", start, timeZone: null }, { now: fixedNow });
-        expect(event.data.start).toMatch(/^2026-02-02T/);
-        expect(event.data.timeZone).toBeNull();
-        const task = new JsCal.Task({ title: "No TZ", start, timeZone: null }, { now: fixedNow });
-        expect(task.data.timeZone).toBeNull();
-    });
-    it("accepts Date inputs for updated/created", () => {
-        const updated = new Date("2026-02-02T10:00:00Z");
-        const created = new Date("2026-02-01T09:00:00Z");
-        const event = new JsCal.Event({
-            title: "Dates",
-            start: "2026-02-02T10:00:00",
-            updated,
-            created,
-        });
-        expect(event.data.updated).toBe("2026-02-02T10:00:00Z");
-        expect(event.data.created).toBe("2026-02-01T09:00:00Z");
-    });
-    it("rejects invalid event start", () => {
-        expect(() => new JsCal.Event({ title: "Bad", start: "" })).toThrow();
-    });
-    it("resolves task time zones", () => {
-        const task = new JsCal.Task({ title: "TZ", start: "2026-02-02T10:00:00", timeZone: "asia/tokyo" }, { now: fixedNow });
-        expect(task.data.timeZone).toBe("Asia/Tokyo");
-    });
-    it("derives task progress from participant statuses", () => {
-        const completed = new JsCal.Task({
-            title: "Completed",
-            participants: {
-                p1: { "@type": "Participant", roles: { attendee: true }, progress: "completed" },
-            },
-        }, { now: fixedNow });
-        expect(completed.data.progress).toBe("completed");
-        const failed = new JsCal.Task({
-            title: "Failed",
-            participants: {
-                p1: { "@type": "Participant", roles: { attendee: true }, progress: "failed" },
-            },
-        }, { now: fixedNow });
-        expect(failed.data.progress).toBe("failed");
-        const inProcess = new JsCal.Task({
-            title: "In process",
-            participants: {
-                p1: { "@type": "Participant", roles: { attendee: true }, progress: "in-process" },
-            },
-        }, { now: fixedNow });
-        expect(inProcess.data.progress).toBe("in-process");
-        const fallback = new JsCal.Task({
-            title: "Fallback",
-            participants: {
-                p1: { "@type": "Participant", roles: { attendee: true }, progress: "delegated" },
-            },
-        }, { now: fixedNow });
-        expect(fallback.data.progress).toBe("needs-action");
-    });
-    it("clones task and group objects", () => {
-        const task = new JsCal.Task({ title: "Task", start: "2026-02-02T10:00:00" }, { now: fixedNow });
-        const taskClone = task.clone();
-        taskClone.data.title = "Changed";
-        expect(task.data.title).toBe("Task");
-        const group = new JsCal.Group({ entries: [] }, { now: fixedNow });
-        const groupClone = group.clone();
-        groupClone.data.title = "Changed";
-        expect(group.data.title).toBe("");
-    });
-    it("requires entries for group creation", () => {
-        // @ts-expect-error entries are required
-        expect(() => new JsCal.Group({})).toThrow();
-    });
-    it("supports get/set helpers", () => {
-        const event = makeEvent();
-        expect(event.get("title")).toBe("Kickoff");
-        const updated = event.set("title", "Updated");
-        expect(event.get("title")).toBe("Kickoff");
-        expect(updated.get("title")).toBe("Updated");
-    });
-    it("exposes type guards", () => {
-        const event = makeEvent().eject();
-        const task = new JsCal.Task({ title: "Task", start: "2026-02-02T10:00:00" }).eject();
-        const group = new JsCal.Group({ entries: [] }).eject();
-        expect(isEvent(event)).toBe(true);
-        expect(isTask(task)).toBe(true);
-        expect(isGroup(group)).toBe(true);
-    });
-});

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

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

package/dist/__tests__/calendar.test.js

@@ -1,97 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { JsCal, createUid } from "../jscal.js";
-const fixedNow = () => "2026-02-01T00:00:00Z";
-function makeEvent() {
-    return new JsCal.Event({
-        title: "Kickoff",
-        start: "2026-02-02T10:00:00",
-    }, { now: fixedNow });
-}
-describe("JsCal.Event", () => {
-    it("fills uid and updated", () => {
-        const event = makeEvent();
-        expect(event.data.uid).toBeTruthy();
-        expect(event.data.updated).toBe("2026-02-01T00:00:00Z");
-        expect(event.data["@type"]).toBe("Event");
-        expect(event.data.sequence).toBe(0);
-        expect(event.data.duration).toBe("PT0S");
-        expect(event.data.status).toBe("confirmed");
-        expect(event.data.created).toBe("2026-02-01T00:00:00Z");
-        expect(event.data.descriptionContentType).toBe("text/plain");
-        expect(event.data.showWithoutTime).toBe(false);
-        expect(event.data.freeBusyStatus).toBe("busy");
-        expect(event.data.privacy).toBe("public");
-        expect(event.data.useDefaultAlerts).toBe(false);
-        expect(event.data.excluded).toBe(false);
-        expect(event.data.timeZone).toBeUndefined();
-    });
-    it("throws when required fields are missing", () => {
-        expect(() => {
-            // @ts-expect-error start is required
-            new JsCal.Event({ title: "Missing start" }, { now: fixedNow });
-        }).toThrow(/Event.start/);
-    });
-    it("accepts explicit @type", () => {
-        const event = new JsCal.Event({ start: "2026-02-02T10:00:00" }, { now: fixedNow });
-        expect(event.data["@type"]).toBe("Event");
-    });
-    it("accepts Date for start", () => {
-        const event = new JsCal.Event({ start: new Date("2026-02-02T10:00:00") }, { now: fixedNow });
-        expect(event.data.start).toBe("2026-02-02T10:00:00");
-    });
-    it("does not set timeZone when missing", () => {
-        const event = new JsCal.Event({ start: new Date("2026-02-02T10:00:00") }, { now: fixedNow });
-        expect(event.data.timeZone).toBeUndefined();
-    });
-    it("accepts duration in seconds", () => {
-        const event = new JsCal.Event({ start: new Date("2026-02-02T10:00:00"), duration: 3600 }, { now: fixedNow });
-        expect(event.data.duration).toBe("PT1H");
-    });
-    it("handles duration boundaries", () => {
-        const zero = new JsCal.Event({ start: new Date("2026-02-02T10:00:00"), duration: 0 }, { now: fixedNow });
-        expect(zero.data.duration).toBe("PT0S");
-        const seconds = new JsCal.Event({ start: new Date("2026-02-02T10:00:00"), duration: 59 }, { now: fixedNow });
-        expect(seconds.data.duration).toBe("PT59S");
-        const negative = new JsCal.Event({ start: new Date("2026-02-02T10:00:00"), duration: -1 }, { now: fixedNow });
-        expect(negative.data.duration).toBe("PT0S");
-    });
-});
-describe("Event.patch", () => {
-    it("increments sequence on non-participant patches", () => {
-        const event = makeEvent();
-        const patched = event.patch({ title: "Updated" }, { now: fixedNow });
-        expect(patched.data.sequence).toBe(1);
-        expect(event.data.sequence).toBe(0);
-    });
-    it("respects touch=false", () => {
-        const event = makeEvent();
-        const before = event.data.updated;
-        const patched = event.patch({ title: "No touch" }, { touch: false, now: () => "2026-02-02T00:00:00Z" });
-        expect(patched.data.updated).toBe(before);
-    });
-    it("applies patch and updates metadata", () => {
-        const event = makeEvent();
-        const patched = event.patch({ title: "Patched" }, { now: fixedNow });
-        expect(patched.data.title).toBe("Patched");
-        expect(patched.data.updated).toBe("2026-02-01T00:00:00Z");
-        expect(patched.data.sequence).toBe(1);
-    });
-    it("does not increment sequence for participants-only patch", () => {
-        const event = makeEvent();
-        const patched = event.patch({
-            participants: {
-                p1: {
-                    "@type": "Participant",
-                    roles: { attendee: true },
-                },
-            },
-        }, { now: fixedNow });
-        expect(patched.data.sequence ?? 0).toBe(0);
-    });
-});
-describe("createUid", () => {
-    it("generates unique-ish id format", () => {
-        const uid = createUid();
-        expect(uid).toMatch(/^[0-9a-f-]{36}$/);
-    });
-});

package/dist/__tests__/ical-extra.test.d.ts

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

package/dist/__tests__/ical-extra.test.js

@@ -1,87 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { JsCal } from "../jscal.js";
-const task = {
-    "@type": "Task",
-    uid: "t1",
-    updated: "2026-02-01T00:00:00Z",
-    title: "Write notes",
-    description: "Prepare summary",
-    sequence: 1,
-    start: "2026-02-02T09:00:00",
-    due: "2026-02-02T17:00:00",
-    timeZone: "America/Los_Angeles",
-    percentComplete: 50,
-    progress: "in-process",
-};
-const group = {
-    "@type": "Group",
-    uid: "g1",
-    updated: "2026-02-01T00:00:00Z",
-    title: "Group",
-    entries: [task],
-};
-const event = {
-    "@type": "Event",
-    uid: "e2",
-    updated: "2026-02-01T00:00:00Z",
-    title: "Planning",
-    start: "2026-02-03T09:00:00",
-};
-const taskWithMethod = {
-    "@type": "Task",
-    uid: "t2",
-    updated: "2026-02-01T00:00:00Z",
-    title: "Method test",
-    method: "request",
-};
-const taskWithoutTimeZone = {
-    "@type": "Task",
-    uid: "t3",
-    updated: "2026-02-01T00:00:00Z",
-    title: "No TZ",
-    start: "2026-02-05T09:00:00",
-    due: "2026-02-05T17:00:00",
-};
-describe("toICal extras", () => {
-    it("exports VTODO with key fields", () => {
-        const ical = JsCal.toICal([task], { includeXJSCalendar: false });
-        expect(ical).toContain("BEGIN:VTODO");
-        expect(ical).toContain("UID:t1");
-        expect(ical).toContain("DTSTART;TZID=America/Los_Angeles:20260202T090000");
-        expect(ical).toContain("DUE;TZID=America/Los_Angeles:20260202T170000");
-        expect(ical).toContain("PERCENT-COMPLETE:50");
-        expect(ical).toContain("STATUS:IN-PROCESS");
-    });
-    it("exports group as VCALENDAR with entries", () => {
-        const ical = JsCal.toICal([group], { includeXJSCalendar: true });
-        expect(ical).toContain("BEGIN:VCALENDAR");
-        expect(ical).toContain("X-JSCALENDAR-GROUP:");
-        expect(ical).toContain("BEGIN:VTODO");
-    });
-    it("exports mixed arrays (group + event + task)", () => {
-        const ical = JsCal.toICal([group, event, task]);
-        expect(ical).toContain("BEGIN:VEVENT");
-        expect(ical).toContain("BEGIN:VTODO");
-    });
-    it("uses method from first object that defines it", () => {
-        const ical = JsCal.toICal([event, taskWithMethod]);
-        expect(ical).toContain("METHOD:REQUEST");
-    });
-    it("exports VTODO without time zone parameters", () => {
-        const ical = JsCal.toICal([taskWithoutTimeZone], { includeXJSCalendar: false });
-        expect(ical).toContain("DTSTART:20260205T090000");
-        expect(ical).toContain("DUE:20260205T170000");
-    });
-    it("ignores unknown object types", () => {
-        const unknownObject = {
-            "@type": "Unknown",
-            uid: "x1",
-            updated: "2026-02-01T00:00:00Z",
-        };
-        // @ts-expect-error unknown object type
-        const ical = JsCal.toICal([unknownObject], { includeXJSCalendar: false });
-        expect(ical).toContain("BEGIN:VCALENDAR");
-        expect(ical).not.toContain("BEGIN:VEVENT");
-        expect(ical).not.toContain("BEGIN:VTODO");
-    });
-});

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

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