@craftguild/jscalendar 0.2.0 → 0.3.1

package/dist/recurrence/rule-normalize.js

@@ -0,0 +1,57 @@
+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

@@ -0,0 +1,7 @@
+/**
+ * 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

@@ -0,0 +1,21 @@
+/**
+ * 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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,57 @@
+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

@@ -0,0 +1,27 @@
+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

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

package/dist/recurrence.d.ts

@@ -1,15 +1,2 @@
-import type { JSCalendarObject } from "./types.js";
-export type RecurrenceRange = {
-    from: Date;
-    to: Date;
-};
-export type RecurrencePage = {
-    items: JSCalendarObject[];
-    nextCursor?: string;
-};
-export type RecurrencePageOptions = {
-    limit: number;
-    cursor?: string;
-};
-export declare function expandRecurrence(items: JSCalendarObject[], range: RecurrenceRange): Generator<JSCalendarObject>;
-export declare function expandRecurrencePaged(items: JSCalendarObject[], range: RecurrenceRange, options: RecurrencePageOptions): RecurrencePage;
+export type { RecurrenceRange, RecurrencePage, RecurrencePageOptions } from "./recurrence/types.js";
+export { expandRecurrence, expandRecurrencePaged } from "./recurrence/expand.js";