@robinpath/calendar - npm Package Compare versions

Comparing version

0.1.1

0.1.2

+15

-3

package.json

		{
		"name": "@robinpath/calendar",
		"version": "0.1.1",
		"version": "0.1.2",
		"publishConfig": {
		@@ -24,9 +24,21 @@ "access": "public"
		"peerDependencies": {
		"@wiredwp/robinpath": ">=0.20.0"
		"@robinpath/core": ">=0.20.0"
		},
		"devDependencies": {
		"@wiredwp/robinpath": "^0.30.1",
		"@robinpath/core": "^0.30.1",
		"tsx": "^4.19.0",
		"typescript": "^5.6.0"
		},
		"description": "iCal (.ics) calendar parsing, generation, event management, and date range queries",
		"keywords": [
		"calendar",
		"utility"
		],
		"license": "MIT",
		"robinpath": {
		"category": "utility",
		"type": "utility",
		"auth": "none",
		"functionCount": 13
		}
		}

-178

dist/calendar.d.ts

		import type { BuiltinHandler } from "@wiredwp/robinpath";
		export declare const CalendarFunctions: Record<string, BuiltinHandler>;
		export declare const CalendarFunctionMetadata: {
		createEvent: {
		description: string;
		parameters: {
		name: string;
		dataType: string;
		description: string;
		formInputType: string;
		required: boolean;
		}[];
		returnType: string;
		returnDescription: string;
		example: string;
		};
		createCalendar: {
		description: string;
		parameters: {
		name: string;
		dataType: string;
		description: string;
		formInputType: string;
		required: boolean;
		}[];
		returnType: string;
		returnDescription: string;
		example: string;
		};
		parse: {
		description: string;
		parameters: {
		name: string;
		dataType: string;
		description: string;
		formInputType: string;
		required: boolean;
		}[];
		returnType: string;
		returnDescription: string;
		example: string;
		};
		parseFile: {
		description: string;
		parameters: {
		name: string;
		dataType: string;
		description: string;
		formInputType: string;
		required: boolean;
		}[];
		returnType: string;
		returnDescription: string;
		example: string;
		};
		writeFile: {
		description: string;
		parameters: {
		name: string;
		dataType: string;
		description: string;
		formInputType: string;
		required: boolean;
		}[];
		returnType: string;
		returnDescription: string;
		example: string;
		};
		addEvent: {
		description: string;
		parameters: {
		name: string;
		dataType: string;
		description: string;
		formInputType: string;
		required: boolean;
		}[];
		returnType: string;
		returnDescription: string;
		example: string;
		};
		removeEvent: {
		description: string;
		parameters: {
		name: string;
		dataType: string;
		description: string;
		formInputType: string;
		required: boolean;
		}[];
		returnType: string;
		returnDescription: string;
		example: string;
		};
		findEvents: {
		description: string;
		parameters: {
		name: string;
		dataType: string;
		description: string;
		formInputType: string;
		required: boolean;
		}[];
		returnType: string;
		returnDescription: string;
		example: string;
		};
		today: {
		description: string;
		parameters: {
		name: string;
		dataType: string;
		description: string;
		formInputType: string;
		required: boolean;
		}[];
		returnType: string;
		returnDescription: string;
		example: string;
		};
		upcoming: {
		description: string;
		parameters: {
		name: string;
		dataType: string;
		description: string;
		formInputType: string;
		required: boolean;
		}[];
		returnType: string;
		returnDescription: string;
		example: string;
		};
		toJson: {
		description: string;
		parameters: {
		name: string;
		dataType: string;
		description: string;
		formInputType: string;
		required: boolean;
		}[];
		returnType: string;
		returnDescription: string;
		example: string;
		};
		formatDate: {
		description: string;
		parameters: {
		name: string;
		dataType: string;
		description: string;
		formInputType: string;
		required: boolean;
		}[];
		returnType: string;
		returnDescription: string;
		example: string;
		};
		parseDate: {
		description: string;
		parameters: {
		name: string;
		dataType: string;
		description: string;
		formInputType: string;
		required: boolean;
		}[];
		returnType: string;
		returnDescription: string;
		example: string;
		};
		};
		export declare const CalendarModuleMetadata: {
		description: string;
		methods: string[];
		};
		//# sourceMappingURL=calendar.d.ts.map

-1

dist/calendar.d.ts.map

{"version":3,"file":"calendar.d.ts","sourceRoot":"","sources":["../src/calendar.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAA2C,MAAM,oBAAoB,CAAC;AAuIlG,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAmJ,CAAC;AAEjN,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAcpC,CAAC;AAEF,eAAO,MAAM,sBAAsB;;;CAGlC,CAAC"}

-157

dist/calendar.js

		import { readFileSync, writeFileSync } from "node:fs";
		import { randomUUID } from "node:crypto";
		function toIcalDate(iso, allDay = false) {
		const d = new Date(iso);
		if (allDay)
		return d.toISOString().slice(0, 10).replace(/-/g, "");
		return d.toISOString().replace(/[-:]/g, "").replace(/\.\d{3}/, "");
		}
		function fromIcalDate(ical) {
		if (ical.length === 8)
		return `${ical.slice(0, 4)}-${ical.slice(4, 6)}-${ical.slice(6, 8)}`;
		const m = ical.match(/(\d{4})(\d{2})(\d{2})T(\d{2})(\d{2})(\d{2})/);
		if (!m)
		return ical;
		return `${m[1]}-${m[2]}-${m[3]}T${m[4]}:${m[5]}:${m[6]}${ical.endsWith("Z") ? "Z" : ""}`;
		}
		function escIcal(s) { return s.replace(/\\/g, "\\\\").replace(/;/g, "\\;").replace(/,/g, "\\,").replace(/\n/g, "\\n"); }
		function unescIcal(s) { return s.replace(/\\n/g, "\n").replace(/\\,/g, ",").replace(/\\;/g, ";").replace(/\\\\/g, "\\"); }
		function extractProp(block, prop) {
		const re = new RegExp(`^${prop}[;:](.*)`, "mi");
		const m = block.match(re);
		if (!m)
		return undefined;
		let val = m[1];
		if (val.includes(":"))
		val = val.split(":").slice(-1)[0];
		return unescIcal(val.trim());
		}
		const createEvent = (args) => {
		const opts = (typeof args[0] === "object" && args[0] !== null ? args[0] : {});
		return {
		uid: opts.uid ? String(opts.uid) : randomUUID(),
		summary: String(opts.summary ?? ""),
		description: opts.description ? String(opts.description) : undefined,
		location: opts.location ? String(opts.location) : undefined,
		start: String(opts.start ?? new Date().toISOString()),
		end: opts.end ? String(opts.end) : undefined,
		allDay: opts.allDay === true,
		organizer: opts.organizer ? String(opts.organizer) : undefined,
		attendees: Array.isArray(opts.attendees) ? opts.attendees.map(String) : undefined,
		url: opts.url ? String(opts.url) : undefined,
		};
		};
		const createCalendar = (args) => {
		const events = (Array.isArray(args[0]) ? args[0] : []);
		const opts = (typeof args[1] === "object" && args[1] !== null ? args[1] : {});
		const lines = ["BEGIN:VCALENDAR", "VERSION:2.0", `PRODID:-//RobinPath//Calendar//EN`];
		if (opts.name)
		lines.push(`X-WR-CALNAME:${escIcal(String(opts.name))}`);
		if (opts.timezone)
		lines.push(`X-WR-TIMEZONE:${String(opts.timezone)}`);
		for (const ev of events) {
		lines.push("BEGIN:VEVENT");
		lines.push(`UID:${ev.uid ?? randomUUID()}`);
		lines.push(`SUMMARY:${escIcal(String(ev.summary ?? ""))}`);
		if (ev.description)
		lines.push(`DESCRIPTION:${escIcal(String(ev.description))}`);
		if (ev.location)
		lines.push(`LOCATION:${escIcal(String(ev.location))}`);
		const allDay = ev.allDay === true;
		lines.push(allDay ? `DTSTART;VALUE=DATE:${toIcalDate(String(ev.start), true)}` : `DTSTART:${toIcalDate(String(ev.start))}`);
		if (ev.end)
		lines.push(allDay ? `DTEND;VALUE=DATE:${toIcalDate(String(ev.end), true)}` : `DTEND:${toIcalDate(String(ev.end))}`);
		if (ev.organizer)
		lines.push(`ORGANIZER:mailto:${ev.organizer}`);
		if (Array.isArray(ev.attendees))
		for (const a of ev.attendees)
		lines.push(`ATTENDEE:mailto:${a}`);
		if (ev.url)
		lines.push(`URL:${ev.url}`);
		lines.push(`DTSTAMP:${toIcalDate(new Date().toISOString())}`);
		lines.push("END:VEVENT");
		}
		lines.push("END:VCALENDAR");
		return lines.join("\r\n");
		};
		const parse = (args) => {
		const ics = String(args[0] ?? "");
		const nameMatch = ics.match(/X-WR-CALNAME:(.*)/i);
		const eventBlocks = ics.split(/BEGIN:VEVENT/i).slice(1);
		const events = eventBlocks.map((block) => {
		const endIdx = block.indexOf("END:VEVENT");
		const content = endIdx >= 0 ? block.substring(0, endIdx) : block;
		const dtstart = extractProp(content, "DTSTART");
		const dtend = extractProp(content, "DTEND");
		const allDay = content.includes("VALUE=DATE");
		const attendees = [];
		const attMatches = content.matchAll(/ATTENDEE[^:]*:(?:mailto:)?(.+)/gi);
		for (const m of attMatches)
		attendees.push(m[1].trim());
		return {
		uid: extractProp(content, "UID"), summary: extractProp(content, "SUMMARY"),
		description: extractProp(content, "DESCRIPTION"), location: extractProp(content, "LOCATION"),
		start: dtstart ? fromIcalDate(dtstart) : undefined, end: dtend ? fromIcalDate(dtend) : undefined,
		allDay, organizer: extractProp(content, "ORGANIZER")?.replace(/mailto:/i, ""),
		attendees: attendees.length ? attendees : undefined, url: extractProp(content, "URL"),
		};
		});
		return { name: nameMatch?.[1]?.trim() ?? null, events };
		};
		const parseFile = (args) => parse([readFileSync(String(args[0] ?? ""), "utf-8")]);
		const writeFile = (args) => { writeFileSync(String(args[0] ?? ""), String(args[1] ?? "")); return true; };
		const addEvent = (args) => {
		const ics = String(args[0] ?? "");
		const ev = (typeof args[1] === "object" && args[1] !== null ? args[1] : {});
		const eventIcs = createCalendar([[ev]]).split("BEGIN:VEVENT")[1].split("END:VCALENDAR")[0];
		return ics.replace(/END:VCALENDAR/i, `BEGIN:VEVENT${eventIcs}END:VCALENDAR`);
		};
		const removeEvent = (args) => {
		const ics = String(args[0] ?? "");
		const uid = String(args[1] ?? "");
		return ics.replace(new RegExp(`BEGIN:VEVENT[\\s\\S]?UID:${uid.replace(/[.+?^${}()\|[\]\\]/g, "\\$&")}[\\s\\S]*?END:VEVENT\\r?\\n?`, "i"), "");
		};
		const findEvents = (args) => {
		const events = (Array.isArray(args[0]) ? args[0] : []);
		const start = new Date(String(args[1] ?? "")).getTime();
		const end = new Date(String(args[2] ?? "")).getTime();
		return events.filter((e) => { const t = new Date(String(e.start ?? "")).getTime(); return t >= start && t <= end; });
		};
		const today = (args) => {
		const events = (Array.isArray(args[0]) ? args[0] : []);
		const now = new Date();
		const dayStart = new Date(now.getFullYear(), now.getMonth(), now.getDate()).toISOString();
		const dayEnd = new Date(now.getFullYear(), now.getMonth(), now.getDate() + 1).toISOString();
		return findEvents([events, dayStart, dayEnd]);
		};
		const upcoming = (args) => {
		const events = (Array.isArray(args[0]) ? args[0] : []);
		const days = Number(args[1] ?? 7);
		const now = new Date();
		const end = new Date(now.getTime() + days * 86400000);
		return findEvents([events, now.toISOString(), end.toISOString()]);
		};
		const toJson = (args) => parse(args);
		const formatDate = (args) => toIcalDate(String(args[0] ?? new Date().toISOString()));
		const parseDate = (args) => fromIcalDate(String(args[0] ?? ""));
		export const CalendarFunctions = { createEvent, createCalendar, parse, parseFile, writeFile, addEvent, removeEvent, findEvents, today, upcoming, toJson, formatDate, parseDate };
		export const CalendarFunctionMetadata = {
		createEvent: { description: "Create an iCal event object", parameters: [{ name: "options", dataType: "object", description: "{summary, description, location, start, end, allDay, organizer, attendees, url, uid}", formInputType: "text", required: true }], returnType: "object", returnDescription: "Event object", example: 'calendar.createEvent {"summary": "Meeting", "start": "2024-01-15T10:00:00Z", "end": "2024-01-15T11:00:00Z"}' },
		createCalendar: { description: "Create iCal string from events", parameters: [{ name: "events", dataType: "array", description: "Event objects", formInputType: "text", required: true }, { name: "options", dataType: "object", description: "{name, timezone}", formInputType: "text", required: false }], returnType: "string", returnDescription: "iCal string", example: 'calendar.createCalendar [$event1, $event2] {"name": "My Calendar"}' },
		parse: { description: "Parse iCal string", parameters: [{ name: "icsString", dataType: "string", description: "iCal content", formInputType: "text", required: true }], returnType: "object", returnDescription: "{name, events[]}", example: 'calendar.parse $icsContent' },
		parseFile: { description: "Parse .ics file", parameters: [{ name: "filePath", dataType: "string", description: "File path", formInputType: "text", required: true }], returnType: "object", returnDescription: "{name, events[]}", example: 'calendar.parseFile "./events.ics"' },
		writeFile: { description: "Write iCal to file", parameters: [{ name: "filePath", dataType: "string", description: "File path", formInputType: "text", required: true }, { name: "icsString", dataType: "string", description: "iCal content", formInputType: "text", required: true }], returnType: "boolean", returnDescription: "true", example: 'calendar.writeFile "./events.ics" $ics' },
		addEvent: { description: "Add event to iCal string", parameters: [{ name: "icsString", dataType: "string", description: "Existing iCal", formInputType: "text", required: true }, { name: "event", dataType: "object", description: "Event object", formInputType: "text", required: true }], returnType: "string", returnDescription: "Updated iCal", example: 'calendar.addEvent $ics $event' },
		removeEvent: { description: "Remove event by UID", parameters: [{ name: "icsString", dataType: "string", description: "Existing iCal", formInputType: "text", required: true }, { name: "uid", dataType: "string", description: "Event UID", formInputType: "text", required: true }], returnType: "string", returnDescription: "Updated iCal", example: 'calendar.removeEvent $ics "abc-123"' },
		findEvents: { description: "Find events in date range", parameters: [{ name: "events", dataType: "array", description: "Event array", formInputType: "text", required: true }, { name: "start", dataType: "string", description: "Start date ISO", formInputType: "text", required: true }, { name: "end", dataType: "string", description: "End date ISO", formInputType: "text", required: true }], returnType: "array", returnDescription: "Matching events", example: 'calendar.findEvents $events "2024-01-01" "2024-01-31"' },
		today: { description: "Get today's events", parameters: [{ name: "events", dataType: "array", description: "Event array", formInputType: "text", required: true }], returnType: "array", returnDescription: "Today's events", example: 'calendar.today $events' },
		upcoming: { description: "Get upcoming events", parameters: [{ name: "events", dataType: "array", description: "Event array", formInputType: "text", required: true }, { name: "days", dataType: "number", description: "Days ahead (default 7)", formInputType: "text", required: false }], returnType: "array", returnDescription: "Upcoming events", example: 'calendar.upcoming $events 14' },
		toJson: { description: "Convert iCal to JSON", parameters: [{ name: "icsString", dataType: "string", description: "iCal content", formInputType: "text", required: true }], returnType: "object", returnDescription: "Parsed object", example: 'calendar.toJson $ics' },
		formatDate: { description: "Format ISO to iCal date", parameters: [{ name: "isoDate", dataType: "string", description: "ISO date", formInputType: "text", required: true }], returnType: "string", returnDescription: "iCal date", example: 'calendar.formatDate "2024-01-15T10:00:00Z"' },
		parseDate: { description: "Parse iCal date to ISO", parameters: [{ name: "icalDate", dataType: "string", description: "iCal date", formInputType: "text", required: true }], returnType: "string", returnDescription: "ISO date", example: 'calendar.parseDate "20240115T100000Z"' },
		};
		export const CalendarModuleMetadata = {
		description: "iCal (.ics) calendar parsing, generation, event management, and date range queries",
		methods: ["createEvent", "createCalendar", "parse", "parseFile", "writeFile", "addEvent", "removeEvent", "findEvents", "today", "upcoming", "toJson", "formatDate", "parseDate"],
		};
		//# sourceMappingURL=calendar.js.map

-1

dist/calendar.js.map

-6

dist/index.d.ts

		import type { ModuleAdapter } from "@wiredwp/robinpath";
		declare const CalendarModule: ModuleAdapter;
		export default CalendarModule;
		export { CalendarModule };
		export { CalendarFunctions, CalendarFunctionMetadata, CalendarModuleMetadata } from "./calendar.js";
		//# sourceMappingURL=index.d.ts.map

-1

dist/index.d.ts.map

{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAExD,QAAA,MAAM,cAAc,EAAE,aAAmL,CAAC;AAC1M,eAAe,cAAc,CAAC;AAC9B,OAAO,EAAE,cAAc,EAAE,CAAC;AAC1B,OAAO,EAAE,iBAAiB,EAAE,wBAAwB,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAC"}

-6

dist/index.js

		import { CalendarFunctions, CalendarFunctionMetadata, CalendarModuleMetadata } from "./calendar.js";
		const CalendarModule = { name: "calendar", functions: CalendarFunctions, functionMetadata: CalendarFunctionMetadata, moduleMetadata: CalendarModuleMetadata, global: false };
		export default CalendarModule;
		export { CalendarModule };
		export { CalendarFunctions, CalendarFunctionMetadata, CalendarModuleMetadata } from "./calendar.js";
		//# sourceMappingURL=index.js.map

-1

dist/index.js.map

{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,iBAAiB,EAAE,wBAAwB,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAC;AACpG,MAAM,cAAc,GAAkB,EAAE,IAAI,EAAE,UAAU,EAAE,SAAS,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,wBAA+B,EAAE,cAAc,EAAE,sBAA6B,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC;AAC1M,eAAe,cAAc,CAAC;AAC9B,OAAO,EAAE,cAAc,EAAE,CAAC;AAC1B,OAAO,EAAE,iBAAiB,EAAE,wBAAwB,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAC"}

@robinpath/calendar - npm Package Compare versions

New alerts

Fixed alerts

Improved metrics

Worsened metrics