react-big-schedule 8.1.0 → 9.0.1

package/dist/calendar/Calendar.d.ts

@@ -0,0 +1,28 @@
+import type { Dayjs } from 'dayjs';
+import type { CalendarCallbacks, CalendarOptions, CalendarViewName, EventSource } from './types';
+export interface CalendarProps extends CalendarOptions, CalendarCallbacks {
+    /** Events: an array, a `(range) => events` function, or a `{ url }` JSON feed. */
+    events?: EventSource;
+    /** More sources (arrays, functions, feeds, or `{ events, color, textColor }`) merged with `events`. */
+    eventSources?: EventSource[];
+    /** Controlled view. */
+    view?: CalendarViewName;
+    initialView?: CalendarViewName;
+    onViewChange?: (view: CalendarViewName) => void;
+    /** Controlled date (anchor of the visible range). */
+    date?: Dayjs | string | Date;
+    initialDate?: Dayjs | string | Date;
+    onDateChange?: (date: Dayjs) => void;
+    /** Views offered in the toolbar switcher. */
+    views?: CalendarViewName[];
+    /** Set false to hide the built-in toolbar and drive view/date yourself. */
+    toolbar?: boolean;
+    /** Colour scheme: 'default' (transparent, follows the page), 'light', 'dark' or any custom data-rbs-theme value. */
+    theme?: string;
+    /** Design language: 'material' | 'fluent' | 'tailwind' | 'minimal' | 'classic'. */
+    look?: string;
+    /** Colour palette: blue, green, purple, red, amber, emerald, indigo or rose. */
+    palette?: string;
+}
+declare function Calendar({ events: eventsProp, eventSources, view: viewProp, initialView, onViewChange, date: dateProp, initialDate, onDateChange, views, toolbar, theme, look, palette, ...rest }: CalendarProps): import("react").JSX.Element;
+export default Calendar;

package/dist/calendar/Calendar.js

@@ -0,0 +1,95 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { lazy, Suspense, useCallback, useEffect, useMemo, useState } from 'react';
+import SchedulerData from '../components/SchedulerData';
+import { ViewType } from '../config/default';
+import Toolbar from './Toolbar';
+import { withTimeZone } from './timezone';
+import { useEventSources } from './useEventSources';
+import { useRecurrence } from './useRecurrence';
+import { getViewRange, getViewTitle, stepDate } from './utils';
+const DayGridView = lazy(() => import('./views/DayGridView'));
+const TimeGridView = lazy(() => import('./views/TimeGridView'));
+const ListView = lazy(() => import('./views/ListView'));
+const MultiMonthView = lazy(() => import('./views/MultiMonthView'));
+const VIEW_LABELS = {
+    dayGridMonth: 'Month',
+    dayGridWeek: 'Week grid',
+    dayGridDay: 'Day grid',
+    timeGridWeek: 'Week',
+    timeGridDay: 'Day',
+    listDay: 'List day',
+    listWeek: 'List',
+    listMonth: 'List month',
+    listYear: 'List year',
+    multiMonthYear: 'Year',
+    multiMonthStack: 'Year stack',
+    multiMonthContinuous: 'Year flow',
+};
+const DEFAULT_VIEWS = ['dayGridMonth', 'timeGridWeek', 'timeGridDay', 'listWeek', 'multiMonthYear'];
+function pickView(view) {
+    if (view.startsWith('dayGrid'))
+        return DayGridView;
+    if (view.startsWith('timeGrid'))
+        return TimeGridView;
+    if (view.startsWith('list'))
+        return ListView;
+    return MultiMonthView;
+}
+function Calendar({ events: eventsProp, eventSources, view: viewProp, initialView = 'dayGridMonth', onViewChange, date: dateProp, initialDate, onDateChange, views = DEFAULT_VIEWS, toolbar = true, theme, look, palette, ...rest }) {
+    // one locale-bound dayjs per calendar (same isolation as <Scheduler>, see #146)
+    const baseDayjs = useMemo(() => new SchedulerData(undefined, ViewType.Week, false, false).localeDayjs, []);
+    useMemo(() => baseDayjs.locale(rest.locale ?? baseDayjs.locale()), [baseDayjs, rest.locale]);
+    const dayjs = useMemo(() => withTimeZone(baseDayjs, rest.timeZone), [baseDayjs, rest.timeZone]);
+    const [innerView, setInnerView] = useState(initialView);
+    const [innerDate, setInnerDate] = useState(() => dayjs(initialDate));
+    const view = viewProp ?? innerView;
+    const date = useMemo(() => (dateProp === undefined ? dayjs(innerDate.valueOf()) : dayjs(dateProp)), [dayjs, dateProp, innerDate]);
+    const setView = useCallback((next) => {
+        if (viewProp === undefined)
+            setInnerView(next);
+        onViewChange?.(next);
+    }, [viewProp, onViewChange]);
+    const setDate = useCallback((next) => {
+        if (dateProp === undefined)
+            setInnerDate(next);
+        onDateChange?.(next);
+    }, [dateProp, onDateChange]);
+    const goTo = useCallback((nextView, nextDate) => {
+        setView(nextView);
+        setDate(nextDate);
+    }, [setView, setDate]);
+    const range = useMemo(() => getViewRange(view, date, rest.firstDay ?? 0), [view, date, rest.firstDay]);
+    const { onDatesSet, onLoading, onEventsError } = rest;
+    const sourced = useEventSources(eventsProp, eventSources, range, onLoading, onEventsError);
+    const events = useRecurrence(sourced.events, range, dayjs);
+    useEffect(() => {
+        onDatesSet?.({ ...range, view });
+    }, [range.start.valueOf(), range.end.valueOf(), view]);
+    // one delegated hover card for every view: any element carrying data-tip (title line, then detail lines)
+    const [tip, setTip] = useState(null);
+    const showTip = (target, pressed = false) => {
+        const el = pressed ? null : target.closest('[data-tip]');
+        if (!el?.dataset.tip)
+            return setTip(null);
+        const r = el.getBoundingClientRect();
+        setTip(t => t && t.text === el.dataset.tip && t.top === r.top
+            ? t
+            : {
+                x: r.left + r.width / 2,
+                top: r.top,
+                bottom: r.bottom,
+                text: el.dataset.tip ?? '',
+                color: el.dataset.tipColor,
+            });
+    };
+    const [tipTitle, ...tipLines] = tip?.text.split('\n') ?? [];
+    const View = pickView(view);
+    const viewProps = { ...rest, view, date, events, dayjs, goTo };
+    return (_jsxs("div", { "data-rbs-theme": theme, "data-rbs-look": look, "data-rbs-palette": palette, className: `rbs-calendar rbs-container ${rest.className ?? ''}`, style: { height: rest.height, ...rest.style }, onMouseOver: e => showTip(e.target, e.buttons > 0), onFocus: e => showTip(e.target), onBlur: () => setTip(null), onMouseLeave: () => setTip(null), onScrollCapture: () => setTip(null), children: [toolbar && (_jsx(Toolbar, { title: getViewTitle(view, date, range), view: view, views: views.map(name => ({ name, label: VIEW_LABELS[name] })), today: dayjs(), loading: sourced.loading, onPrev: () => setDate(stepDate(view, date, -1)), onNext: () => setDate(stepDate(view, date, 1)), onToday: () => setDate(dayjs()), onView: setView })), _jsx(Suspense, { fallback: _jsx("span", { className: "rbs-spinner", role: "status", "aria-label": "Loading" }), children: _jsx(View, { ...viewProps }) }), tip && (_jsxs("div", { role: "tooltip", className: "rbs-tip", style: {
+                    left: Math.min(Math.max(tip.x, 150), window.innerWidth - 150),
+                    ...(tip.top > 110
+                        ? { top: tip.top - 8, transform: 'translate(-50%, -100%)' }
+                        : { top: tip.bottom + 8, transform: 'translateX(-50%)' }),
+                }, children: [_jsx("span", { className: "rbs-tip-bar", style: { background: tip.color ?? 'var(--rbs-accent)' } }), _jsx("strong", { children: tipTitle }), tipLines.map(l => (_jsx("span", { children: l }, l)))] }))] }));
+}
+export default Calendar;

package/dist/calendar/Toolbar.d.ts

@@ -0,0 +1,18 @@
+import type { Dayjs } from 'dayjs';
+import type { CalendarViewName } from './types';
+export interface ToolbarProps {
+    title: string;
+    view: CalendarViewName;
+    views: {
+        name: CalendarViewName;
+        label: string;
+    }[];
+    onPrev: () => void;
+    onNext: () => void;
+    onToday: () => void;
+    onView: (view: CalendarViewName) => void;
+    today: Dayjs;
+    loading?: boolean;
+}
+declare function Toolbar({ title, view, views, onPrev, onNext, onToday, onView, loading }: ToolbarProps): import("react").JSX.Element;
+export default Toolbar;

package/dist/calendar/Toolbar.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { ChevronLeft, ChevronRight } from '../components/ui/Icons';
+function Toolbar({ title, view, views, onPrev, onNext, onToday, onView, loading }) {
+    return (_jsxs("div", { className: "rbs-cal-toolbar rbs:flex rbs:flex-wrap rbs:items-center rbs:justify-between rbs:gap-2 rbs:pb-3", children: [_jsxs("div", { className: "rbs:flex rbs:items-center rbs:gap-2", children: [_jsx("button", { type: "button", "aria-label": "Previous", className: "rbs-icon-btn", onClick: onPrev, children: _jsx(ChevronLeft, {}) }), _jsx("button", { type: "button", "aria-label": "Next", className: "rbs-icon-btn", onClick: onNext, children: _jsx(ChevronRight, {}) }), _jsx("button", { type: "button", className: "rbs-btn", onClick: onToday, children: "Today" }), loading && _jsx("span", { className: "rbs-spinner", role: "status", "aria-label": "Loading events" })] }), _jsx("h2", { className: "rbs-cal-title rbs:m-0 rbs:text-lg rbs:font-medium", children: title }), _jsx("div", { className: "rbs-segmented", role: "group", "aria-label": "View", children: views.map(v => (_jsx("button", { type: "button", "aria-pressed": v.name === view, onClick: () => onView(v.name), children: v.label }, v.name))) })] }));
+}
+export default Toolbar;

package/dist/calendar/recurrence.check.d.ts

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

package/dist/calendar/recurrence.check.js

@@ -0,0 +1,49 @@
+// Run: bun src/calendar/recurrence.check.ts
+import SchedulerData from '../components/SchedulerData';
+import { ViewType } from '../config/default';
+import { expandRecurring } from './recurrence';
+import { withTimeZone } from './timezone';
+const assert = {
+    equal: (a, b) => {
+        if (a !== b)
+            throw new Error(`expected ${String(b)}, got ${String(a)}`);
+    },
+    deepEqual: (a, b) => assert.equal(JSON.stringify(a), JSON.stringify(b)),
+    ok: (v) => assert.equal(Boolean(v), true),
+};
+const base = new SchedulerData(undefined, ViewType.Week, false, false).localeDayjs;
+const utc = withTimeZone(base, 'UTC');
+const range = { start: utc('2024-03-04'), end: utc('2024-03-18') }; // two weeks, Mon..Mon
+// rrule: weekly Mon/Wed, 1h, one wed skipped via exceptions
+const weekly = {
+    id: 'a',
+    title: 'Standup',
+    start: '2024-03-01T09:00:00',
+    end: '2024-03-01T10:00:00',
+    rrule: 'FREQ=WEEKLY;BYDAY=MO,WE',
+    exceptions: ['2024-03-13T09:00:00'],
+};
+const occ = expandRecurring([weekly], range, utc);
+assert.deepEqual(occ.map(o => String(o.start).slice(0, 16)), ['2024-03-04T09:00', '2024-03-06T09:00', '2024-03-11T09:00']);
+assert.ok(String(occ[0]?.id).startsWith('a:2024-03-04T09:00'));
+assert.equal(occ[0]?.extendedProps?.recurringId, 'a');
+assert.equal(occ[0]?.end && String(occ[0].end).slice(11, 16), '10:00');
+// simple form
+const simple = {
+    id: 's',
+    title: 'Gym',
+    start: '2024-01-01',
+    recurrence: { daysOfWeek: [2, 4], startTime: '07:30', endTime: '08:15', endRecur: '2024-03-13' },
+};
+const so = expandRecurring([simple], range, utc);
+assert.deepEqual(so.map(o => String(o.start).slice(0, 16)), ['2024-03-05T07:30', '2024-03-07T07:30', '2024-03-12T07:30']);
+// plain events pass through untouched
+const plain = { id: 'p', title: 'x', start: '2024-03-05' };
+assert.equal(expandRecurring([plain], range, utc)[0], plain);
+// time zones: 2024-03-01T00:00:00Z is 05:30 in Kolkata and 19:00 (Feb 29) in New York; offset-less string is wall time
+const inst = '2024-03-01T00:00:00Z';
+assert.equal(withTimeZone(base, 'Asia/Kolkata')(inst).format('YYYY-MM-DD HH:mm'), '2024-03-01 05:30');
+assert.equal(withTimeZone(base, 'America/New_York')(inst).format('YYYY-MM-DD HH:mm'), '2024-02-29 19:00');
+assert.equal(withTimeZone(base, 'Asia/Kolkata')('2024-03-01T05:30:00').toISOString(), '2024-03-01T00:00:00.000Z');
+assert.equal(withTimeZone(base, 'UTC')('2024-03-01').format('YYYY-MM-DD HH:mm'), '2024-03-01 00:00');
+console.log('recurrence.check: ok');

package/dist/calendar/recurrence.d.ts

@@ -0,0 +1,8 @@
+import type { LocaleDayjs } from '../types';
+import type { CalendarEvent, DateRange } from './types';
+export declare const isRecurring: (e: CalendarEvent) => boolean;
+/**
+ * Replace recurring events by their occurrences inside `range`; other events pass through untouched.
+ * Cost is proportional to the visible range, never to the length of the recurrence.
+ */
+export declare function expandRecurring(events: CalendarEvent[], range: DateRange, dayjs: LocaleDayjs): CalendarEvent[];

package/dist/calendar/recurrence.js

@@ -0,0 +1,90 @@
+import { rrulestr } from 'rrule';
+import { normalizeEvent, parseTime, toDayjs } from './utils';
+const MAX_PER_EVENT = 2000;
+const DAY = 86400000;
+export const isRecurring = (e) => Boolean(e.rrule || e.recurrence);
+// rrule computes in UTC fields; feed it wall-clock fields as if they were UTC ("floating" time) so DST and zones stay right
+const toFloating = (d) => new Date(Date.UTC(d.year(), d.month(), d.date(), d.hour(), d.minute(), d.second()));
+const fromFloating = (dayjs, d) => dayjs(d.toISOString().slice(0, 19));
+function occurrence(ev, start, end, allDay) {
+    const { rrule: _r, recurrence: _c, exceptions: _x, ...rest } = ev;
+    const fmt = (d) => (allDay ? d.format('YYYY-MM-DD') : d.format());
+    return {
+        ...rest,
+        id: `${ev.id}:${start.format()}`,
+        start: fmt(start),
+        end: fmt(end),
+        allDay,
+        extendedProps: { ...ev.extendedProps, recurringId: ev.id },
+    };
+}
+function rruleStarts(dayjs, ev, start, from, to) {
+    // bare "FREQ=..." lines need their RRULE: prefix for set parsing
+    const text = ev.rrule
+        .split(/\r?\n/)
+        .map(l => (/^(RRULE|EXRULE|DTSTART|EXDATE|RDATE)/i.test(l.trim()) ? l.trim() : `RRULE:${l.trim()}`))
+        .join('\n');
+    const dtstart = `DTSTART:${toFloating(start)
+        .toISOString()
+        .replace(/[-:]|\.\d{3}/g, '')}`;
+    const set = rrulestr(/^DTSTART/im.test(text) ? text : `${dtstart}\n${text}`, { forceset: true });
+    return set
+        .between(toFloating(from), toFloating(to), true)
+        .slice(0, MAX_PER_EVENT)
+        .map(d => fromFloating(dayjs, d));
+}
+function simpleStarts(dayjs, ev, from, to) {
+    const r = ev.recurrence;
+    if (!r)
+        return [];
+    const days = new Set(r.daysOfWeek);
+    const lo = r.startRecur === undefined ? undefined : toDayjs(dayjs, r.startRecur).startOf('day');
+    const hi = r.endRecur === undefined ? undefined : toDayjs(dayjs, r.endRecur).startOf('day');
+    const out = [];
+    for (let d = from.startOf('day'); d.isBefore(to) && out.length < MAX_PER_EVENT; d = d.add(1, 'day')) {
+        if (!days.has(d.day()) || (lo && d.isBefore(lo)) || (hi && !d.isBefore(hi)))
+            continue;
+        if (r.startTime === undefined) {
+            out.push({ start: d, allDay: true });
+            continue;
+        }
+        const at = (t) => d.add(parseTime(t), 'minute');
+        out.push({ start: at(r.startTime), end: r.endTime === undefined ? undefined : at(r.endTime), allDay: false });
+    }
+    return out;
+}
+/**
+ * Replace recurring events by their occurrences inside `range`; other events pass through untouched.
+ * Cost is proportional to the visible range, never to the length of the recurrence.
+ */
+export function expandRecurring(events, range, dayjs) {
+    const out = [];
+    for (const ev of events) {
+        if (!isRecurring(ev)) {
+            out.push(ev);
+            continue;
+        }
+        const base = normalizeEvent(dayjs, ev);
+        const dur = base.end.diff(base.start);
+        const skip = new Set((ev.exceptions ?? []).map(x => {
+            const d = toDayjs(dayjs, x);
+            return base.allDay ? d.format('YYYY-MM-DD') : String(d.valueOf());
+        }));
+        const isSkipped = (s) => skip.has(base.allDay ? s.format('YYYY-MM-DD') : String(s.valueOf()));
+        const span = (s) => base.allDay ? s.add(Math.max(1, Math.round(dur / DAY)), 'day') : s.add(dur, 'millisecond');
+        const from = range.start.subtract(dur, 'millisecond');
+        if (ev.rrule) {
+            for (const s of rruleStarts(dayjs, ev, base.start, from, range.end)) {
+                if (!isSkipped(s))
+                    out.push(occurrence(ev, s, span(s), base.allDay));
+            }
+        }
+        for (const o of simpleStarts(dayjs, ev, from, range.end)) {
+            const s = o.start;
+            const e = o.end?.isAfter(s) ? o.end : o.allDay ? s.add(Math.max(1, Math.round(dur / DAY)), 'day') : span(s);
+            if (!isSkipped(s) && e.isAfter(range.start))
+                out.push(occurrence(ev, s, e, o.allDay));
+        }
+    }
+    return out;
+}

package/dist/calendar/timezone.d.ts

@@ -0,0 +1,6 @@
+import type { LocaleDayjs } from '../types';
+/**
+ * Bind a locale dayjs to a time zone. Instants (offset strings, Dates, timestamps, Dayjs) are converted to the zone;
+ * offset-less strings are read as wall-clock time in it.
+ */
+export declare function withTimeZone(base: LocaleDayjs, zone: string | undefined): LocaleDayjs;

package/dist/calendar/timezone.js

@@ -0,0 +1,14 @@
+// "2024-03-01T10:00:00Z", "...+05:30" (a date-only string never matches: it needs a time part)
+const HAS_OFFSET = /\d[T ]\d.*(?:[zZ]|[+-]\d{2}(?::?\d{2})?)$/;
+/**
+ * Bind a locale dayjs to a time zone. Instants (offset strings, Dates, timestamps, Dayjs) are converted to the zone;
+ * offset-less strings are read as wall-clock time in it.
+ */
+export function withTimeZone(base, zone) {
+    if (!zone || zone === 'local')
+        return base;
+    const create = (date, format, strict) => typeof date === 'string' && !format && !HAS_OFFSET.test(date)
+        ? base.tz(date, zone)
+        : base(date, format, strict).tz(zone);
+    return Object.assign(create, { locale: base.locale, utc: base.utc, tz: base.tz });
+}

package/dist/calendar/types.d.ts

@@ -0,0 +1,187 @@
+import type { Dayjs } from 'dayjs';
+import type { CSSProperties, ReactNode } from 'react';
+import type { LocaleDayjs } from '../types';
+/** Every built-in calendar view (FullCalendar naming). Resource timeline stays in <Scheduler>. */
+export type CalendarViewName = 'dayGridMonth' | 'dayGridWeek' | 'dayGridDay' | 'timeGridWeek' | 'timeGridDay' | 'listDay' | 'listWeek' | 'listMonth' | 'listYear' | 'multiMonthYear' | 'multiMonthStack' | 'multiMonthContinuous';
+export type DateLike = string | number | Date | Dayjs;
+export interface CalendarEvent {
+    id: string | number;
+    title: string;
+    start: DateLike;
+    end?: DateLike;
+    allDay?: boolean;
+    /** Background colour of the event; falls back to the theme accent. */
+    color?: string;
+    textColor?: string;
+    /** 'background' paints the time range behind other events instead of an event chip. */
+    display?: 'auto' | 'block' | 'list-item' | 'background' | 'none';
+    editable?: boolean;
+    startEditable?: boolean;
+    durationEditable?: boolean;
+    /** Free-form data, handed back untouched in every callback. */
+    extendedProps?: Record<string, unknown>;
+    classNames?: string[];
+    /**
+     * RFC 5545 rule (`FREQ=WEEKLY;BYDAY=MO,WE`, optionally with DTSTART/EXDATE lines). Expanded for the visible range only.
+     * DTSTART defaults to `start`; an embedded DTSTART is read as wall-clock time in the calendar's time zone.
+     * The event's `start`/`end` give the first occurrence and the duration of every occurrence.
+     */
+    rrule?: string;
+    /** FullCalendar-style simple recurrence (weekly days + time of day). Takes `start`/`end` duration when no times are given. */
+    recurrence?: SimpleRecurrence;
+    /** Occurrences to skip (matched by start instant, or by day for all-day events). Applies to `rrule` and `recurrence`. */
+    exceptions?: DateLike[];
+}
+/** Weekly recurrence without RRULE syntax. */
+export interface SimpleRecurrence {
+    /** 0 = Sunday ... 6 = Saturday. */
+    daysOfWeek: number[];
+    /** 'HH:mm'. Omit both times for all-day occurrences. */
+    startTime?: string;
+    /** 'HH:mm'. Omit to reuse the duration of the event. */
+    endTime?: string;
+    /** First day (inclusive) the recurrence applies. */
+    startRecur?: DateLike;
+    /** Day (exclusive) the recurrence stops, like FullCalendar. */
+    endRecur?: DateLike;
+}
+/** Visible range handed to dynamic event sources. */
+export type EventFetchRange = DateRange;
+/** Function source. Receives an AbortSignal that fires when the user navigates away before it resolves. */
+export type EventFetcher = (range: EventFetchRange, signal: AbortSignal) => CalendarEvent[] | Promise<CalendarEvent[]>;
+/** JSON feed source: GET (or POST) `url` with `start` / `end` ISO query params, expects a CalendarEvent[] response. */
+export interface EventFeed {
+    url: string;
+    method?: 'GET' | 'POST';
+    /** Extra query params (form body for POST); a function is evaluated on every fetch. */
+    params?: Record<string, string | number | boolean> | (() => Record<string, string | number | boolean>);
+    /** Same as `params`; merged on top of it (FullCalendar's extraParams). */
+    extraParams?: Record<string, string | number | boolean> | (() => Record<string, string | number | boolean>);
+    headers?: Record<string, string>;
+    /** Query param names. Default 'start' / 'end'. */
+    startParam?: string;
+    endParam?: string;
+    /** Default colours for events of this feed. */
+    color?: string;
+    textColor?: string;
+}
+export type EventSourceInput = CalendarEvent[] | EventFetcher | EventFeed;
+/** Any source wrapped with colours that fill in events lacking their own. */
+export interface EventSourceObject {
+    events: EventSourceInput;
+    color?: string;
+    textColor?: string;
+}
+export type EventSource = EventSourceInput | EventSourceObject;
+export interface BusinessHours {
+    /** 0 = Sunday ... 6 = Saturday. Default Mon-Fri. */
+    daysOfWeek?: number[];
+    /** 'HH:mm' */
+    startTime?: string;
+    endTime?: string;
+}
+export interface DateRange {
+    start: Dayjs;
+    end: Dayjs;
+}
+export interface EventClickInfo {
+    event: CalendarEvent;
+    jsEvent: React.MouseEvent | MouseEvent;
+}
+export interface DateClickInfo {
+    date: Dayjs;
+    allDay: boolean;
+    jsEvent: React.MouseEvent | MouseEvent;
+}
+export interface SelectInfo {
+    start: Dayjs;
+    end: Dayjs;
+    allDay: boolean;
+}
+export interface EventChangeInfo {
+    event: CalendarEvent;
+    oldEvent: CalendarEvent;
+    /** Call to undo the change in a controlled calendar. */
+    revert: () => void;
+}
+export interface EventContentArg {
+    event: CalendarEvent;
+    view: CalendarViewName;
+    timeText: string;
+    isStart: boolean;
+    isEnd: boolean;
+    isPast: boolean;
+    isFuture: boolean;
+    isToday: boolean;
+}
+/** Options shared by every view; the <Calendar> shell fills in defaults. */
+export interface CalendarOptions {
+    locale?: string;
+    /**
+     * Time zone dates are displayed and reported in: 'local' (default), 'UTC' or an IANA name ('Asia/Kolkata').
+     * Event strings with an offset/`Z` are converted; strings without one are wall-clock time in this zone.
+     */
+    timeZone?: 'local' | 'UTC' | (string & {});
+    /** 0 = Sunday ... 6 = Saturday. Default 0. */
+    firstDay?: number;
+    weekends?: boolean;
+    weekNumbers?: boolean;
+    nowIndicator?: boolean;
+    businessHours?: boolean | BusinessHours;
+    selectable?: boolean;
+    editable?: boolean;
+    /** Max events per day cell before "+N more" (dayGrid). true = fit to cell height. */
+    dayMaxEvents?: boolean | number;
+    /** Minutes per time-grid slot row. Default 30. */
+    slotDuration?: number;
+    /** 'HH:mm' */
+    slotMinTime?: string;
+    slotMaxTime?: string;
+    /** Pixel height of one slot row in time-grid views. Default 28. */
+    slotHeight?: number;
+    /** Fixed height in px or CSS value; 'auto' grows with content. */
+    height?: number | string;
+    /** 'HH:mm' scroll target on mount in time-grid. Default 08:00. */
+    scrollTime?: string;
+    /** Hide events from other months in dayGrid month. */
+    showNonCurrentDates?: boolean;
+    eventTimeFormat?: string;
+    eventContent?: (arg: EventContentArg) => ReactNode;
+    eventClassNames?: (arg: EventContentArg) => string | string[];
+    dayCellClassNames?: (arg: {
+        date: Dayjs;
+        isToday: boolean;
+        isOther: boolean;
+    }) => string | string[];
+    noEventsContent?: ReactNode;
+    style?: CSSProperties;
+    className?: string;
+}
+export interface CalendarCallbacks {
+    onEventClick?: (info: EventClickInfo) => void;
+    onDateClick?: (info: DateClickInfo) => void;
+    onSelect?: (info: SelectInfo) => void;
+    /** Event moved by drag-and-drop (start/end already updated on `event`). */
+    onEventDrop?: (info: EventChangeInfo) => void;
+    /** Event resized (start/end already updated on `event`). */
+    onEventResize?: (info: EventChangeInfo) => void;
+    /** Visible date range changed (navigation or view change). */
+    onDatesSet?: (range: DateRange & {
+        view: CalendarViewName;
+    }) => void;
+    onNavLinkDayClick?: (date: Dayjs) => void;
+    /** A dynamic event source started (true) or all of them finished (false) loading. */
+    onLoading?: (isLoading: boolean) => void;
+    /** A function or JSON-feed source failed. Aborted (stale) requests are not reported. */
+    onEventsError?: (error: Error) => void;
+}
+/** What the shell passes to every view component. */
+export interface CalendarViewProps extends CalendarOptions, CalendarCallbacks {
+    view: CalendarViewName;
+    /** Anchor date of the visible range. */
+    date: Dayjs;
+    events: CalendarEvent[];
+    dayjs: LocaleDayjs;
+    /** Called by views to switch view/date (nav links, "+N more", year month titles). */
+    goTo: (view: CalendarViewName, date: Dayjs) => void;
+}

package/dist/calendar/types.js

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

package/dist/calendar/useEventSources.d.ts

@@ -0,0 +1,11 @@
+import type { CalendarEvent, DateRange, EventSource } from './types';
+export interface UseEventSources {
+    events: CalendarEvent[];
+    loading: boolean;
+}
+/**
+ * Merge `events` + `eventSources` into one array. Arrays are used as is; function and feed sources are (re)fetched
+ * whenever the visible range changes, and a request left behind by navigation is aborted and ignored.
+ * Inline function sources do not refetch on re-render; feeds refetch when url/method change.
+ */
+export declare function useEventSources(events: EventSource | undefined, eventSources: EventSource[] | undefined, range: DateRange, onLoading?: (loading: boolean) => void, onError?: (error: Error) => void): UseEventSources;

package/dist/calendar/useEventSources.js

@@ -0,0 +1,89 @@
+import { useEffect, useMemo, useRef, useState } from 'react';
+const isWrapped = (s) => typeof s === 'object' && !Array.isArray(s) && 'events' in s;
+function normalize(src) {
+    if (isWrapped(src))
+        return { input: src.events, color: src.color, textColor: src.textColor };
+    const feed = !Array.isArray(src) && typeof src === 'object' ? src : undefined;
+    return { input: src, color: feed?.color, textColor: feed?.textColor };
+}
+const paint = (events, { color, textColor }) => color || textColor
+    ? events.map(e => ({ ...e, color: e.color ?? color, textColor: e.textColor ?? textColor }))
+    : events;
+const resolve = (v) => (typeof v === 'function' ? v() : v);
+async function fetchFeed(feed, range, signal) {
+    const params = new URLSearchParams();
+    const all = { ...resolve(feed.params), ...resolve(feed.extraParams) };
+    for (const [k, v] of Object.entries(all))
+        params.set(k, String(v));
+    params.set(feed.startParam ?? 'start', range.start.toISOString());
+    params.set(feed.endParam ?? 'end', range.end.toISOString());
+    const post = feed.method === 'POST';
+    const url = post ? feed.url : `${feed.url}${feed.url.includes('?') ? '&' : '?'}${params}`;
+    const res = await fetch(url, {
+        method: feed.method ?? 'GET',
+        headers: { ...(post ? { 'Content-Type': 'application/x-www-form-urlencoded' } : {}), ...feed.headers },
+        body: post ? params : undefined,
+        signal,
+    });
+    if (!res.ok)
+        throw new Error(`Event feed ${feed.url} responded ${res.status}`);
+    return (await res.json());
+}
+const load = (src, range, signal) => Promise.resolve(typeof src.input === 'function'
+    ? src.input(range, signal)
+    : fetchFeed(src.input, range, signal));
+/**
+ * Merge `events` + `eventSources` into one array. Arrays are used as is; function and feed sources are (re)fetched
+ * whenever the visible range changes, and a request left behind by navigation is aborted and ignored.
+ * Inline function sources do not refetch on re-render; feeds refetch when url/method change.
+ */
+export function useEventSources(events, eventSources, range, onLoading, onError) {
+    const list = useMemo(() => (events === undefined ? [] : [events]).concat(eventSources ?? []).map(normalize), [events, eventSources]);
+    const latest = useRef({ list, onError });
+    latest.current = { list, onError };
+    // fetched results by source position; kept while a new range loads so the grid doesn't blink
+    const [fetched, setFetched] = useState({});
+    const [loading, setLoading] = useState(false);
+    const dynKey = list
+        .map(s => typeof s.input === 'function'
+        ? 'fn'
+        : Array.isArray(s.input)
+            ? ''
+            : JSON.stringify([s.input.url, s.input.method]))
+        .join('|');
+    const from = range.start.valueOf();
+    const to = range.end.valueOf();
+    useEffect(() => {
+        const dynamic = latest.current.list.flatMap((s, i) => (Array.isArray(s.input) ? [] : [{ s, i }]));
+        if (!dynamic.length) {
+            setLoading(false);
+            return undefined;
+        }
+        const ctl = new AbortController();
+        setLoading(true);
+        Promise.all(dynamic.map(async ({ s, i }) => {
+            try {
+                const events = await load(s, range, ctl.signal);
+                if (!ctl.signal.aborted)
+                    setFetched(f => ({ ...f, [i]: events }));
+            }
+            catch (err) {
+                if (!ctl.signal.aborted)
+                    latest.current.onError?.(err instanceof Error ? err : new Error(String(err)));
+            }
+        })).then(() => {
+            if (!ctl.signal.aborted)
+                setLoading(false);
+        });
+        return () => ctl.abort();
+    }, [from, to, dynKey]);
+    const lastLoading = useRef(false);
+    useEffect(() => {
+        if (lastLoading.current !== loading) {
+            lastLoading.current = loading;
+            onLoading?.(loading);
+        }
+    }, [loading, onLoading]);
+    const merged = useMemo(() => list.flatMap((s, i) => paint(Array.isArray(s.input) ? s.input : (fetched[i] ?? []), s)), [list, fetched]);
+    return { events: merged, loading };
+}

package/dist/calendar/useRecurrence.d.ts

@@ -0,0 +1,4 @@
+import type { LocaleDayjs } from '../types';
+import type { CalendarEvent, DateRange } from './types';
+/** Expand recurring events for `range`. The (rrule-sized) engine loads on first use; until then recurring events are held back. */
+export declare function useRecurrence(events: CalendarEvent[], range: DateRange, dayjs: LocaleDayjs): CalendarEvent[];

package/dist/calendar/useRecurrence.js

@@ -0,0 +1,15 @@
+import { useEffect, useMemo, useState } from 'react';
+/** Expand recurring events for `range`. The (rrule-sized) engine loads on first use; until then recurring events are held back. */
+export function useRecurrence(events, range, dayjs) {
+    const needed = useMemo(() => events.some(e => e.rrule || e.recurrence), [events]);
+    const [engine, setEngine] = useState();
+    useEffect(() => {
+        if (needed && !engine)
+            import('./recurrence').then(setEngine);
+    }, [needed, engine]);
+    return useMemo(() => {
+        if (!needed)
+            return events;
+        return engine ? engine.expandRecurring(events, range, dayjs) : events.filter(e => !e.rrule && !e.recurrence);
+    }, [events, needed, engine, range.start.valueOf(), range.end.valueOf(), dayjs]);
+}