@craftguild/jscalendar 0.5.2 → 0.5.4

package/dist/recurrence/date-utils.js

@@ -1,259 +0,0 @@
-import { FREQ_DAILY, FREQ_HOURLY, FREQ_MINUTELY, FREQ_MONTHLY, FREQ_WEEKLY, FREQ_YEARLY } from "./constants.js";
-/**
- * Advance a date-time by a recurrence interval.
- * @param start Anchor date-time.
- * @param frequency Recurrence frequency.
- * @param amount Number of intervals to add.
- * @param firstDay First day of week for weekly intervals.
- * @return Date-time moved to the next interval boundary.
- */
-export function addInterval(start, frequency, amount, firstDay) {
-    if (frequency === FREQ_YEARLY) {
-        return { year: start.year + amount, month: 1, day: 1, hour: 0, minute: 0, second: 0 };
-    }
-    if (frequency === FREQ_MONTHLY) {
-        const next = addMonths(start, amount);
-        return { year: next.year, month: next.month, day: 1, hour: 0, minute: 0, second: 0 };
-    }
-    if (frequency === FREQ_WEEKLY) {
-        const weekStart = startOfWeek(start, firstDay);
-        return addDays(weekStart, amount * 7);
-    }
-    if (frequency === FREQ_DAILY) {
-        return addDays(start, amount);
-    }
-    if (frequency === FREQ_HOURLY) {
-        return addHours(start, amount);
-    }
-    if (frequency === FREQ_MINUTELY) {
-        return addMinutes(start, amount);
-    }
-    return addSeconds(start, amount);
-}
-/**
- * Parse local date time into structured data.
- * @param value LocalDateTime string.
- * @return Parsed date-time parts.
- */
-export function parseLocalDateTime(value) {
-    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}`);
-    }
-    return {
-        year: Number(match[1]),
-        month: Number(match[2]),
-        day: Number(match[3]),
-        hour: Number(match[4]),
-        minute: Number(match[5]),
-        second: Number(match[6]),
-    };
-}
-/**
- * Format local date time as string.
- * @param dt Date-time parts.
- * @return LocalDateTime string.
- */
-export function formatLocalDateTime(dt) {
-    return `${pad(dt.year, 4)}-${pad(dt.month, 2)}-${pad(dt.day, 2)}T${pad(dt.hour, 2)}:${pad(dt.minute, 2)}:${pad(dt.second, 2)}`;
-}
-/**
- * Pad a numeric value with leading zeros.
- * @param value Number to pad.
- * @param length Total length.
- * @return Zero-padded string.
- */
-export function pad(value, length) {
-    return value.toString().padStart(length, "0");
-}
-/**
- * Add days to the target.
- * @param dt Date-time parts.
- * @param days Days to add.
- * @return New date-time with days added.
- */
-export function addDays(dt, days) {
-    const ms = Date.UTC(dt.year, dt.month - 1, dt.day, dt.hour, dt.minute, dt.second) + days * 86400 * 1000;
-    const d = new Date(ms);
-    return {
-        year: d.getUTCFullYear(),
-        month: d.getUTCMonth() + 1,
-        day: d.getUTCDate(),
-        hour: dt.hour,
-        minute: dt.minute,
-        second: dt.second,
-    };
-}
-/**
- * Add hours to the target.
- * @param dt Date-time parts.
- * @param hours Hours to add.
- * @return New date-time with hours added.
- */
-export function addHours(dt, hours) {
-    const ms = Date.UTC(dt.year, dt.month - 1, dt.day, dt.hour, dt.minute, dt.second) + hours * 3600 * 1000;
-    const d = new Date(ms);
-    return {
-        year: d.getUTCFullYear(),
-        month: d.getUTCMonth() + 1,
-        day: d.getUTCDate(),
-        hour: d.getUTCHours(),
-        minute: d.getUTCMinutes(),
-        second: d.getUTCSeconds(),
-    };
-}
-/**
- * Add minutes to the target.
- * @param dt Date-time parts.
- * @param minutes Minutes to add.
- * @return New date-time with minutes added.
- */
-export function addMinutes(dt, minutes) {
-    return addSeconds(dt, minutes * 60);
-}
-/**
- * Add seconds to the target.
- * @param dt Date-time parts.
- * @param seconds Seconds to add.
- * @return New date-time with seconds added.
- */
-export function addSeconds(dt, seconds) {
-    const ms = Date.UTC(dt.year, dt.month - 1, dt.day, dt.hour, dt.minute, dt.second) + seconds * 1000;
-    const d = new Date(ms);
-    return {
-        year: d.getUTCFullYear(),
-        month: d.getUTCMonth() + 1,
-        day: d.getUTCDate(),
-        hour: d.getUTCHours(),
-        minute: d.getUTCMinutes(),
-        second: d.getUTCSeconds(),
-    };
-}
-/**
- * Add months to the target.
- * @param dt Date-time parts.
- * @param months Months to add.
- * @return New date-time with months added.
- */
-export function addMonths(dt, months) {
-    const total = (dt.year * 12 + (dt.month - 1)) + months;
-    const year = Math.floor(total / 12);
-    const month = (total % 12) + 1;
-    const day = Math.min(dt.day, daysInMonth(year, month));
-    return { year, month, day, hour: dt.hour, minute: dt.minute, second: dt.second };
-}
-/**
- * Get day of week for a date-time.
- * @param dt Date-time parts.
- * @return Two-letter weekday code.
- */
-export function dayOfWeek(dt) {
-    const d = new Date(Date.UTC(dt.year, dt.month - 1, dt.day));
-    const idx = d.getUTCDay();
-    if (idx === 0)
-        return "su";
-    if (idx === 1)
-        return "mo";
-    if (idx === 2)
-        return "tu";
-    if (idx === 3)
-        return "we";
-    if (idx === 4)
-        return "th";
-    if (idx === 5)
-        return "fr";
-    return "sa";
-}
-/**
- * Get day of year for a date-time.
- * @param dt Date-time parts.
- * @return Day of year (1-366).
- */
-export function dayOfYear(dt) {
-    const start = Date.UTC(dt.year, 0, 1);
-    const current = Date.UTC(dt.year, dt.month - 1, dt.day);
-    return Math.floor((current - start) / (24 * 3600 * 1000)) + 1;
-}
-/**
- * Get number of days in a month.
- * @param year Year number.
- * @param month Month number (1-12).
- * @return Days in the month.
- */
-export function daysInMonth(year, month) {
-    return new Date(Date.UTC(year, month, 0)).getUTCDate();
-}
-/**
- * Get number of days in a year.
- * @param year Year number.
- * @return Days in the year.
- */
-export function daysInYear(year) {
-    return new Date(Date.UTC(year + 1, 0, 0)).getUTCDate();
-}
-/**
- * Get the start of week for a date-time.
- * @param dt Date-time parts.
- * @param firstDay Weekday that starts the week.
- * @return Date-time at the start of the week.
- */
-export function startOfWeek(dt, firstDay) {
-    const order = ["mo", "tu", "we", "th", "fr", "sa", "su"];
-    const dow = dayOfWeek(dt);
-    const offset = (order.indexOf(dow) - order.indexOf(firstDay) + 7) % 7;
-    return addDays(dt, -offset);
-}
-/**
- * Get ISO-like week number for a date-time.
- * @param dt Date-time parts.
- * @param firstDay Weekday that starts the week.
- * @return Week number for the given date.
- */
-export function weekNumber(dt, firstDay) {
-    const yearStart = { year: dt.year, month: 1, day: 1, hour: 0, minute: 0, second: 0 };
-    const weekStart = startOfWeek(yearStart, firstDay);
-    const daysBeforeYear = daysBetween(weekStart, yearStart);
-    const daysInFirstWeek = 7 - daysBeforeYear;
-    const week1Start = daysInFirstWeek >= 4 ? weekStart : addDays(weekStart, 7);
-    if (compareDate(dt, week1Start) < 0) {
-        return totalWeeksInYear(dt.year - 1, firstDay);
-    }
-    const diff = daysBetween(week1Start, dt);
-    return Math.floor(diff / 7) + 1;
-}
-/**
- * Get total weeks in a year.
- * @param year Year number.
- * @param firstDay Weekday that starts the week.
- * @return Total number of weeks in the year.
- */
-export function totalWeeksInYear(year, firstDay) {
-    const lastDay = { year, month: 12, day: 31, hour: 0, minute: 0, second: 0 };
-    return weekNumber(lastDay, firstDay);
-}
-/**
- * Get whole-day difference between two dates.
- * @param a Start date.
- * @param b End date.
- * @return Whole-day difference (b - a).
- */
-export function daysBetween(a, b) {
-    const msA = Date.UTC(a.year, a.month - 1, a.day);
-    const msB = Date.UTC(b.year, b.month - 1, b.day);
-    return Math.floor((msB - msA) / (24 * 3600 * 1000));
-}
-/**
- * Compare two dates without time.
- * @param a First date.
- * @param b Second date.
- * @return Negative/zero/positive comparison result.
- */
-export function compareDate(a, b) {
-    if (a.year !== b.year)
-        return a.year - b.year;
-    if (a.month !== b.month)
-        return a.month - b.month;
-    if (a.day !== b.day)
-        return a.day - b.day;
-    return 0;
-}

package/dist/recurrence/expand.d.ts

@@ -1,23 +0,0 @@
-import type { JSCalendarObject } from "../types.js";
-import type { RecurrenceRange } from "./types.js";
-/**
- * Expand recurrence into occurrences sorted by recurrenceId/start.
- * @param items JSCalendar objects to expand.
- * @param range Date range bounds.
- * @return Generator of expanded occurrences.
- */
-export declare function expandRecurrence(items: JSCalendarObject[], range: RecurrenceRange): Generator<JSCalendarObject>;
-/**
- * Expand recurrence paged into occurrences.
- * @param items JSCalendar objects to expand.
- * @param range Date range bounds.
- * @param options Pagination options.
- * @return Page of expanded items plus an optional next cursor.
- */
-export declare function expandRecurrencePaged(items: JSCalendarObject[], range: RecurrenceRange, options: {
-    limit: number;
-    cursor?: string;
-}): {
-    items: JSCalendarObject[];
-    nextCursor?: string;
-};

package/dist/recurrence/expand.js

@@ -1,315 +0,0 @@
-import { applyPatch } from "../patch.js";
-import { dateTimeInTimeZone, localDateTimeFromDate, localDateTimeToUtcDate } from "../utils.js";
-import { TYPE_EVENT, TYPE_TASK } from "./constants.js";
-import { expandRule } from "./rules.js";
-/**
- * Expand recurrence into occurrences sorted by recurrenceId/start.
- * @param items JSCalendar objects to expand.
- * @param range Date range bounds.
- * @return Generator of expanded occurrences.
- */
-export function* expandRecurrence(items, range) {
-    const occurrences = [];
-    let index = 0;
-    for (const item of items) {
-        if (item["@type"] === TYPE_EVENT) {
-            for (const occurrence of expandEvent(item, range)) {
-                occurrences.push({ value: occurrence, key: occurrenceKey(occurrence), index });
-                index += 1;
-            }
-            continue;
-        }
-        if (item["@type"] === TYPE_TASK) {
-            for (const occurrence of expandTask(item, range)) {
-                occurrences.push({ value: occurrence, key: occurrenceKey(occurrence), index });
-                index += 1;
-            }
-            continue;
-        }
-        occurrences.push({ value: item, key: occurrenceKey(item), index });
-        index += 1;
-    }
-    occurrences.sort((a, b) => {
-        if (a.key && b.key)
-            return a.key.localeCompare(b.key);
-        if (a.key)
-            return -1;
-        if (b.key)
-            return 1;
-        return a.index - b.index;
-    });
-    for (const occurrence of occurrences) {
-        yield occurrence.value;
-    }
-}
-/**
- * Expand recurrence paged into occurrences.
- * @param items JSCalendar objects to expand.
- * @param range Date range bounds.
- * @param options Pagination options.
- * @return Page of expanded items plus an optional next cursor.
- */
-export function expandRecurrencePaged(items, range, options) {
-    const result = [];
-    let nextCursor;
-    for (const occurrence of expandRecurrence(items, range)) {
-        const key = occurrenceKey(occurrence);
-        if (options.cursor && key) {
-            if (key <= options.cursor) {
-                continue;
-            }
-        }
-        else if (options.cursor && !key) {
-            continue;
-        }
-        result.push(occurrence);
-        if (key) {
-            nextCursor = key;
-        }
-        if (result.length >= options.limit) {
-            break;
-        }
-    }
-    return { items: result, nextCursor };
-}
-/**
- * Expand event into occurrences.
- * @param event Event to expand.
- * @param range Date range bounds.
- * @return Generator of expanded occurrences.
- */
-function expandEvent(event, range) {
-    return expandObject(event, range, event.start, event.recurrenceRules, event.excludedRecurrenceRules, event.recurrenceOverrides, event.timeZone ?? null);
-}
-/**
- * Expand task into occurrences.
- * @param task Task to expand.
- * @param range Date range bounds.
- * @return Generator of expanded occurrences.
- */
-function expandTask(task, range) {
-    const anchor = task.start ?? task.due;
-    if (!anchor) {
-        return (function* empty() { })();
-    }
-    return expandObject(task, range, anchor, task.recurrenceRules, task.excludedRecurrenceRules, task.recurrenceOverrides, task.timeZone ?? null);
-}
-/**
- * Build a stable ordering key for an occurrence.
- * @param value Occurrence object.
- * @return Sort key or undefined when not available.
- */
-function occurrenceKey(value) {
-    if (value.recurrenceId)
-        return value.recurrenceId;
-    if (value["@type"] === TYPE_EVENT)
-        return value.start;
-    if (value["@type"] === TYPE_TASK)
-        return value.start ?? value.due;
-    return undefined;
-}
-/**
- * Expand object into occurrences.
- * @param base Base JSCalendar object.
- * @param range Date range bounds.
- * @param anchor Anchor LocalDateTime for the series.
- * @param rules Inclusion recurrence rules.
- * @param excludedRules Exclusion recurrence rules.
- * @param overrides Recurrence overrides keyed by LocalDateTime.
- * @param recurrenceIdTimeZone Optional time zone for recurrence IDs.
- * @return Generator of expanded occurrences.
- */
-function* expandObject(base, range, anchor, rules, excludedRules, overrides, recurrenceIdTimeZone) {
-    const hasZone = Boolean(recurrenceIdTimeZone);
-    const fromLocal = hasZone && recurrenceIdTimeZone
-        ? dateTimeInTimeZone(range.from, recurrenceIdTimeZone)
-        : localDateTimeFromDate(range.from);
-    const toLocal = hasZone && recurrenceIdTimeZone
-        ? dateTimeInTimeZone(range.to, recurrenceIdTimeZone)
-        : localDateTimeFromDate(range.to);
-    const fromDate = range.from;
-    const toDate = range.to;
-    const overrideKeys = overrides ? Object.keys(overrides) : [];
-    if (!rules || rules.length === 0) {
-        if (hasZone && recurrenceIdTimeZone) {
-            if (isInRangeWithZone(anchor, fromDate, toDate, recurrenceIdTimeZone)) {
-                yield base;
-            }
-        }
-        else if (isInRange(anchor, fromLocal, toLocal)) {
-            yield base;
-        }
-        for (const key of overrideKeys) {
-            const patch = overrides ? overrides[key] : undefined;
-            const instance = buildInstance(base, key, recurrenceIdTimeZone, patch);
-            if (!instance)
-                continue;
-            if (hasZone && recurrenceIdTimeZone) {
-                if (isInRangeWithZone(key, fromDate, toDate, recurrenceIdTimeZone)) {
-                    yield instance;
-                }
-            }
-            else if (isInRange(key, fromLocal, toLocal)) {
-                yield instance;
-            }
-        }
-        return;
-    }
-    const occurrences = [];
-    for (const rule of rules) {
-        const expanded = expandRule(anchor, rule, fromLocal, toLocal, true, recurrenceIdTimeZone ?? undefined, fromDate, toDate);
-        occurrences.push(...expanded);
-    }
-    const excluded = new Set();
-    if (excludedRules && excludedRules.length > 0) {
-        for (const rule of excludedRules) {
-            const expanded = expandRule(anchor, rule, fromLocal, toLocal, true, recurrenceIdTimeZone ?? undefined, fromDate, toDate);
-            for (const value of expanded) {
-                excluded.add(value);
-            }
-        }
-    }
-    if (!occurrences.includes(anchor)) {
-        occurrences.push(anchor);
-    }
-    for (const key of overrideKeys) {
-        if (!occurrences.includes(key)) {
-            occurrences.push(key);
-        }
-    }
-    let sorted = Array.from(new Set(occurrences)).sort((a, b) => compareLocal(a, b, recurrenceIdTimeZone ?? undefined));
-    if (rules[0]?.count && sorted.length > rules[0].count) {
-        sorted = sorted.slice(0, rules[0].count);
-    }
-    for (const dt of sorted) {
-        if (excluded.has(dt))
-            continue;
-        const patch = overrides ? overrides[dt] : undefined;
-        const instance = buildInstance(base, dt, recurrenceIdTimeZone, patch);
-        if (!instance)
-            continue;
-        if (hasZone && recurrenceIdTimeZone) {
-            if (isInRangeWithZone(dt, fromDate, toDate, recurrenceIdTimeZone)) {
-                yield instance;
-            }
-        }
-        else if (isInRange(dt, fromLocal, toLocal)) {
-            yield instance;
-        }
-    }
-}
-/**
- * Build an occurrence instance from a base object plus override patch.
- * @param base Base JSCalendar object.
- * @param recurrenceId LocalDateTime recurrence id.
- * @param recurrenceIdTimeZone Optional time zone for recurrence id.
- * @param patch Override patch for the occurrence.
- * @return Occurrence instance or null if excluded.
- */
-function buildInstance(base, recurrenceId, recurrenceIdTimeZone, patch) {
-    const patched = patch ? applyPatch(base, patch) : base;
-    if (isExcludedInstance(patched)) {
-        return null;
-    }
-    const overridesStart = patchHasKey(patch, "start");
-    const overridesDue = patchHasKey(patch, "due");
-    let shifted;
-    if (patched["@type"] === TYPE_EVENT) {
-        shifted = overridesStart ? patched : { ...patched, start: recurrenceId };
-    }
-    else if (patched["@type"] === TYPE_TASK) {
-        if (patched.start) {
-            shifted = overridesStart ? patched : { ...patched, start: recurrenceId };
-        }
-        else if (patched.due) {
-            shifted = overridesDue ? patched : { ...patched, due: recurrenceId };
-        }
-        else {
-            shifted = patched;
-        }
-    }
-    else {
-        shifted = patched;
-    }
-    const instance = {
-        ...stripRecurrenceProperties(shifted),
-        recurrenceId,
-    };
-    if (recurrenceIdTimeZone) {
-        instance.recurrenceIdTimeZone = recurrenceIdTimeZone;
-    }
-    return instance;
-}
-/**
- * Check if a patch contains a key or pointer.
- * @param patch Patch object to inspect.
- * @param key Field name to look up.
- * @return True when the patch modifies the field.
- */
-function patchHasKey(patch, key) {
-    if (!patch)
-        return false;
-    if (Object.prototype.hasOwnProperty.call(patch, key))
-        return true;
-    if (Object.prototype.hasOwnProperty.call(patch, `/${key}`))
-        return true;
-    return false;
-}
-/**
- * Strip recurrence properties from value.
- * @param object JSCalendar object to clean.
- * @return Object without recurrence rule fields.
- */
-function stripRecurrenceProperties(object) {
-    const { recurrenceRules: _recurrenceRules, excludedRecurrenceRules: _excludedRecurrenceRules, recurrenceOverrides: _recurrenceOverrides, ...rest } = object;
-    return rest;
-}
-/**
- * Check whether value is excluded instance.
- * @param object JSCalendar object.
- * @return True when the occurrence is excluded.
- */
-function isExcludedInstance(object) {
-    return object.excluded === true;
-}
-/**
- * Check whether value is in range.
- * @param value LocalDateTime string.
- * @param from LocalDateTime lower bound.
- * @param to LocalDateTime upper bound.
- * @return True when value is within the range.
- */
-function isInRange(value, from, to) {
-    return value >= from && value <= to;
-}
-/**
- * Check whether value is in range with zone.
- * @param value LocalDateTime string.
- * @param from Date lower bound.
- * @param to Date upper bound.
- * @param timeZone Time zone for LocalDateTime conversion.
- * @return True when value is within the range.
- */
-function isInRangeWithZone(value, from, to, timeZone) {
-    const utc = localDateTimeToUtcDate(value, timeZone);
-    return utc >= from && utc <= to;
-}
-/**
- * Compare local date-time strings, optionally using a time zone.
- * @param a LocalDateTime string A.
- * @param b LocalDateTime string B.
- * @param timeZone Optional time zone for comparison.
- * @return Negative/zero/positive comparison result.
- */
-function compareLocal(a, b, timeZone) {
-    if (!timeZone) {
-        if (a === b)
-            return 0;
-        return a < b ? -1 : 1;
-    }
-    const aUtc = localDateTimeToUtcDate(a, timeZone).getTime();
-    const bUtc = localDateTimeToUtcDate(b, timeZone).getTime();
-    if (aUtc === bUtc)
-        return 0;
-    return aUtc < bUtc ? -1 : 1;
-}

package/dist/recurrence/rule-candidates.d.ts

@@ -1,21 +0,0 @@
-import type { RecurrenceRule } from "../types.js";
-import type { DateCandidate, DateTime, DayOfWeek } from "./types.js";
-/**
- * Build candidate dates for the current recurrence period.
- * @param periodStart Start of the current recurrence period.
- * @param rule Normalized recurrence rule.
- * @param firstDay First day of the week for weekly calculations.
- * @param skip Skip policy for invalid month days.
- * @return Candidate dates for further filtering.
- */
-export declare function generateDateCandidates(periodStart: DateTime, rule: RecurrenceRule, firstDay: DayOfWeek, skip: string): DateCandidate[];
-/**
- * Apply BY* filters and skip behavior to candidate dates.
- * @param candidates Candidate dates for the period.
- * @param rule Normalized recurrence rule.
- * @param periodStart Start of the current recurrence period.
- * @param firstDay First day of the week for weekly calculations.
- * @param skip Skip policy for invalid month days.
- * @return Filtered candidate dates.
- */
-export declare function filterDateCandidates(candidates: DateCandidate[], rule: RecurrenceRule, periodStart: DateTime, firstDay: DayOfWeek, skip: string): DateCandidate[];