@craftguild/jscalendar 0.1.0

package/dist/types.d.ts

@@ -0,0 +1,219 @@
+import type { TimeZoneId } from "./timezones.js";
+export { TimeZoneId, TimeZoneInput } from "./timezones.js";
+export type Id = string;
+export type Int = number;
+export type UnsignedInt = number;
+export type UTCDateTime = string;
+export type LocalDateTime = string;
+export type Duration = string;
+export type SignedDuration = string;
+export type BooleanMap = Record<string, true>;
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = JsonPrimitive | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+export type PatchObject = Record<string, JsonValue | null>;
+export interface Relation {
+    "@type": "Relation";
+    relation?: BooleanMap;
+}
+export interface Link {
+    "@type": "Link";
+    href: string;
+    cid?: string;
+    contentType?: string;
+    size?: UnsignedInt;
+    rel?: string;
+    display?: string;
+    title?: string;
+}
+export interface Location {
+    "@type": "Location";
+    name?: string;
+    description?: string;
+    locationTypes?: BooleanMap;
+    relativeTo?: string;
+    timeZone?: TimeZoneId;
+    coordinates?: string;
+    links?: Record<Id, Link>;
+}
+export interface VirtualLocation {
+    "@type": "VirtualLocation";
+    name?: string;
+    description?: string;
+    uri: string;
+    features?: BooleanMap;
+}
+export interface Participant {
+    "@type": "Participant";
+    name?: string;
+    email?: string;
+    description?: string;
+    sendTo?: Record<string, string>;
+    kind?: string;
+    roles: BooleanMap;
+    locationId?: Id;
+    language?: string;
+    participationStatus?: string;
+    participationComment?: string;
+    expectReply?: boolean;
+    scheduleAgent?: string;
+    scheduleForceSend?: boolean;
+    scheduleSequence?: UnsignedInt;
+    scheduleStatus?: string[];
+    scheduleUpdated?: UTCDateTime;
+    sentBy?: string;
+    invitedBy?: Id;
+    delegatedTo?: Record<Id, true>;
+    delegatedFrom?: Record<Id, true>;
+    memberOf?: Record<Id, true>;
+    links?: Record<Id, Link>;
+    progress?: string;
+    progressUpdated?: UTCDateTime;
+    percentComplete?: UnsignedInt;
+}
+export interface OffsetTrigger {
+    "@type": "OffsetTrigger";
+    offset: SignedDuration;
+    relativeTo?: "start" | "end" | string;
+}
+export interface AbsoluteTrigger {
+    "@type": "AbsoluteTrigger";
+    when: UTCDateTime;
+}
+export interface UnknownTrigger {
+    "@type": string;
+    [key: string]: JsonValue;
+}
+export type Trigger = OffsetTrigger | AbsoluteTrigger | UnknownTrigger;
+export interface Alert {
+    "@type": "Alert";
+    trigger: Trigger;
+    acknowledged?: UTCDateTime;
+    relatedTo?: Record<string, Relation>;
+    action?: string;
+}
+export type DayOfWeek = "mo" | "tu" | "we" | "th" | "fr" | "sa" | "su";
+export interface NDay {
+    "@type": "NDay";
+    day: DayOfWeek;
+    nthOfPeriod?: Int;
+}
+export interface RecurrenceRule {
+    "@type": "RecurrenceRule";
+    frequency: "yearly" | "monthly" | "weekly" | "daily" | "hourly" | "minutely" | "secondly";
+    interval?: UnsignedInt;
+    rscale?: string;
+    skip?: "omit" | "backward" | "forward";
+    firstDayOfWeek?: DayOfWeek;
+    byDay?: NDay[];
+    byMonthDay?: Int[];
+    byMonth?: string[];
+    byYearDay?: Int[];
+    byWeekNo?: Int[];
+    byHour?: UnsignedInt[];
+    byMinute?: UnsignedInt[];
+    bySecond?: UnsignedInt[];
+    bySetPosition?: Int[];
+    count?: UnsignedInt;
+    until?: LocalDateTime;
+}
+export interface TimeZoneRule {
+    "@type": "TimeZoneRule";
+    start: LocalDateTime;
+    offsetFrom: string;
+    offsetTo: string;
+    recurrenceRules?: RecurrenceRule[];
+    recurrenceOverrides?: Record<LocalDateTime, PatchObject>;
+    names?: BooleanMap;
+    comments?: string[];
+}
+export interface TimeZone {
+    "@type": "TimeZone";
+    tzId: string;
+    updated?: UTCDateTime;
+    url?: string;
+    validUntil?: UTCDateTime;
+    aliases?: BooleanMap;
+    standard?: TimeZoneRule[];
+    daylight?: TimeZoneRule[];
+}
+export interface JSCalendarCommon {
+    "@type": string;
+    uid: string;
+    relatedTo?: Record<string, Relation>;
+    prodId?: string;
+    created?: UTCDateTime;
+    updated: UTCDateTime;
+    sequence?: UnsignedInt;
+    method?: string;
+    title?: string;
+    description?: string;
+    descriptionContentType?: string;
+    showWithoutTime?: boolean;
+    locations?: Record<Id, Location>;
+    virtualLocations?: Record<Id, VirtualLocation>;
+    links?: Record<Id, Link>;
+    locale?: string;
+    keywords?: BooleanMap;
+    categories?: BooleanMap;
+    color?: string;
+    recurrenceId?: LocalDateTime;
+    recurrenceIdTimeZone?: TimeZoneId | null;
+    recurrenceRules?: RecurrenceRule[];
+    excludedRecurrenceRules?: RecurrenceRule[];
+    recurrenceOverrides?: Record<LocalDateTime, PatchObject>;
+    excluded?: boolean;
+    priority?: Int;
+    freeBusyStatus?: string;
+    privacy?: string;
+    replyTo?: Record<string, string>;
+    sentBy?: string;
+    participants?: Record<Id, Participant>;
+    requestStatus?: string;
+    useDefaultAlerts?: boolean;
+    alerts?: Record<Id, Alert>;
+    localizations?: Record<string, PatchObject>;
+    timeZone?: TimeZoneId | null;
+    timeZones?: Partial<Record<TimeZoneId, TimeZone>>;
+}
+export interface Event extends JSCalendarCommon {
+    "@type": "Event";
+    start: LocalDateTime;
+    duration?: Duration;
+    status?: string;
+}
+export interface Task extends JSCalendarCommon {
+    "@type": "Task";
+    due?: LocalDateTime;
+    start?: LocalDateTime;
+    estimatedDuration?: Duration;
+    percentComplete?: UnsignedInt;
+    progress?: string;
+    progressUpdated?: UTCDateTime;
+}
+export interface Group extends JSCalendarCommon {
+    "@type": "Group";
+    entries: Array<Event | Task>;
+    source?: string;
+}
+export type JSCalendarObject = Event | Task | Group;
+export type CalendarType = JSCalendarObject["@type"];
+export type CreateInput<TType extends CalendarType> = TType extends "Event" ? Omit<Event, "@type" | "uid" | "updated"> & {
+    type?: "Event" | "event";
+    "@type"?: "Event";
+    uid?: string;
+    updated?: UTCDateTime;
+} : TType extends "Task" ? Omit<Task, "@type" | "uid" | "updated"> & {
+    type?: "Task" | "task";
+    "@type"?: "Task";
+    uid?: string;
+    updated?: UTCDateTime;
+} : Omit<Group, "@type" | "uid" | "updated"> & {
+    type?: "Group" | "group";
+    "@type"?: "Group";
+    uid?: string;
+    updated?: UTCDateTime;
+};
+export type AnyCreateInput = CreateInput<"Event"> | CreateInput<"Task"> | CreateInput<"Group">;
+export type CalendarLike = JSCalendarObject | PatchObject | JsonValue;

package/dist/types.js

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

package/dist/utils.d.ts

@@ -0,0 +1,10 @@
+import type { Duration, UTCDateTime } from "./types.js";
+export declare function nowUtc(): UTCDateTime;
+export declare function deepClone<T>(value: T): T;
+export declare function isUtcDateTime(value: string): boolean;
+export declare function compareDateTime(a: string, b: string): number | null;
+export declare function durationToMilliseconds(duration: Duration): number | null;
+export declare function normalizeUtcDateTime(value: string): UTCDateTime;
+export declare function localDateTimeFromDate(value: Date): string;
+export declare function dateTimeInTimeZone(value: Date, timeZone: string): string;
+export declare function localDateTimeToUtcDate(value: string, timeZone: string): Date;

package/dist/utils.js

@@ -0,0 +1,80 @@
+import { format } from "date-fns";
+import { formatInTimeZone, fromZonedTime } from "date-fns-tz";
+export function nowUtc() {
+    return normalizeUtcDateTime(new Date().toISOString());
+}
+export function deepClone(value) {
+    if (typeof structuredClone === "function") {
+        return structuredClone(value);
+    }
+    throw new Error("structuredClone is not available in this environment");
+}
+export function isUtcDateTime(value) {
+    return /Z$/.test(value);
+}
+export function compareDateTime(a, b) {
+    const aUtc = isUtcDateTime(a);
+    const bUtc = isUtcDateTime(b);
+    if (aUtc && bUtc) {
+        const aMs = Date.parse(a);
+        const bMs = Date.parse(b);
+        if (Number.isNaN(aMs) || Number.isNaN(bMs))
+            return null;
+        return aMs === bMs ? 0 : aMs < bMs ? -1 : 1;
+    }
+    if (!aUtc && !bUtc) {
+        if (a === b)
+            return 0;
+        return a < b ? -1 : 1;
+    }
+    return null;
+}
+export function durationToMilliseconds(duration) {
+    const re = /^P(?:(\d+)W)?(?:(\d+)D)?(?:T(?:(\d+)H)?(?:(\d+)M)?(?:(\d+(?:\.\d+)?)S)?)?$/;
+    const match = re.exec(duration);
+    if (!match)
+        return null;
+    const weeks = Number(match[1] || 0);
+    const days = Number(match[2] || 0);
+    const hours = Number(match[3] || 0);
+    const minutes = Number(match[4] || 0);
+    const seconds = Number(match[5] || 0);
+    const totalSeconds = weeks * 7 * 24 * 60 * 60 +
+        days * 24 * 60 * 60 +
+        hours * 60 * 60 +
+        minutes * 60 +
+        seconds;
+    return totalSeconds * 1000;
+}
+export function normalizeUtcDateTime(value) {
+    const match = value.match(/^(.*)\.(\d+)Z$/);
+    if (!match)
+        return value;
+    const prefix = match[1] ?? value;
+    const fraction = match[2] ?? "";
+    const trimmed = fraction.replace(/0+$/, "");
+    if (trimmed.length === 0) {
+        return `${prefix}Z`;
+    }
+    return `${prefix}.${trimmed}Z`;
+}
+export function localDateTimeFromDate(value) {
+    return format(value, "yyyy-MM-dd'T'HH:mm:ss");
+}
+export function dateTimeInTimeZone(value, timeZone) {
+    return formatInTimeZone(value, timeZone, "yyyy-MM-dd'T'HH:mm:ss");
+}
+export function localDateTimeToUtcDate(value, timeZone) {
+    const match = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})/.exec(value);
+    if (!match) {
+        throw new Error(`Invalid LocalDateTime: ${value}`);
+    }
+    const year = Number(match[1]);
+    const month = Number(match[2]);
+    const day = Number(match[3]);
+    const hour = Number(match[4]);
+    const minute = Number(match[5]);
+    const second = Number(match[6]);
+    const local = new Date(year, month - 1, day, hour, minute, second);
+    return fromZonedTime(local, timeZone);
+}

package/dist/validate.d.ts

@@ -0,0 +1,6 @@
+import type { JSCalendarObject } from "./types.js";
+export declare class ValidationError extends Error {
+    path: string;
+    constructor(path: string, message: string);
+}
+export declare function validateJsCalendarObject(value: JSCalendarObject, path?: string): void;