@craftguild/jscalendar 0.5.3 → 0.5.5

package/dist/recurrence/rule-candidates.js

@@ -1,120 +0,0 @@
-import { FREQ_DAILY, FREQ_HOURLY, FREQ_MINUTELY, FREQ_MONTHLY, FREQ_SECONDLY, FREQ_WEEKLY, FREQ_YEARLY, SKIP_BACKWARD, SKIP_FORWARD, SKIP_OMIT } from "./constants.js";
-import { addDays, addMonths, daysInMonth, pad } from "./date-utils.js";
-import { matchesByDay, matchesByMonthDay, matchesByWeekNo, matchesByYearDay } from "./rule-matchers.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 function generateDateCandidates(periodStart, rule, firstDay, skip) {
-    const result = [];
-    const wantsInvalid = skip !== SKIP_OMIT && rule.byMonthDay && rule.byMonthDay.length > 0;
-    if (rule.frequency === FREQ_YEARLY) {
-        for (let month = 1; month <= 12; month += 1) {
-            const maxDays = wantsInvalid ? 31 : daysInMonth(periodStart.year, month);
-            for (let day = 1; day <= maxDays; day += 1) {
-                const valid = day <= daysInMonth(periodStart.year, month);
-                result.push({ year: periodStart.year, month, day, valid });
-            }
-        }
-        return result;
-    }
-    if (rule.frequency === FREQ_MONTHLY) {
-        const maxDays = wantsInvalid ? 31 : daysInMonth(periodStart.year, periodStart.month);
-        for (let day = 1; day <= maxDays; day += 1) {
-            const valid = day <= daysInMonth(periodStart.year, periodStart.month);
-            result.push({ year: periodStart.year, month: periodStart.month, day, valid });
-        }
-        return result;
-    }
-    if (rule.frequency === FREQ_WEEKLY) {
-        let cursor = periodStart;
-        for (let i = 0; i < 7; i += 1) {
-            result.push({ year: cursor.year, month: cursor.month, day: cursor.day, valid: true });
-            cursor = addDays(cursor, 1);
-        }
-        return result;
-    }
-    if (rule.frequency === FREQ_DAILY) {
-        result.push({ year: periodStart.year, month: periodStart.month, day: periodStart.day, valid: true });
-        return result;
-    }
-    if (rule.frequency === FREQ_HOURLY || rule.frequency === FREQ_MINUTELY || rule.frequency === FREQ_SECONDLY) {
-        result.push({ year: periodStart.year, month: periodStart.month, day: periodStart.day, valid: true });
-        return result;
-    }
-    return result;
-}
-/**
- * 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 function filterDateCandidates(candidates, rule, periodStart, firstDay, skip) {
-    let result = candidates;
-    if (rule.byMonth && rule.byMonth.length > 0) {
-        const months = rule.byMonth.map((m) => parseInt(m, 10)).filter((m) => !Number.isNaN(m));
-        result = result.filter((d) => months.includes(d.month));
-    }
-    if (rule.byWeekNo && rule.byWeekNo.length > 0) {
-        const byWeekNo = rule.byWeekNo.filter((d) => d !== 0);
-        result = result.filter((d) => d.valid && matchesByWeekNo(d, byWeekNo, firstDay));
-    }
-    if (rule.byYearDay && rule.byYearDay.length > 0) {
-        const byYearDay = rule.byYearDay.filter((d) => d !== 0);
-        result = result.filter((d) => d.valid && matchesByYearDay(d, byYearDay));
-    }
-    if (rule.byMonthDay && rule.byMonthDay.length > 0) {
-        const byMonthDay = rule.byMonthDay.filter((d) => d !== 0);
-        result = result.filter((d) => matchesByMonthDay(d, byMonthDay));
-    }
-    const byDay = rule.byDay;
-    if (byDay && byDay.length > 0) {
-        result = result.filter((d) => matchesByDay(d, byDay, rule.frequency, periodStart, firstDay));
-    }
-    if (skip !== SKIP_OMIT && rule.byMonthDay && rule.byMonthDay.length > 0) {
-        result = adjustInvalidMonthDays(result, skip);
-    }
-    else {
-        result = result.filter((d) => d.valid);
-    }
-    return result;
-}
-/**
- * Shift invalid month-day candidates using the skip policy.
- * @param candidates Candidate dates that may include invalid month days.
- * @param skip Skip policy for invalid month days.
- * @return Candidates with invalid days adjusted or removed.
- */
-function adjustInvalidMonthDays(candidates, skip) {
-    const adjusted = [];
-    for (const candidate of candidates) {
-        if (candidate.valid) {
-            adjusted.push(candidate);
-            continue;
-        }
-        if (skip === SKIP_FORWARD) {
-            const next = addMonths({ year: candidate.year, month: candidate.month, day: 1, hour: 0, minute: 0, second: 0 }, 1);
-            adjusted.push({ year: next.year, month: next.month, day: 1, valid: true });
-        }
-        else if (skip === SKIP_BACKWARD) {
-            const day = daysInMonth(candidate.year, candidate.month);
-            adjusted.push({ year: candidate.year, month: candidate.month, day, valid: true });
-        }
-    }
-    const deduped = new Map();
-    for (const candidate of adjusted) {
-        const key = `${pad(candidate.year, 4)}-${pad(candidate.month, 2)}-${pad(candidate.day, 2)}`;
-        if (!deduped.has(key)) {
-            deduped.set(key, candidate);
-        }
-    }
-    return Array.from(deduped.values());
-}

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

@@ -1,11 +0,0 @@
-import type { RecurrenceRule } from "../types.js";
-import type { DateTime, DayOfWeek } from "./types.js";
-/**
- * Generate date-time strings for the current period using rule filters.
- * @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 Date-time strings for this period.
- */
-export declare function generateDateTimes(periodStart: DateTime, rule: RecurrenceRule, firstDay: DayOfWeek, skip: string): string[];

package/dist/recurrence/rule-generate.js

@@ -1,36 +0,0 @@
-import { formatLocalDateTime } from "./date-utils.js";
-import { filterDateCandidates, generateDateCandidates } from "./rule-candidates.js";
-/**
- * Generate date-time strings for the current period using rule filters.
- * @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 Date-time strings for this period.
- */
-export function generateDateTimes(periodStart, rule, firstDay, skip) {
-    const dateCandidates = generateDateCandidates(periodStart, rule, firstDay, skip);
-    const filteredDates = filterDateCandidates(dateCandidates, rule, periodStart, firstDay, skip);
-    const hours = rule.byHour && rule.byHour.length > 0 ? rule.byHour : [periodStart.hour];
-    const minutes = rule.byMinute && rule.byMinute.length > 0 ? rule.byMinute : [periodStart.minute];
-    const seconds = rule.bySecond && rule.bySecond.length > 0 ? rule.bySecond : [periodStart.second];
-    const result = [];
-    for (const date of filteredDates) {
-        for (const hour of hours) {
-            for (const minute of minutes) {
-                for (const second of seconds) {
-                    const dt = formatLocalDateTime({
-                        year: date.year,
-                        month: date.month,
-                        day: date.day,
-                        hour,
-                        minute,
-                        second,
-                    });
-                    result.push(dt);
-                }
-            }
-        }
-    }
-    return result;
-}

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

@@ -1,34 +0,0 @@
-import type { NDay, RecurrenceRule } from "../types.js";
-import type { DateCandidate, DateTime, DayOfWeek } from "./types.js";
-/**
- * Check whether a candidate date matches BYMONTHDAY values.
- * @param date Candidate date.
- * @param byMonthDay BYMONTHDAY values (positive or negative).
- * @return True when the candidate date matches any BYMONTHDAY value.
- */
-export declare function matchesByMonthDay(date: DateCandidate, byMonthDay: number[]): boolean;
-/**
- * Check whether a candidate date matches BYYEARDAY values.
- * @param date Candidate date.
- * @param byYearDay BYYEARDAY values (positive or negative).
- * @return True when the candidate date matches any BYYEARDAY value.
- */
-export declare function matchesByYearDay(date: DateCandidate, byYearDay: number[]): boolean;
-/**
- * Check whether a candidate date matches BYWEEKNO values.
- * @param date Candidate date.
- * @param byWeekNo BYWEEKNO values (positive or negative).
- * @param firstDay First day of the week for week number calculations.
- * @return True when the candidate date matches any BYWEEKNO value.
- */
-export declare function matchesByWeekNo(date: DateCandidate, byWeekNo: number[], firstDay: DayOfWeek): boolean;
-/**
- * Check whether a candidate date matches BYDAY rules.
- * @param date Candidate date.
- * @param byDay BYDAY rules (with optional nth-of-period entries).
- * @param frequency Rule frequency.
- * @param periodStart Start of the current recurrence period.
- * @param firstDay First day of the week for weekly calculations.
- * @return True when the candidate date matches any BYDAY rule.
- */
-export declare function matchesByDay(date: DateCandidate, byDay: NDay[], frequency: RecurrenceRule["frequency"], periodStart: DateTime, firstDay: DayOfWeek): boolean;

package/dist/recurrence/rule-matchers.js

@@ -1,120 +0,0 @@
-import { FREQ_MONTHLY, FREQ_YEARLY } from "./constants.js";
-import { addDays, dayOfWeek, dayOfYear, daysInMonth, daysInYear, totalWeeksInYear, weekNumber } from "./date-utils.js";
-/**
- * Check whether a candidate date matches BYMONTHDAY values.
- * @param date Candidate date.
- * @param byMonthDay BYMONTHDAY values (positive or negative).
- * @return True when the candidate date matches any BYMONTHDAY value.
- */
-export function matchesByMonthDay(date, byMonthDay) {
-    const dim = daysInMonth(date.year, date.month);
-    for (const v of byMonthDay) {
-        if (v > 0 && date.day === v)
-            return true;
-        if (v < 0 && date.day === dim + v + 1)
-            return true;
-    }
-    return false;
-}
-/**
- * Check whether a candidate date matches BYYEARDAY values.
- * @param date Candidate date.
- * @param byYearDay BYYEARDAY values (positive or negative).
- * @return True when the candidate date matches any BYYEARDAY value.
- */
-export function matchesByYearDay(date, byYearDay) {
-    const diy = daysInYear(date.year);
-    const doy = dayOfYear({ year: date.year, month: date.month, day: date.day, hour: 0, minute: 0, second: 0 });
-    for (const v of byYearDay) {
-        if (v > 0 && doy === v)
-            return true;
-        if (v < 0 && doy === diy + v + 1)
-            return true;
-    }
-    return false;
-}
-/**
- * Check whether a candidate date matches BYWEEKNO values.
- * @param date Candidate date.
- * @param byWeekNo BYWEEKNO values (positive or negative).
- * @param firstDay First day of the week for week number calculations.
- * @return True when the candidate date matches any BYWEEKNO value.
- */
-export function matchesByWeekNo(date, byWeekNo, firstDay) {
-    const week = weekNumber({ year: date.year, month: date.month, day: date.day, hour: 0, minute: 0, second: 0 }, firstDay);
-    const total = totalWeeksInYear(date.year, firstDay);
-    for (const v of byWeekNo) {
-        if (v > 0 && week === v)
-            return true;
-        if (v < 0 && week === total + v + 1)
-            return true;
-    }
-    return false;
-}
-/**
- * Check whether a candidate date matches BYDAY rules.
- * @param date Candidate date.
- * @param byDay BYDAY rules (with optional nth-of-period entries).
- * @param frequency Rule frequency.
- * @param periodStart Start of the current recurrence period.
- * @param firstDay First day of the week for weekly calculations.
- * @return True when the candidate date matches any BYDAY rule.
- */
-export function matchesByDay(date, byDay, frequency, periodStart, firstDay) {
-    const weekday = dayOfWeek({ year: date.year, month: date.month, day: date.day, hour: 0, minute: 0, second: 0 });
-    for (const entry of byDay) {
-        if (entry.nthOfPeriod === undefined) {
-            if (entry.day === weekday)
-                return true;
-            continue;
-        }
-        if (frequency !== FREQ_MONTHLY && frequency !== FREQ_YEARLY) {
-            continue;
-        }
-        const matches = listNthPeriodDates(date, frequency, periodStart, firstDay)
-            .filter((d) => dayOfWeek(d) === entry.day);
-        const index = entry.nthOfPeriod > 0 ? entry.nthOfPeriod - 1 : matches.length + entry.nthOfPeriod;
-        if (index >= 0 && index < matches.length) {
-            const target = matches[index];
-            if (target && target.year === date.year && target.month === date.month && target.day === date.day) {
-                return true;
-            }
-        }
-    }
-    return false;
-}
-/**
- * List dates in the current period for nth-of-period matching.
- * @param date Candidate date (year/month used for period selection).
- * @param frequency Rule frequency.
- * @param periodStart Start of the current recurrence period.
- * @param firstDay First day of the week for weekly calculations.
- * @return Date list used to resolve nth-of-period BYDAY entries.
- */
-function listNthPeriodDates(date, frequency, periodStart, firstDay) {
-    if (frequency === FREQ_YEARLY) {
-        const result = [];
-        for (let month = 1; month <= 12; month += 1) {
-            const days = daysInMonth(date.year, month);
-            for (let day = 1; day <= days; day += 1) {
-                result.push({ year: date.year, month, day, hour: 0, minute: 0, second: 0 });
-            }
-        }
-        return result;
-    }
-    if (frequency === FREQ_MONTHLY) {
-        const result = [];
-        const days = daysInMonth(date.year, date.month);
-        for (let day = 1; day <= days; day += 1) {
-            result.push({ year: date.year, month: date.month, day, hour: 0, minute: 0, second: 0 });
-        }
-        return result;
-    }
-    const result = [];
-    let cursor = periodStart;
-    for (let i = 0; i < 7; i += 1) {
-        result.push({ year: cursor.year, month: cursor.month, day: cursor.day, hour: 0, minute: 0, second: 0 });
-        cursor = addDays(cursor, 1);
-    }
-    return result;
-}

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

@@ -1,9 +0,0 @@
-import type { RecurrenceRule } from "../types.js";
-import type { DateTime } from "./types.js";
-/**
- * Normalize rule fields by copying arrays and filling defaults from the start date-time.
- * @param rule Recurrence rule to normalize.
- * @param start Anchor date-time that supplies default by* values.
- * @return Normalized recurrence rule with default by* fields filled.
- */
-export declare function normalizeRule(rule: RecurrenceRule, start: DateTime): RecurrenceRule;

package/dist/recurrence/rule-normalize.js

@@ -1,57 +0,0 @@
-import { FREQ_HOURLY, FREQ_MINUTELY, FREQ_MONTHLY, FREQ_SECONDLY, FREQ_WEEKLY, FREQ_YEARLY } from "./constants.js";
-import { dayOfWeek } from "./date-utils.js";
-/**
- * Normalize rule fields by copying arrays and filling defaults from the start date-time.
- * @param rule Recurrence rule to normalize.
- * @param start Anchor date-time that supplies default by* values.
- * @return Normalized recurrence rule with default by* fields filled.
- */
-export function normalizeRule(rule, start) {
-    const normalized = {
-        ...rule,
-        bySecond: rule.bySecond ? [...rule.bySecond] : undefined,
-        byMinute: rule.byMinute ? [...rule.byMinute] : undefined,
-        byHour: rule.byHour ? [...rule.byHour] : undefined,
-        byDay: rule.byDay ? [...rule.byDay] : undefined,
-        byMonthDay: rule.byMonthDay ? [...rule.byMonthDay] : undefined,
-        byMonth: rule.byMonth ? [...rule.byMonth] : undefined,
-        byYearDay: rule.byYearDay ? [...rule.byYearDay] : undefined,
-        byWeekNo: rule.byWeekNo ? [...rule.byWeekNo] : undefined,
-        bySetPosition: rule.bySetPosition ? [...rule.bySetPosition] : undefined,
-    };
-    if (normalized.frequency !== FREQ_SECONDLY && (!normalized.bySecond || normalized.bySecond.length === 0)) {
-        normalized.bySecond = [start.second];
-    }
-    if (normalized.frequency !== FREQ_SECONDLY && normalized.frequency !== FREQ_MINUTELY &&
-        (!normalized.byMinute || normalized.byMinute.length === 0)) {
-        normalized.byMinute = [start.minute];
-    }
-    if (normalized.frequency !== FREQ_SECONDLY && normalized.frequency !== FREQ_MINUTELY &&
-        normalized.frequency !== FREQ_HOURLY &&
-        (!normalized.byHour || normalized.byHour.length === 0)) {
-        normalized.byHour = [start.hour];
-    }
-    if (normalized.frequency === FREQ_WEEKLY && (!normalized.byDay || normalized.byDay.length === 0)) {
-        normalized.byDay = [{ "@type": "NDay", day: dayOfWeek(start) }];
-    }
-    if (normalized.frequency === FREQ_MONTHLY && (!normalized.byDay || normalized.byDay.length === 0) &&
-        (!normalized.byMonthDay || normalized.byMonthDay.length === 0)) {
-        normalized.byMonthDay = [start.day];
-    }
-    if (normalized.frequency === FREQ_YEARLY && (!normalized.byYearDay || normalized.byYearDay.length === 0)) {
-        const hasByMonth = normalized.byMonth && normalized.byMonth.length > 0;
-        const hasByWeekNo = normalized.byWeekNo && normalized.byWeekNo.length > 0;
-        const hasByMonthDay = normalized.byMonthDay && normalized.byMonthDay.length > 0;
-        const hasByDay = normalized.byDay && normalized.byDay.length > 0;
-        if (!hasByMonth && !hasByWeekNo && (hasByMonthDay || !hasByDay)) {
-            normalized.byMonth = [start.month.toString()];
-        }
-        if (!hasByMonthDay && !hasByWeekNo && !hasByDay) {
-            normalized.byMonthDay = [start.day];
-        }
-        if (hasByWeekNo && !hasByMonthDay && !hasByDay) {
-            normalized.byDay = [{ "@type": "NDay", day: dayOfWeek(start) }];
-        }
-    }
-    return normalized;
-}

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

@@ -1,7 +0,0 @@
-/**
- * Select candidate positions based on BYSETPOS rules.
- * @param candidates Candidate date-time strings.
- * @param setPos BYSETPOS indices (1-based, negative from end).
- * @return Selected date-time strings in the order of set positions.
- */
-export declare function applyBySetPos(candidates: string[], setPos: number[]): string[];

package/dist/recurrence/rule-selectors.js

@@ -1,21 +0,0 @@
-/**
- * Select candidate positions based on BYSETPOS rules.
- * @param candidates Candidate date-time strings.
- * @param setPos BYSETPOS indices (1-based, negative from end).
- * @return Selected date-time strings in the order of set positions.
- */
-export function applyBySetPos(candidates, setPos) {
-    const sorted = [...candidates].sort();
-    const result = [];
-    const total = sorted.length;
-    for (const pos of setPos) {
-        const index = pos > 0 ? pos - 1 : total + pos;
-        if (index >= 0 && index < total) {
-            const value = sorted[index];
-            if (value !== undefined) {
-                result.push(value);
-            }
-        }
-    }
-    return result;
-}

package/dist/recurrence/rules.d.ts

@@ -1,14 +0,0 @@
-import type { RecurrenceRule, TimeZoneId } from "../types.js";
-/**
- * Expand a recurrence rule into local date-time strings within a range.
- * @param anchor Anchor LocalDateTime for the rule.
- * @param rule Recurrence rule to expand.
- * @param fromLocal Local date-time lower bound (inclusive).
- * @param toLocal Local date-time upper bound (inclusive).
- * @param includeAnchor Whether to include the anchor occurrence.
- * @param timeZone Optional time zone for range comparisons.
- * @param fromDate Optional Date lower bound (time zone-aware).
- * @param toDate Optional Date upper bound (time zone-aware).
- * @return Local date-time strings that match the rule in range order.
- */
-export declare function expandRule(anchor: string, rule: RecurrenceRule, fromLocal: string, toLocal: string, includeAnchor: boolean, timeZone?: TimeZoneId, fromDate?: Date, toDate?: Date): string[];

package/dist/recurrence/rules.js

@@ -1,57 +0,0 @@
-import { RSCALE_GREGORIAN, SKIP_OMIT } from "./constants.js";
-import { addInterval, compareDate, formatLocalDateTime, parseLocalDateTime } from "./date-utils.js";
-import { generateDateTimes } from "./rule-generate.js";
-import { normalizeRule } from "./rule-normalize.js";
-import { applyBySetPos } from "./rule-selectors.js";
-/**
- * Expand a recurrence rule into local date-time strings within a range.
- * @param anchor Anchor LocalDateTime for the rule.
- * @param rule Recurrence rule to expand.
- * @param fromLocal Local date-time lower bound (inclusive).
- * @param toLocal Local date-time upper bound (inclusive).
- * @param includeAnchor Whether to include the anchor occurrence.
- * @param timeZone Optional time zone for range comparisons.
- * @param fromDate Optional Date lower bound (time zone-aware).
- * @param toDate Optional Date upper bound (time zone-aware).
- * @return Local date-time strings that match the rule in range order.
- */
-export function expandRule(anchor, rule, fromLocal, toLocal, includeAnchor, timeZone, fromDate, toDate) {
-    if (rule.rscale && rule.rscale !== RSCALE_GREGORIAN) {
-        throw new Error(`Unsupported rscale: ${rule.rscale}`);
-    }
-    const start = parseLocalDateTime(anchor);
-    const normalized = normalizeRule(rule, start);
-    const interval = normalized.interval ?? 1;
-    const until = normalized.until;
-    const count = normalized.count ?? Infinity;
-    const skip = normalized.skip ?? SKIP_OMIT;
-    const firstDay = normalized.firstDayOfWeek ?? "mo";
-    const results = [];
-    let generated = 0;
-    let cursor = start;
-    while (generated < count) {
-        const candidates = generateDateTimes(cursor, normalized, firstDay, skip).sort();
-        let filtered = candidates;
-        if (normalized.bySetPosition && normalized.bySetPosition.length > 0) {
-            filtered = applyBySetPos(filtered, normalized.bySetPosition);
-        }
-        for (const dt of filtered) {
-            generated += 1;
-            if (generated > count)
-                break;
-            if (until && dt > until)
-                return results;
-            if (dt >= fromLocal && dt <= toLocal) {
-                results.push(dt);
-            }
-        }
-        if (until && cursor && formatLocalDateTime(cursor) > until)
-            break;
-        if (generated >= count)
-            break;
-        if (cursor && compareDate(cursor, parseLocalDateTime(toLocal)) > 0)
-            break;
-        cursor = addInterval(cursor, normalized.frequency, interval, firstDay);
-    }
-    return results;
-}

package/dist/recurrence/types.d.ts

@@ -1,27 +0,0 @@
-export type RecurrenceRange = {
-    from: Date;
-    to: Date;
-};
-export type RecurrencePage = {
-    items: import("../types.js").JSCalendarObject[];
-    nextCursor?: string;
-};
-export type RecurrencePageOptions = {
-    limit: number;
-    cursor?: string;
-};
-export type DayOfWeek = "mo" | "tu" | "we" | "th" | "fr" | "sa" | "su";
-export type DateTime = {
-    year: number;
-    month: number;
-    day: number;
-    hour: number;
-    minute: number;
-    second: number;
-};
-export type DateCandidate = {
-    year: number;
-    month: number;
-    day: number;
-    valid: boolean;
-};

package/dist/recurrence/types.js

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

package/dist/recurrence.d.ts

@@ -1,2 +0,0 @@
-export type { RecurrenceRange, RecurrencePage, RecurrencePageOptions } from "./recurrence/types.js";
-export { expandRecurrence, expandRecurrencePaged } from "./recurrence/expand.js";

package/dist/recurrence.js

@@ -1 +0,0 @@
-export { expandRecurrence, expandRecurrencePaged } from "./recurrence/expand.js";

package/dist/search.d.ts

@@ -1,44 +0,0 @@
-import type { JSCalendarObject } from "./types.js";
-export type DateRangeValue = string | Date;
-export type DateRange = {
-    start?: DateRangeValue;
-    end?: DateRangeValue;
-};
-export type DateRangeOptions = {
-    includeIncomparable?: boolean;
-};
-/**
- * Find a JSCalendar object by UID.
- * @param items Items to search.
- * @param uid UID to match.
- * @return The matching item or undefined.
- */
-export declare function findByUid<T extends JSCalendarObject>(items: T[], uid: string): T | undefined;
-/**
- * Filter items by JSCalendar @type.
- * @param items Items to filter.
- * @param type Type to match.
- * @return Filtered items.
- */
-export declare function filterByType<T extends JSCalendarObject>(items: T[], type: T["@type"]): T[];
-/**
- * Group JSCalendar objects by @type.
- * @param items Items to group.
- * @return Record keyed by type.
- */
-export declare function groupByType(items: JSCalendarObject[]): Record<string, JSCalendarObject[]>;
-/**
- * Filter items by free-text match.
- * @param items Items to search.
- * @param query Text query.
- * @return Filtered items.
- */
-export declare function filterByText(items: JSCalendarObject[], query: string): JSCalendarObject[];
-/**
- * Filter items that intersect a date range.
- * @param items Items to filter.
- * @param range Range with optional start and end.
- * @param options Filtering options.
- * @return Filtered items.
- */
-export declare function filterByDateRange(items: JSCalendarObject[], range: DateRange, options?: DateRangeOptions): JSCalendarObject[];