origam 2.2.1 → 2.5.0

package/dist/src/utils/Calendar/date.util.cjs

@@ -0,0 +1,181 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "addDays", {
+  enumerable: true,
+  get: function () {
+    return _date.addDays;
+  }
+});
+Object.defineProperty(exports, "addMonths", {
+  enumerable: true,
+  get: function () {
+    return _date.addMonths;
+  }
+});
+Object.defineProperty(exports, "addWeeks", {
+  enumerable: true,
+  get: function () {
+    return _date.addWeeks;
+  }
+});
+exports.buildDisabledPredicate = buildDisabledPredicate;
+exports.buildMonthMatrix = buildMonthMatrix;
+exports.diffMinutes = diffMinutes;
+exports.eachDayOfInterval = eachDayOfInterval;
+Object.defineProperty(exports, "endOfMonth", {
+  enumerable: true,
+  get: function () {
+    return _date.endOfMonth;
+  }
+});
+Object.defineProperty(exports, "endOfWeek", {
+  enumerable: true,
+  get: function () {
+    return _date.endOfWeek;
+  }
+});
+exports.endOfWeekFixed = endOfWeekFixed;
+exports.formatDate = formatDate;
+exports.formatTime = formatTime;
+exports.getWeekdayNames = getWeekdayNames;
+Object.defineProperty(exports, "isAfter", {
+  enumerable: true,
+  get: function () {
+    return _date.isAfter;
+  }
+});
+Object.defineProperty(exports, "isBefore", {
+  enumerable: true,
+  get: function () {
+    return _date.isBefore;
+  }
+});
+exports.isPast = isPast;
+Object.defineProperty(exports, "isSameDay", {
+  enumerable: true,
+  get: function () {
+    return _date.isSameDay;
+  }
+});
+Object.defineProperty(exports, "isSameMonth", {
+  enumerable: true,
+  get: function () {
+    return _date.isSameMonth;
+  }
+});
+exports.isToday = isToday;
+exports.isWeekend = isWeekend;
+exports.isoWeekNumber = isoWeekNumber;
+Object.defineProperty(exports, "startOfDay", {
+  enumerable: true,
+  get: function () {
+    return _date.startOfDay;
+  }
+});
+Object.defineProperty(exports, "startOfMonth", {
+  enumerable: true,
+  get: function () {
+    return _date.startOfMonth;
+  }
+});
+exports.startOfWeekFixed = startOfWeekFixed;
+exports.toDate = toDate;
+var _date = require("../Commons/date.util.cjs");
+function toDate(value) {
+  if (value == null) return null;
+  if (value instanceof Date) return Number.isNaN(value.getTime()) ? null : new Date(value.getTime());
+  if (typeof value === "number") {
+    const d = new Date(value);
+    return Number.isNaN(d.getTime()) ? null : d;
+  }
+  const parsed = new Date(value);
+  return Number.isNaN(parsed.getTime()) ? null : parsed;
+}
+function startOfWeekFixed(date, firstDayOfWeek) {
+  const d = new Date(date);
+  d.setHours(0, 0, 0, 0);
+  const diff = (d.getDay() - firstDayOfWeek + 7) % 7;
+  d.setDate(d.getDate() - diff);
+  return d;
+}
+function endOfWeekFixed(date, firstDayOfWeek) {
+  const start = startOfWeekFixed(date, firstDayOfWeek);
+  return (0, _date.addDays)(start, 6);
+}
+function isToday(date) {
+  return (0, _date.isSameDay)(date, /* @__PURE__ */new Date());
+}
+function isPast(date) {
+  return date.getTime() < Date.now();
+}
+function isWeekend(date) {
+  const day = date.getDay();
+  return day === 0 || day === 6;
+}
+function diffMinutes(a, b) {
+  return Math.round((b.getTime() - a.getTime()) / 6e4);
+}
+function formatTime(date, format, locale) {
+  const options = {
+    hour: "2-digit",
+    minute: "2-digit",
+    hour12: format === "12h"
+  };
+  return new Intl.DateTimeFormat(locale, options).format(date);
+}
+function formatDate(date, locale, options) {
+  return new Intl.DateTimeFormat(locale, options).format(date);
+}
+function buildMonthMatrix(date, firstDayOfWeek) {
+  const firstOfMonth = (0, _date.startOfMonth)(date);
+  const gridStart = startOfWeekFixed(firstOfMonth, firstDayOfWeek);
+  const rows = [];
+  for (let r = 0; r < 6; r++) {
+    const row = [];
+    for (let c = 0; c < 7; c++) {
+      row.push((0, _date.addDays)(gridStart, r * 7 + c));
+    }
+    rows.push(row);
+  }
+  return rows;
+}
+function isoWeekNumber(date) {
+  const d = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()));
+  const day = d.getUTCDay() || 7;
+  d.setUTCDate(d.getUTCDate() + 4 - day);
+  const yearStart = new Date(Date.UTC(d.getUTCFullYear(), 0, 1));
+  return Math.ceil(((d.getTime() - yearStart.getTime()) / 864e5 + 1) / 7);
+}
+function buildDisabledPredicate(input) {
+  if (!input) return () => false;
+  if (typeof input === "function") return input;
+  const set = new Set(input.map(value => toDate(value)).filter(value => value !== null).map(value => `${value.getFullYear()}-${value.getMonth()}-${value.getDate()}`));
+  return date => set.has(`${date.getFullYear()}-${date.getMonth()}-${date.getDate()}`);
+}
+function eachDayOfInterval(from, to) {
+  const start = (0, _date.startOfDay)(from);
+  const end = (0, _date.startOfDay)(to);
+  if (end.getTime() < start.getTime()) return [];
+  const out = [];
+  let cursor = start;
+  while (cursor.getTime() <= end.getTime()) {
+    out.push(cursor);
+    cursor = (0, _date.addDays)(cursor, 1);
+  }
+  return out;
+}
+function getWeekdayNames(locale, firstDayOfWeek, length = "short") {
+  const formatter = new Intl.DateTimeFormat(locale, {
+    weekday: length
+  });
+  const anchor = new Date(2e3, 0, 2);
+  const out = [];
+  for (let i = 0; i < 7; i++) {
+    const day = (0, _date.addDays)(anchor, (firstDayOfWeek + i) % 7);
+    out.push(formatter.format(day));
+  }
+  return out;
+}

package/dist/src/utils/Calendar/date.util.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Calendar-specific date helpers.
+ *
+ * We re-export a subset of the rich `src/utils/Commons/date.util.ts`
+ * surface (the parts the `OrigamCalendar` component depends on), and
+ * add a handful of helpers that only the full-calendar component
+ * cares about (`isToday`, `isPast`, `isWeekend`, `diffMinutes`,
+ * `formatTime`, `buildMonthMatrix`). Keeping the calendar-side
+ * surface narrow makes the public API obvious and lets us evolve
+ * the underlying helpers without auditing every component.
+ *
+ * **SSR-safe** — every function takes a `Date` argument (the caller
+ * provides "now" via `new Date()`), so no module-scope `Date()` call
+ * runs at import time.
+ */
+export { addDays, addMonths, addWeeks, endOfMonth, endOfWeek, isAfter, isBefore, isSameDay, isSameMonth, startOfDay, startOfMonth } from '../Commons/date.util';
+/**
+ * Coerce a `Date | string | number` to a `Date`. Strings go through
+ * `new Date()` (which accepts ISO-8601 natively); numbers are treated
+ * as epoch milliseconds. Returns `null` for unparseable values so the
+ * caller can branch on `!= null`.
+ */
+export declare function toDate(value: Date | string | number | null | undefined): Date | null;
+/**
+ * Start of week aware of `firstDayOfWeek`. We don't go through the
+ * locale-based path in `Commons/date.util.ts` (`startOfWeek(date, locale)`)
+ * because the calendar receives the first-day-of-week as an explicit
+ * prop — letting the locale override it would surprise the consumer.
+ */
+export declare function startOfWeekFixed(date: Date, firstDayOfWeek: number): Date;
+/** Symmetric counterpart to `startOfWeekFixed`. */
+export declare function endOfWeekFixed(date: Date, firstDayOfWeek: number): Date;
+/**
+ * `true` when the date falls on the current calendar day (local
+ * timezone). The "now" reference is captured at call time so the
+ * function stays pure between calls — we don't memoize.
+ */
+export declare function isToday(date: Date): boolean;
+/**
+ * `true` when the date sits in the past — including today's earlier
+ * hours. Used to fade out past events in the toolbar/agenda.
+ */
+export declare function isPast(date: Date): boolean;
+/**
+ * `true` for Saturday / Sunday. Used to paint the weekend stripe in
+ * month / week views when `weekendHighlight` is on.
+ */
+export declare function isWeekend(date: Date): boolean;
+/**
+ * Difference between two dates expressed in **minutes** (positive
+ * when `b` is after `a`). Used for event-height calculations in the
+ * week / day timelines.
+ */
+export declare function diffMinutes(a: Date, b: Date): number;
+/**
+ * Format a `Date` as `HH:MM` (`'24h'`) or `H:MM AM/PM` (`'12h'`).
+ * Goes through `Intl.DateTimeFormat` so the locale's separator and
+ * AM/PM marker are honoured.
+ */
+export declare function formatTime(date: Date, format: '12h' | '24h', locale?: string): string;
+/**
+ * Locale-aware date formatter. Thin wrapper over `Intl.DateTimeFormat`
+ * — kept here so callers don't have to repeat the locale fallback.
+ */
+export declare function formatDate(date: Date, locale: string, options: Intl.DateTimeFormatOptions): string;
+/**
+ * Build a 6-row × 7-col matrix anchored on the month that contains
+ * `date`. Rows always equal 6 so the grid height stays stable when
+ * navigating month-to-month (some months span only 4 or 5 weeks
+ * otherwise).
+ */
+export declare function buildMonthMatrix(date: Date, firstDayOfWeek: number): Array<Array<Date>>;
+/**
+ * Get the ISO 8601 week number for the given date. Used to render the
+ * optional `showWeekNumbers` column in month / week views.
+ *
+ * Algorithm — Thursday-of-the-week / first-Thursday-of-year, which is
+ * the ISO 8601 spec (week 1 contains the year's first Thursday).
+ */
+export declare function isoWeekNumber(date: Date): number;
+/**
+ * Predicate factory. Resolves the user-supplied `disabledDates` (array
+ * of `Date | string` or a predicate function) into a single
+ * `(date: Date) => boolean` we can call from the cell builders.
+ */
+export declare function buildDisabledPredicate(input: Array<Date | string> | ((d: Date) => boolean) | undefined): (date: Date) => boolean;
+/**
+ * Inclusive day-range iterator. Returns every date between `from`
+ * and `to` (00:00 local).
+ */
+export declare function eachDayOfInterval(from: Date, to: Date): Array<Date>;
+/**
+ * Read the weekday short names for the given locale. The output is
+ * already rotated so `firstDayOfWeek` is the first item.
+ */
+export declare function getWeekdayNames(locale: string, firstDayOfWeek: number, length?: 'narrow' | 'short' | 'long'): Array<string>;

package/dist/src/utils/Calendar/date.util.js

@@ -0,0 +1,114 @@
+import {
+  addDays,
+  isSameDay,
+  startOfDay,
+  startOfMonth
+} from "../Commons/date.util.js";
+export {
+  addDays,
+  addMonths,
+  addWeeks,
+  endOfMonth,
+  endOfWeek,
+  isAfter,
+  isBefore,
+  isSameDay,
+  isSameMonth,
+  startOfDay,
+  startOfMonth
+} from "../Commons/date.util.js";
+export function toDate(value) {
+  if (value == null) return null;
+  if (value instanceof Date) return Number.isNaN(value.getTime()) ? null : new Date(value.getTime());
+  if (typeof value === "number") {
+    const d = new Date(value);
+    return Number.isNaN(d.getTime()) ? null : d;
+  }
+  const parsed = new Date(value);
+  return Number.isNaN(parsed.getTime()) ? null : parsed;
+}
+export function startOfWeekFixed(date, firstDayOfWeek) {
+  const d = new Date(date);
+  d.setHours(0, 0, 0, 0);
+  const diff = (d.getDay() - firstDayOfWeek + 7) % 7;
+  d.setDate(d.getDate() - diff);
+  return d;
+}
+export function endOfWeekFixed(date, firstDayOfWeek) {
+  const start = startOfWeekFixed(date, firstDayOfWeek);
+  return addDays(start, 6);
+}
+export function isToday(date) {
+  return isSameDay(date, /* @__PURE__ */ new Date());
+}
+export function isPast(date) {
+  return date.getTime() < Date.now();
+}
+export function isWeekend(date) {
+  const day = date.getDay();
+  return day === 0 || day === 6;
+}
+export function diffMinutes(a, b) {
+  return Math.round((b.getTime() - a.getTime()) / 6e4);
+}
+export function formatTime(date, format, locale) {
+  const options = {
+    hour: "2-digit",
+    minute: "2-digit",
+    hour12: format === "12h"
+  };
+  return new Intl.DateTimeFormat(locale, options).format(date);
+}
+export function formatDate(date, locale, options) {
+  return new Intl.DateTimeFormat(locale, options).format(date);
+}
+export function buildMonthMatrix(date, firstDayOfWeek) {
+  const firstOfMonth = startOfMonth(date);
+  const gridStart = startOfWeekFixed(firstOfMonth, firstDayOfWeek);
+  const rows = [];
+  for (let r = 0; r < 6; r++) {
+    const row = [];
+    for (let c = 0; c < 7; c++) {
+      row.push(addDays(gridStart, r * 7 + c));
+    }
+    rows.push(row);
+  }
+  return rows;
+}
+export function isoWeekNumber(date) {
+  const d = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()));
+  const day = d.getUTCDay() || 7;
+  d.setUTCDate(d.getUTCDate() + 4 - day);
+  const yearStart = new Date(Date.UTC(d.getUTCFullYear(), 0, 1));
+  return Math.ceil(((d.getTime() - yearStart.getTime()) / 864e5 + 1) / 7);
+}
+export function buildDisabledPredicate(input) {
+  if (!input) return () => false;
+  if (typeof input === "function") return input;
+  const set = new Set(
+    input.map((value) => toDate(value)).filter((value) => value !== null).map((value) => `${value.getFullYear()}-${value.getMonth()}-${value.getDate()}`)
+  );
+  return (date) => set.has(`${date.getFullYear()}-${date.getMonth()}-${date.getDate()}`);
+}
+export function eachDayOfInterval(from, to) {
+  const start = startOfDay(from);
+  const end = startOfDay(to);
+  if (end.getTime() < start.getTime()) return [];
+  const out = [];
+  let cursor = start;
+  while (cursor.getTime() <= end.getTime()) {
+    out.push(cursor);
+    cursor = addDays(cursor, 1);
+  }
+  return out;
+}
+export function getWeekdayNames(locale, firstDayOfWeek, length = "short") {
+  const formatter = new Intl.DateTimeFormat(locale, { weekday: length });
+  const anchor = new Date(2e3, 0, 2);
+  const out = [];
+  for (let i = 0; i < 7; i++) {
+    const day = addDays(anchor, (firstDayOfWeek + i) % 7);
+    out.push(formatter.format(day));
+  }
+  return out;
+}

package/dist/src/utils/Calendar/rrule.util.cjs

@@ -0,0 +1,105 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.expandRecurrence = expandRecurrence;
+exports.parseRRule = parseRRule;
+var _date = require("./date.util.cjs");
+const BY_DAY_MAP = {
+  SU: 0,
+  MO: 1,
+  TU: 2,
+  WE: 3,
+  TH: 4,
+  FR: 5,
+  SA: 6
+};
+function parseUntil(value) {
+  if (!value) return null;
+  const m = value.match(/^(\d{4})(\d{2})(\d{2})(?:T(\d{2})(\d{2})(\d{2})Z?)?$/);
+  if (!m) return null;
+  const [, yy, mm, dd, hh, mi, ss] = m;
+  const y = Number(yy);
+  const mo = Number(mm) - 1;
+  const d = Number(dd);
+  const h = hh ? Number(hh) : 23;
+  const mn = mi ? Number(mi) : 59;
+  const s = ss ? Number(ss) : 59;
+  return new Date(y, mo, d, h, mn, s);
+}
+function parseRRule(rrule) {
+  if (!rrule) return null;
+  const cleaned = rrule.replace(/^RRULE:/i, "").trim();
+  if (!cleaned) return null;
+  const parts = {};
+  for (const segment of cleaned.split(";")) {
+    const [key, value] = segment.split("=");
+    if (key && value !== void 0) parts[key.toUpperCase()] = value;
+  }
+  const freq = parts.FREQ;
+  if (freq !== "DAILY" && freq !== "WEEKLY" && freq !== "MONTHLY") return null;
+  const interval = parts.INTERVAL ? Math.max(1, Number(parts.INTERVAL)) : 1;
+  const count = parts.COUNT ? Math.max(0, Number(parts.COUNT)) : null;
+  const until = parts.UNTIL ? parseUntil(parts.UNTIL) : null;
+  const byDay = parts.BYDAY ? parts.BYDAY.split(",").map(token => BY_DAY_MAP[token.trim().toUpperCase()]).filter(value => value !== void 0) : null;
+  return {
+    freq,
+    interval,
+    count,
+    until,
+    byDay
+  };
+}
+function eventDuration(event) {
+  const start = (0, _date.toDate)(event.start);
+  const end = event.end ? (0, _date.toDate)(event.end) : null;
+  if (!start || !end) return 0;
+  return (0, _date.diffMinutes)(start, end);
+}
+function cloneOccurrence(template, occurrenceStart, durationMin) {
+  const end = durationMin > 0 ? new Date(occurrenceStart.getTime() + durationMin * 6e4) : void 0;
+  return {
+    ...template,
+    start: occurrenceStart,
+    end,
+    rrule: void 0
+  };
+}
+const MAX_OCCURRENCES = 366 * 3;
+function expandRecurrence(event, range) {
+  const start = (0, _date.toDate)(event.start);
+  if (!start) return [];
+  if (!event.rrule) {
+    if (start.getTime() > range.end.getTime()) return [];
+    const eventEnd = event.end ? (0, _date.toDate)(event.end) : null;
+    if (eventEnd && eventEnd.getTime() < range.start.getTime()) return [];
+    if (!eventEnd && start.getTime() < range.start.getTime()) return [];
+    return [event];
+  }
+  const rule = parseRRule(event.rrule);
+  if (!rule) return event.rrule ? [event] : [];
+  const duration = eventDuration(event);
+  const occurrences = [];
+  let cursor = new Date(start.getTime());
+  let emitted = 0;
+  while (cursor.getTime() <= range.end.getTime() && (!rule.until || cursor.getTime() <= rule.until.getTime()) && (rule.count == null || emitted < rule.count) && emitted < MAX_OCCURRENCES) {
+    const passesByDay = rule.freq === "WEEKLY" && rule.byDay ? rule.byDay.includes(cursor.getDay()) : true;
+    if (passesByDay && cursor.getTime() >= range.start.getTime() - duration * 6e4) {
+      occurrences.push(cloneOccurrence(event, new Date(cursor.getTime()), duration));
+    }
+    if (passesByDay) emitted++;
+    cursor = advance(cursor, rule, start);
+  }
+  return occurrences;
+}
+function advance(cursor, rule, anchor) {
+  if (rule.freq === "WEEKLY" && rule.byDay && rule.byDay.length > 0) {
+    return (0, _date.addDays)(cursor, 1);
+  }
+  if (rule.freq === "DAILY") return (0, _date.addDays)(cursor, rule.interval);
+  if (rule.freq === "WEEKLY") return (0, _date.addDays)(cursor, 7 * rule.interval);
+  const next = (0, _date.addMonths)(cursor, rule.interval);
+  next.setDate(anchor.getDate());
+  return next;
+}

package/dist/src/utils/Calendar/rrule.util.d.ts

@@ -0,0 +1,49 @@
+/**
+ * RRULE subset parser + recurrence expander.
+ *
+ * Supports — and ONLY supports — the following RFC 5545 directives:
+ * - `FREQ=DAILY | WEEKLY | MONTHLY`
+ * - `INTERVAL=N` (default 1)
+ * - `COUNT=N` (caps occurrences)
+ * - `UNTIL=YYYYMMDDTHHMMSSZ` (ISO 8601 basic with optional `Z`)
+ * - `BYDAY=MO,TU,...` (only for `FREQ=WEEKLY`)
+ *
+ * Everything else (`BYMONTHDAY`, `BYSETPOS`, `BYMONTH`, `BYHOUR`,
+ * `WKST`, `EXDATE`, …) is silently ignored. This matches what
+ * @origam/Calendar promises in its docs: a minimal subset that
+ * handles 95% of "every Monday/Wednesday/Friday at 10am"-style
+ * patterns without dragging in a full RRULE engine like `rrule.js`.
+ *
+ * Pure / SSR-safe: no `Date.now()` at module scope, no DOM access.
+ */
+import type { IEvent } from '../../interfaces';
+interface IParsedRule {
+    freq: 'DAILY' | 'WEEKLY' | 'MONTHLY';
+    interval: number;
+    count: number | null;
+    until: Date | null;
+    byDay: Array<number> | null;
+}
+/**
+ * Parse a raw RRULE string into a normalized rule object. Returns
+ * `null` when the directive is malformed or uses an unsupported
+ * `FREQ` value — the caller should fall back to single-occurrence
+ * rendering in that case.
+ */
+export declare function parseRRule(rrule: string): IParsedRule | null;
+/**
+ * Expand an event with an `rrule` into the list of concrete
+ * occurrences that fall inside `[range.start, range.end]`. Events
+ * without an `rrule` are passed through as a single-element list.
+ *
+ * The expander stops at the first of:
+ * - `range.end`
+ * - `rule.until`
+ * - `rule.count` reached
+ * - `MAX_OCCURRENCES` reached (safety net)
+ */
+export declare function expandRecurrence(event: IEvent, range: {
+    start: Date;
+    end: Date;
+}): Array<IEvent>;
+export {};

package/dist/src/utils/Calendar/rrule.util.js

@@ -0,0 +1,92 @@
+import { addDays, addMonths, diffMinutes, toDate } from "./date.util.js";
+const BY_DAY_MAP = {
+  SU: 0,
+  MO: 1,
+  TU: 2,
+  WE: 3,
+  TH: 4,
+  FR: 5,
+  SA: 6
+};
+function parseUntil(value) {
+  if (!value) return null;
+  const m = value.match(/^(\d{4})(\d{2})(\d{2})(?:T(\d{2})(\d{2})(\d{2})Z?)?$/);
+  if (!m) return null;
+  const [, yy, mm, dd, hh, mi, ss] = m;
+  const y = Number(yy);
+  const mo = Number(mm) - 1;
+  const d = Number(dd);
+  const h = hh ? Number(hh) : 23;
+  const mn = mi ? Number(mi) : 59;
+  const s = ss ? Number(ss) : 59;
+  return new Date(y, mo, d, h, mn, s);
+}
+export function parseRRule(rrule) {
+  if (!rrule) return null;
+  const cleaned = rrule.replace(/^RRULE:/i, "").trim();
+  if (!cleaned) return null;
+  const parts = {};
+  for (const segment of cleaned.split(";")) {
+    const [key, value] = segment.split("=");
+    if (key && value !== void 0) parts[key.toUpperCase()] = value;
+  }
+  const freq = parts.FREQ;
+  if (freq !== "DAILY" && freq !== "WEEKLY" && freq !== "MONTHLY") return null;
+  const interval = parts.INTERVAL ? Math.max(1, Number(parts.INTERVAL)) : 1;
+  const count = parts.COUNT ? Math.max(0, Number(parts.COUNT)) : null;
+  const until = parts.UNTIL ? parseUntil(parts.UNTIL) : null;
+  const byDay = parts.BYDAY ? parts.BYDAY.split(",").map((token) => BY_DAY_MAP[token.trim().toUpperCase()]).filter((value) => value !== void 0) : null;
+  return { freq, interval, count, until, byDay };
+}
+function eventDuration(event) {
+  const start = toDate(event.start);
+  const end = event.end ? toDate(event.end) : null;
+  if (!start || !end) return 0;
+  return diffMinutes(start, end);
+}
+function cloneOccurrence(template, occurrenceStart, durationMin) {
+  const end = durationMin > 0 ? new Date(occurrenceStart.getTime() + durationMin * 6e4) : void 0;
+  return {
+    ...template,
+    start: occurrenceStart,
+    end,
+    rrule: void 0
+  };
+}
+const MAX_OCCURRENCES = 366 * 3;
+export function expandRecurrence(event, range) {
+  const start = toDate(event.start);
+  if (!start) return [];
+  if (!event.rrule) {
+    if (start.getTime() > range.end.getTime()) return [];
+    const eventEnd = event.end ? toDate(event.end) : null;
+    if (eventEnd && eventEnd.getTime() < range.start.getTime()) return [];
+    if (!eventEnd && start.getTime() < range.start.getTime()) return [];
+    return [event];
+  }
+  const rule = parseRRule(event.rrule);
+  if (!rule) return event.rrule ? [event] : [];
+  const duration = eventDuration(event);
+  const occurrences = [];
+  let cursor = new Date(start.getTime());
+  let emitted = 0;
+  while (cursor.getTime() <= range.end.getTime() && (!rule.until || cursor.getTime() <= rule.until.getTime()) && (rule.count == null || emitted < rule.count) && emitted < MAX_OCCURRENCES) {
+    const passesByDay = rule.freq === "WEEKLY" && rule.byDay ? rule.byDay.includes(cursor.getDay()) : true;
+    if (passesByDay && cursor.getTime() >= range.start.getTime() - duration * 6e4) {
+      occurrences.push(cloneOccurrence(event, new Date(cursor.getTime()), duration));
+    }
+    if (passesByDay) emitted++;
+    cursor = advance(cursor, rule, start);
+  }
+  return occurrences;
+}
+function advance(cursor, rule, anchor) {
+  if (rule.freq === "WEEKLY" && rule.byDay && rule.byDay.length > 0) {
+    return addDays(cursor, 1);
+  }
+  if (rule.freq === "DAILY") return addDays(cursor, rule.interval);
+  if (rule.freq === "WEEKLY") return addDays(cursor, 7 * rule.interval);
+  const next = addMonths(cursor, rule.interval);
+  next.setDate(anchor.getDate());
+  return next;
+}

package/dist/src/utils/Chart/box-plot.util.cjs

@@ -0,0 +1,62 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.computeQuartiles = computeQuartiles;
+exports.isRawDatum = isRawDatum;
+const interpolate = (sorted, p) => {
+  const n = sorted.length;
+  if (n === 0) return 0;
+  if (n === 1) return sorted[0];
+  const pos = p * (n - 1);
+  const lo = Math.floor(pos);
+  const hi = Math.ceil(pos);
+  const frac = pos - lo;
+  if (lo === hi) return sorted[lo];
+  return sorted[lo] + frac * (sorted[hi] - sorted[lo]);
+};
+function computeQuartiles(samples) {
+  const finite = samples.filter(v => Number.isFinite(v));
+  if (finite.length === 0) {
+    return {
+      min: 0,
+      q1: 0,
+      median: 0,
+      q3: 0,
+      max: 0,
+      iqr: 0,
+      outliers: []
+    };
+  }
+  const sorted = [...finite].sort((a, b) => a - b);
+  const q1 = interpolate(sorted, 0.25);
+  const median = interpolate(sorted, 0.5);
+  const q3 = interpolate(sorted, 0.75);
+  const iqr = q3 - q1;
+  const lowerFence = q1 - 1.5 * iqr;
+  const upperFence = q3 + 1.5 * iqr;
+  const outliers = [];
+  const inliers = [];
+  for (const v of sorted) {
+    if (v < lowerFence || v > upperFence) {
+      outliers.push(v);
+    } else {
+      inliers.push(v);
+    }
+  }
+  const whiskerMin = inliers.length > 0 ? inliers[0] : sorted[0];
+  const whiskerMax = inliers.length > 0 ? inliers[inliers.length - 1] : sorted[sorted.length - 1];
+  return {
+    min: whiskerMin,
+    q1,
+    median,
+    q3,
+    max: whiskerMax,
+    iqr,
+    outliers
+  };
+}
+function isRawDatum(datum) {
+  return typeof datum === "object" && datum !== null && Array.isArray(datum.samples);
+}