@cocoar/vue-calendar 1.16.0

package/dist/core/types.d.ts

@@ -0,0 +1,211 @@
+import { Temporal } from '@js-temporal/polyfill';
+/**
+ * A single scheduled item.
+ *
+ * `start` (and the matching `end`) discriminates the event shape:
+ *   - `Temporal.ZonedDateTime` — timed event
+ *   - `Temporal.PlainDate`     — all-day event
+ *
+ * Recurring events are stored as rules (`rrule` + `rdate` +
+ * `exdate`) and expanded only for the visible window. A modified
+ * single occurrence is stored as a separate event with `parentId`
+ * and `recurrenceId` pointing at the original.
+ */
+export interface CalendarEvent<TMeta extends Record<string, unknown> = Record<string, unknown>> {
+    /**
+     * Stable identifier. For occurrences of a recurring event, this is
+     * the SERIES id — every expanded occurrence carries the same id.
+     * Distinguish individual occurrences by `recurrenceId`.
+     */
+    id: string;
+    /**
+     * Start of the event.
+     *   - `Temporal.ZonedDateTime` — timed event (carries local + IANA zone).
+     *   - `Temporal.PlainDate`     — all-day event.
+     *
+     * No other shapes accepted. Floating `PlainDateTime` throws because
+     * "local with no zone" is ambiguous; pass a `ZonedDateTime` with the
+     * intended source zone.
+     */
+    start: Temporal.ZonedDateTime | Temporal.PlainDate;
+    /**
+     * End of the event, EXCLUSIVE. Must match `start`'s shape:
+     *   - `start: ZonedDateTime` → `end?: ZonedDateTime` (any zone)
+     *   - `start: PlainDate`     → `end?: PlainDate`
+     *
+     * Cross-zone is allowed: `start.timeZoneId !== end.timeZoneId` is
+     * fine. The calendar renders in `builder.timezone()` (display zone)
+     * regardless.
+     *
+     * Defaults applied at index-insert if missing:
+     *   - timed → `start.add({ minutes: 30 })`
+     *   - all-day → `start.add({ days: 1 })`
+     */
+    end?: Temporal.ZonedDateTime | Temporal.PlainDate;
+    /**
+     * Anything the consumer needs in their renderer. The default
+     * event card reads:
+     *   - `meta.title?: string`
+     *   - `meta.color?: string` — CSS color or token
+     *   - `meta.icon?: string` — CoarIcon name
+     * Consumers needing more shape replace via the `#event` slot.
+     */
+    meta?: TMeta;
+}
+/**
+ * `true` when the event is timed (`start` is a `ZonedDateTime`).
+ *
+ * Duck-checks `'timeZoneId'` on the start value rather than using
+ * `instanceof` — survives realm boundaries (workers, iframes) and
+ * stays cheap in hot loops.
+ */
+export declare function isTimedEvent<T extends Record<string, unknown>>(e: CalendarEvent<T>): e is CalendarEvent<T> & {
+    start: Temporal.ZonedDateTime;
+    end?: Temporal.ZonedDateTime;
+};
+/**
+ * `true` when the event is all-day (`start` is a `PlainDate`).
+ */
+export declare function isAllDayEvent<T extends Record<string, unknown>>(e: CalendarEvent<T>): e is CalendarEvent<T> & {
+    start: Temporal.PlainDate;
+    end?: Temporal.PlainDate;
+};
+/**
+ * Throws if `event` violates the article-4 contract.
+ *
+ * Called by `EventIndex.insert` / `replaceAll` — consumers don't
+ * call this directly, but the error message names the offending id
+ * so it surfaces fast in dev.
+ *
+ * Reject reasons:
+ *   - `start` is not `ZonedDateTime` or `PlainDate` (catches strings,
+ *     `Date`, floating `PlainDateTime`, `Instant`, `PlainTime`,
+ *     `null`, `undefined`, arrays, etc.)
+ *   - `end` shape doesn't match `start`'s shape (mixed timed + all-day)
+ *   - `end` is not strictly after `start`
+ *
+ * Recurrence fields (`rrule` / `rdate` / `exdate` / `recurrenceId` /
+ * `parentId`) were removed in Phase 8.8e; if the consumer's `meta`
+ * carries `rrule` / `rdate`, a one-shot dev-mode warn fires telling
+ * them the engine isn't yet wired (Phase 4 will return the feature).
+ */
+export declare function validateCalendarEvent(event: CalendarEvent): void;
+/** Built-in view modes. Values stay as string literals so they
+ *  serialize cleanly in URLs / state. */
+export type CalendarView = 'month' | 'week' | 'day' | 'agenda' | 'timeline' | 'year';
+/**
+ * A visible date range bounded to a single view mode.
+ *
+ * `start` is inclusive, `end` is exclusive. Both are ISO-8601
+ * strings. For all-day-aware views (month, week, day, agenda) the
+ * bounds are date-only (`'2026-04-13'`); for time-grid views with
+ * subhour granularity, datetimes (`'2026-04-13T00:00:00'`) keep
+ * the math clean.
+ */
+export interface ViewWindow {
+    view: CalendarView;
+    /** ISO date (or datetime) — first visible boundary, inclusive. */
+    start: string;
+    /** ISO date (or datetime) — last boundary, exclusive. */
+    end: string;
+    /**
+     * IANA display timezone the window is anchored to. Required by
+     * `eventsLoader` callbacks so they can construct an instant range
+     * for backend queries — without this, the same `'2026-04-13'`
+     * means a different 24h slice in `Pacific/Kiritimati` (UTC+14) and
+     * `America/Los_Angeles` (UTC-8), and a "show in my zone" toggle
+     * would silently fetch the wrong events. Article 4: a date is not
+     * a point in time; pin the date+zone before deriving the instant.
+     */
+    timezone: string;
+}
+/**
+ * Recurrence rule for a `RecurringSeries`. The string form is an
+ * iCalendar RRULE (RFC 5545), e.g. `'FREQ=WEEKLY;BYDAY=MO,WE,FR'`.
+ *
+ * Stored as a plain string so the type contract doesn't lock the
+ * library into a specific RRULE parser. The engine (`core/recurrence.ts`)
+ * parses it at expansion time.
+ */
+export type RecurrencePattern = string;
+/**
+ * A recurring series — generates `CalendarEvent` occurrences within
+ * a visible window via `expandSeries(series, window, dstPolicy)`.
+ *
+ * **Article 5 alignment.** Recurring events MUST be local-time +
+ * IANA zone, never UTC. The `dtstart` field carries the local intent
+ * (`ZonedDateTime` for timed series, `PlainDate` for all-day series);
+ * the engine applies the same `DstPolicy` (C4) that governs drag/drop
+ * to gap/overlap occurrences.
+ *
+ * **C8 — separate from `CalendarEvent`.** This type does NOT appear
+ * as `event.meta.rrule` or any other event-level field.
+ * `validateCalendarEvent` dev-warns if a consumer tries that, telling
+ * them to use `RecurringSeries` instead.
+ *
+ * **Engine status (Session 2 stub).** `expandSeries` throws
+ * `not implemented yet — Phase 4` from `recurrence-public.ts`. The
+ * engine integration ships in Phase 4. Type contract exists so
+ * consumers can build their data layer against it from day one.
+ */
+export interface RecurringSeries<TMeta extends Record<string, unknown> = Record<string, unknown>> {
+    /** Stable series identifier — every expanded occurrence carries
+     *  this same id (distinguish occurrences via their `start` value). */
+    id: string;
+    /** RFC 5545 RRULE string. */
+    rrule: RecurrencePattern;
+    /**
+     * Start of the FIRST occurrence — Article 5 "store local intent".
+     *   - `ZonedDateTime` — timed series (carries source IANA zone).
+     *   - `PlainDate`     — all-day series.
+     */
+    dtstart: Temporal.ZonedDateTime | Temporal.PlainDate;
+    /**
+     * Optional duration applied to each generated occurrence's start
+     * to compute its end. **Day-count duration only (D2)** — no
+     * `Period` semantics. "+1 month" is permanently not supported for
+     * recurring occurrences because spans must be DST-stable.
+     *   - For timed series: `{ minutes: number }` and/or `{ hours: number }`.
+     *   - For all-day series: `{ days: number }`.
+     */
+    duration?: {
+        minutes?: number;
+        hours?: number;
+        days?: number;
+    };
+    /** Explicit additional dates the rule didn't generate (RDATE). */
+    rdate?: ReadonlyArray<Temporal.ZonedDateTime | Temporal.PlainDate>;
+    /** Explicit dates to exclude from rule output (EXDATE). */
+    exdate?: ReadonlyArray<Temporal.ZonedDateTime | Temporal.PlainDate>;
+    /** Per-series metadata, copied onto every expanded occurrence. */
+    meta?: TMeta;
+}
+/**
+ * Window for `expandSeries` — the visible range to generate
+ * occurrences for. Bounds are inclusive-start / exclusive-end (same
+ * convention as `ViewWindow`).
+ */
+export interface RecurrenceExpansionWindow {
+    /** Inclusive start of the visible range. */
+    start: Temporal.ZonedDateTime;
+    /** Exclusive end of the visible range. */
+    end: Temporal.ZonedDateTime;
+}
+/**
+ * Resolved locale + timezone context the calendar uses for rendering.
+ *
+ * Resolved (not just "locale: 'de-AT'") because the calendar applies
+ * many small formatting decisions in tight loops and recomputing
+ * the resolution per render is wasteful. Build once, pass down.
+ */
+export interface ResolvedLocale {
+    /** BCP-47 language tag, e.g. `'de-AT'`. */
+    language: string;
+    /** 0 = Sun, 1 = Mon (ISO), …, 6 = Sat. */
+    firstDayOfWeek: 0 | 1 | 2 | 3 | 4 | 5 | 6;
+    /** IANA timezone, e.g. `'Europe/Vienna'`. */
+    timezone: string;
+    /** Derived from Intl — true for 12-hour locales, false for 24-hour. */
+    hour12: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/core/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/core/types.ts"],"names":[],"mappings":"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"}

package/dist/core/viewWindow.d.ts

@@ -0,0 +1,53 @@
+import { Temporal } from '@js-temporal/polyfill';
+import { DayOfWeek } from './temporal';
+import { CalendarView, ViewWindow } from './types';
+export interface ViewWindowOptions {
+    view: CalendarView;
+    /** Cursor date — the date the user is "looking at". */
+    cursor: Temporal.PlainDate;
+    /** Used for week-aligned views (month, week). 0 = Sun … 6 = Sat. */
+    firstDayOfWeek: DayOfWeek;
+    /**
+     * Agenda-view length in days. Default 30 (about a month forward).
+     * Ignored for non-agenda views.
+     */
+    agendaLengthDays?: number;
+    /**
+     * IANA display timezone — written through to `ViewWindow.timezone`
+     * so loaders can derive the correct instant range.
+     */
+    timezone: string;
+}
+/**
+ * Compute the visible date range for a calendar view.
+ *
+ * @returns ViewWindow with `start` inclusive and `end` exclusive,
+ *          both as `YYYY-MM-DD` strings.
+ */
+export declare function computeViewWindow(opts: ViewWindowOptions): ViewWindow;
+/**
+ * Iterate the days inside a window (inclusive start, exclusive end).
+ *
+ * Useful for views that render per-day (agenda groups, week columns).
+ */
+export declare function daysInWindow(window: ViewWindow): Generator<Temporal.PlainDate>;
+/**
+ * Number of days in the window (always integer; end-start in days).
+ */
+export declare function windowDayCount(window: ViewWindow): number;
+/**
+ * True when `date` falls inside `window` (inclusive start, exclusive end).
+ */
+export declare function windowContainsDate(window: ViewWindow, date: Temporal.PlainDate): boolean;
+/**
+ * Navigate forward / backward by one logical "page" in the view.
+ *
+ * - day: ±1 day
+ * - week: ±7 days
+ * - month: ±1 month (from the cursor's calendar month)
+ * - agenda: ± agendaLengthDays
+ *
+ * Returns the new cursor for the next computeViewWindow call.
+ */
+export declare function navigateCursor(view: CalendarView, cursor: Temporal.PlainDate, direction: 'prev' | 'next', agendaLengthDays?: number): Temporal.PlainDate;
+//# sourceMappingURL=viewWindow.d.ts.map

package/dist/core/viewWindow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"viewWindow.d.ts","sourceRoot":"","sources":["../../src/core/viewWindow.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AACjD,OAAO,EACL,KAAK,SAAS,EAGf,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAExD,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,YAAY,CAAC;IACnB,uDAAuD;IACvD,MAAM,EAAE,QAAQ,CAAC,SAAS,CAAC;IAC3B,oEAAoE;IACpE,cAAc,EAAE,SAAS,CAAC;IAC1B;;;OAGG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B;;;OAGG;IACH,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,iBAAiB,GAAG,UAAU,CAiErE;AAID;;;;GAIG;AACH,wBAAiB,YAAY,CAAC,MAAM,EAAE,UAAU,GAAG,SAAS,CAAC,QAAQ,CAAC,SAAS,CAAC,CAO/E;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,CAIzD;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,QAAQ,CAAC,SAAS,GAAG,OAAO,CAOxF;AAED;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,YAAY,EAClB,MAAM,EAAE,QAAQ,CAAC,SAAS,EAC1B,SAAS,EAAE,MAAM,GAAG,MAAM,EAC1B,gBAAgB,SAAK,GACpB,QAAQ,CAAC,SAAS,CAyBpB"}

package/dist/core/virtualScroll.d.ts

@@ -0,0 +1,91 @@
+import { MeasurementCache } from './measurementCache';
+export interface Range1D {
+    /** Index of the first item to render (inclusive). */
+    startIndex: number;
+    /** Index just past the last item to render (exclusive). */
+    endIndex: number;
+    /**
+     * Pixels to translate the rendered window's first item by. Equals
+     * `prefixSum(startIndex)`. The component subtracts the scroll offset
+     * from this when applying the actual transform.
+     */
+    offset: number;
+    /**
+     * Total pixels of all items. Used to size the scroll spacer so the
+     * native scrollbar tracks the full virtual length.
+     */
+    totalSize: number;
+}
+/**
+ * Compute which items should be in the rendered window for a given scroll
+ * position.
+ *
+ * @param measurements  size cache (also encodes `itemCount`)
+ * @param scrollOffset  current scroll position in pixels (0 = top)
+ * @param viewportSize  visible viewport size in pixels
+ * @param overscan      number of extra items to render beyond the visible
+ *                      window in each direction (default 3)
+ *
+ * Invariants (proven in tests):
+ *   - 0 ≤ startIndex ≤ endIndex ≤ itemCount
+ *   - offset === prefixSum(startIndex)
+ *   - totalSize === prefixSum(itemCount)
+ *   - Every pixel in `[scrollOffset, scrollOffset + viewportSize)` that
+ *     intersects an item is covered by the rendered range
+ *     `[startIndex, endIndex)`
+ *   - Empty surface (itemCount === 0) returns `{ 0, 0, 0, 0 }`
+ */
+export declare function getVisibleRange1D(measurements: MeasurementCache, scrollOffset: number, viewportSize: number, overscan?: number): Range1D;
+/**
+ * 2D visible range — produced by composing two 1D ranges, one per axis.
+ *
+ * 2D virtualization is, at the math layer, nothing more than two
+ * independent 1D ranges side-by-side. There is no shared state between
+ * the axes; this `Range2D` type is just the natural pair shape returned
+ * by `getVisibleRange2D` for consumers that want both ranges at once.
+ *
+ * The Vue 2D surface component (`<VirtualizedSurface2D>`) renders the
+ * Cartesian product of `x` and `y` as absolutely-positioned cells.
+ */
+export interface Range2D {
+    x: Range1D;
+    y: Range1D;
+}
+/**
+ * Compose two `getVisibleRange1D` calls into a 2D range.
+ *
+ * The 2D surface's responsibility is just to render the Cartesian
+ * product of `[x.startIndex, x.endIndex)` × `[y.startIndex, y.endIndex)`
+ * with each cell positioned at `(prefixSum_x(cx), prefixSum_y(cy))`.
+ *
+ * Provided as a thin convenience so the 2D component doesn't need to
+ * manage two separate range computations directly. Same overscan, same
+ * input validation rules as the 1D function, applied per axis.
+ */
+export declare function getVisibleRange2D(measurementsX: MeasurementCache, measurementsY: MeasurementCache, scrollX: number, scrollY: number, viewportWidth: number, viewportHeight: number, overscanX?: number, overscanY?: number): Range2D;
+/**
+ * When item sizes change (new measurements, items inserted/removed above
+ * the viewport), the scroll offset must be adjusted so the user-visible
+ * content stays where it is. This function returns the **delta** to add
+ * to `scrollOffset` to keep `anchorIndex`'s viewport position constant.
+ *
+ * The math is deliberately one-line:
+ *
+ *   viewportPos(item) = prefixSum(item) - scrollOffset
+ *
+ *   We want: newPrefixSum(anchor) - newScroll = oldPrefixSum(anchor) - oldScroll
+ *   =>       newScroll - oldScroll = newPrefixSum(anchor) - oldPrefixSum(anchor)
+ *   =>       delta = newPrefixSum(anchor) - oldPrefixSum(anchor)
+ *
+ * The function does NOT mutate scroll. The caller (the component) decides
+ * whether to apply the delta — it may want to animate, debounce, or skip
+ * if the user is actively scrolling.
+ *
+ * @param oldMeasurements  cache state BEFORE the size change
+ * @param newMeasurements  cache state AFTER the size change
+ * @param anchorIndex      the item we want to keep visually stable
+ * @returns                pixels to add to scroll offset (positive = scroll
+ *                         further down to compensate for items growing)
+ */
+export declare function computeAnchorAdjustment(oldMeasurements: MeasurementCache, newMeasurements: MeasurementCache, anchorIndex: number): number;
+//# sourceMappingURL=virtualScroll.d.ts.map

package/dist/core/virtualScroll.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"virtualScroll.d.ts","sourceRoot":"","sources":["../../src/core/virtualScroll.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAEtD,MAAM,WAAW,OAAO;IACtB,qDAAqD;IACrD,UAAU,EAAE,MAAM,CAAC;IACnB,2DAA2D;IAC3D,QAAQ,EAAE,MAAM,CAAC;IACjB;;;;OAIG;IACH,MAAM,EAAE,MAAM,CAAC;IACf;;;OAGG;IACH,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,iBAAiB,CAC/B,YAAY,EAAE,gBAAgB,EAC9B,YAAY,EAAE,MAAM,EACpB,YAAY,EAAE,MAAM,EACpB,QAAQ,SAAI,GACX,OAAO,CAwCT;AAED;;;;;;;;;;GAUG;AACH,MAAM,WAAW,OAAO;IACtB,CAAC,EAAE,OAAO,CAAC;IACX,CAAC,EAAE,OAAO,CAAC;CACZ;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAC/B,aAAa,EAAE,gBAAgB,EAC/B,aAAa,EAAE,gBAAgB,EAC/B,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,aAAa,EAAE,MAAM,EACrB,cAAc,EAAE,MAAM,EACtB,SAAS,SAAI,EACb,SAAS,SAAI,GACZ,OAAO,CAKT;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,uBAAuB,CACrC,eAAe,EAAE,gBAAgB,EACjC,eAAe,EAAE,gBAAgB,EACjC,WAAW,EAAE,MAAM,GAClB,MAAM,CAUR"}