@cocoar/vue-calendar 1.16.0

package/dist/core/dnd/move-math.d.ts

@@ -0,0 +1,136 @@
+import { Temporal } from '@js-temporal/polyfill';
+import { CalendarEvent } from '../types';
+import { DstPolicy } from '../temporal';
+/** Minimum duration of a resized timed event, in minutes. */
+export declare const MIN_RESIZE_MINUTES = 15;
+/**
+ * One-of for every drag-mode the calendar surfaces. Imported by
+ * the move-math entry point so consumers don't need to depend on
+ * the `useCalendarDnd` composable to call this function.
+ */
+export type CalendarDragMode = 'timed' | 'timed-resize-start' | 'timed-resize-end' | 'allDay' | 'allDay-resize-start' | 'allDay-resize-end' | 'month' | 'month-resize-start' | 'month-resize-end';
+/**
+ * DST disambiguation outcome — set by `applyMoveToEvent` whenever
+ * the resolved target date+time hits a spring-forward gap or a
+ * fall-back overlap in the event's source zone.
+ *
+ *   - `null`      — clean conversion, no DST event happened.
+ *   - `'gap'`     — date+time doesn't exist (e.g. 02:30 on 2026-03-29
+ *                    Vienna). Result has been resolved per the active
+ *                    `DstPolicy`; consumers can show a "we shifted
+ *                    your meeting" toast.
+ *   - `'overlap'` — date+time exists twice (e.g. 02:30 on 2026-10-25
+ *                    Vienna). Result picked one per `DstPolicy`.
+ *
+ * **Note (Article 3 — fairness contract):** the flag reflects the DST
+ * situation in the DISPLAY zone — i.e. what the user actually saw and
+ * clicked. For a cross-zone event (Tokyo source rendered in Vienna),
+ * a drop on the Vienna spring-forward gap reports `'gap'` because
+ * that's the user's experience; the resulting `next.start` lives in
+ * the source zone (Tokyo) where there is no gap. This is intentional:
+ * the consumer's UI ("we shifted your meeting") is anchored to the
+ * user's perception, not to the storage zone.
+ */
+export type DstDisambiguation = null | 'gap' | 'overlap';
+/** Snapped drop target produced by hit-tests. */
+export interface CalendarDropTarget {
+    /** ISO date string `'YYYY-MM-DD'` of the drop day. */
+    date: string;
+    /**
+     * Minute-of-day in the DISPLAY zone (`displayZone`), or `null`
+     * when the target is in an all-day band / month cell with no
+     * time component.
+     */
+    minutes: number | null;
+    /**
+     * IANA timezone the calendar renders in — the one `target.minutes`
+     * is anchored to. Required for timed targets so move-math can
+     * resolve the slot in the right zone (Article-4 fix for the bug
+     * where targets were resolved as UTC).
+     */
+    displayZone: string;
+    /** Whether `canDrop()` (if any) accepted this target. */
+    valid: boolean;
+}
+/**
+ * Re-exported `DstPolicy` — single source of truth lives in
+ * `../temporal.ts`. Code MUST import from one of the public paths
+ * and never re-declare it (drift hazard).
+ */
+export type { DstPolicy } from '../temporal';
+/**
+ * Thrown by `applyMoveToEvent` when `dstPolicy === 'reject'` and the
+ * target falls in a DST gap or overlap. The drop layer translates
+ * this into `valid=false` so the snap-back animation fires.
+ */
+export declare class DstResolutionError extends Error {
+    readonly disambiguation: 'gap' | 'overlap';
+    constructor(disambiguation: 'gap' | 'overlap', message: string);
+}
+/**
+ * Result shape of `applyMoveToEvent`. The shape mirrors the input
+ * event: `ZonedDateTime` for timed events, `PlainDate` for all-day.
+ *
+ * `disambiguation` is set whenever the resolved start landed on a DST
+ * gap or overlap in the event's source zone (or, for resize modes,
+ * the moved end). `null` for clean conversions, all-day moves, or
+ * when the policy was `'reject'` (in which case the function throws
+ * before returning).
+ */
+export type MoveResult = {
+    start: Temporal.ZonedDateTime;
+    end?: Temporal.ZonedDateTime;
+    disambiguation?: DstDisambiguation;
+} | {
+    start: Temporal.PlainDate;
+    end?: Temporal.PlainDate;
+    disambiguation?: DstDisambiguation;
+};
+/**
+ * Shape of the payload fired by `onEventDrop`. Same layout for every
+ * drag mode (mouse / keyboard / touch) and every drop site (time-grid
+ * / month / agenda) — produced by `buildDropPayload` exactly once per
+ * commit.
+ */
+export interface EventDropPayload<TMeta extends Record<string, unknown> = Record<string, unknown>> {
+    event: CalendarEvent<TMeta>;
+    /** Snapshot at drag-start. `displayZone` is the zone the user
+     *  STARTED viewing in (a mid-drag `.timezone()` swap is allowed). */
+    original: {
+        start: Temporal.ZonedDateTime | Temporal.PlainDate;
+        end?: Temporal.ZonedDateTime | Temporal.PlainDate;
+        displayZone: string;
+    };
+    /** Resolved next event state — per-endpoint source zones preserved
+     *  (C3). */
+    next: MoveResult;
+    /** Drop slot the cursor was over. `displayZone` here is the
+     *  CURRENT display zone (may differ from `original.displayZone`). */
+    target: {
+        date: string;
+        minutes: number | null;
+        displayZone: string;
+        disambiguation: DstDisambiguation;
+    };
+    native: PointerEvent | null;
+}
+/**
+ * The ONE function that produces an `EventDropPayload` from a drop.
+ *
+ * **C2 — every drop path reaches THIS function exactly once.** Mouse
+ * drop, keyboard Enter, touch end — they all funnel here. Outside of
+ * this file, `applyMoveToEvent` is only called for preview ghost
+ * geometry (which produces identical math, so preview-vs-commit
+ * drift is structurally impossible).
+ *
+ * **Throws** `DstResolutionError` if `dstPolicy === 'reject'` and the
+ * wall-time falls in a DST gap. The caller (composable) catches it
+ * and translates to "drop suppressed".
+ */
+export declare function buildDropPayload<TMeta extends Record<string, unknown> = Record<string, unknown>>(dstPolicy: DstPolicy, event: CalendarEvent<TMeta>, originalSnapshot: {
+    start: Temporal.ZonedDateTime | Temporal.PlainDate;
+    end?: Temporal.ZonedDateTime | Temporal.PlainDate;
+    displayZone: string;
+}, target: CalendarDropTarget, mode: CalendarDragMode, native: PointerEvent | null): EventDropPayload<TMeta>;
+export declare function applyMoveToEvent(event: CalendarEvent, target: CalendarDropTarget, mode: CalendarDragMode | null, dstPolicy?: DstPolicy): MoveResult;
+//# sourceMappingURL=move-math.d.ts.map

package/dist/core/dnd/move-math.d.ts.map

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

package/dist/core/dragHitTest.d.ts

@@ -0,0 +1,74 @@
+import { MeasurementCache } from './measurementCache';
+export interface VerticalHit {
+    /** 0-based item index, or -1 if the pointer is outside the item region. */
+    itemIndex: number;
+    /**
+     * Position within the item, 0..1. 0 = at the top edge, 1 = at the
+     * bottom edge. Useful for "drop above/below" semantics: < 0.5 is
+     * the top half, ≥ 0.5 is the bottom half.
+     *
+     * NaN if `itemIndex === -1`.
+     */
+    ratio: number;
+    /**
+     * Pixel offset within the item, 0..size. Cheaper than recomputing
+     * for callers that need it.
+     */
+    pixelInItem: number;
+}
+/**
+ * Hit-test a vertical surface (`<VirtualizedSurface1DY>` or any
+ * scroll container with measured items). Returns which item the
+ * pointer is over, plus the position within that item.
+ *
+ * @param pointerScreenY  the pointer's screen y-coordinate
+ *                        (from `event.clientY`)
+ * @param surfaceTopScreenY  the surface's top-edge screen y-coordinate
+ *                           (from `surfaceEl.getBoundingClientRect().top`)
+ * @param scrollTop  the surface's current `scrollTop`
+ * @param measurements  the surface's measurement cache (or compatible
+ *                      stand-in for fixed-size mode)
+ * @param surfaceHeight  optional viewport height; if provided, points
+ *                       outside `[surfaceTopScreenY, surfaceTopScreenY +
+ *                       surfaceHeight)` return `itemIndex = -1`
+ */
+export declare function hitTestVerticalSurface(pointerScreenY: number, surfaceTopScreenY: number, scrollTop: number, measurements: MeasurementCache, surfaceHeight?: number): VerticalHit;
+export interface AutoScrollOptions {
+    /** Hot-zone thickness near each edge in pixels. Default 30. */
+    hotZone?: number;
+    /** Max scroll velocity in px/frame. Default 24 (≈ 1440 px/sec @ 60fps). */
+    maxVelocity?: number;
+    /**
+     * Curve applied to the linear penetration ratio (0..1) before
+     * scaling to velocity. `'linear'` is the default; `'quadratic'`
+     * (the natural feeling — slow near the edge, fast at the corner)
+     * applies `r^2`.
+     */
+    curve?: 'linear' | 'quadratic';
+}
+export interface AutoScrollResult {
+    /**
+     * Velocity in px/frame for the X axis. Negative = scroll up, 0 =
+     * idle, positive = scroll down. (For X axis: negative = scroll
+     * left, positive = scroll right.)
+     */
+    velocityX: number;
+    velocityY: number;
+}
+/**
+ * Compute auto-scroll velocity for a pointer position relative to the
+ * surface viewport. Pure function — caller applies the velocity each
+ * frame.
+ *
+ * @param pointerScreenX pointer's screen-x (from `clientX`)
+ * @param pointerScreenY pointer's screen-y (from `clientY`)
+ * @param surfaceRect  surface's `getBoundingClientRect()`-shaped
+ *                     bounds (just the four numbers)
+ */
+export declare function computeAutoScrollVelocity(pointerScreenX: number, pointerScreenY: number, surfaceRect: {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+}, opts?: AutoScrollOptions): AutoScrollResult;
+//# sourceMappingURL=dragHitTest.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dragHitTest.d.ts","sourceRoot":"","sources":["../../src/core/dragHitTest.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAE3D,MAAM,WAAW,WAAW;IAC1B,2EAA2E;IAC3E,SAAS,EAAE,MAAM,CAAC;IAClB;;;;;;OAMG;IACH,KAAK,EAAE,MAAM,CAAC;IACd;;;OAGG;IACH,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,sBAAsB,CACpC,cAAc,EAAE,MAAM,EACtB,iBAAiB,EAAE,MAAM,EACzB,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,gBAAgB,EAC9B,aAAa,CAAC,EAAE,MAAM,GACrB,WAAW,CAiCb;AAID,MAAM,WAAW,iBAAiB;IAChC,+DAA+D;IAC/D,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,2EAA2E;IAC3E,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;;OAKG;IACH,KAAK,CAAC,EAAE,QAAQ,GAAG,WAAW,CAAC;CAChC;AAED,MAAM,WAAW,gBAAgB;IAC/B;;;;OAIG;IACH,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;;GASG;AACH,wBAAgB,yBAAyB,CACvC,cAAc,EAAE,MAAM,EACtB,cAAc,EAAE,MAAM,EACtB,WAAW,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,EACzE,IAAI,GAAE,iBAAsB,GAC3B,gBAAgB,CA2ClB"}

package/dist/core/eventIndex.d.ts

@@ -0,0 +1,106 @@
+import { Temporal } from '@js-temporal/polyfill';
+import { CalendarEvent, ViewWindow } from './types';
+/**
+ * What changed in the index. Granular kinds let consumers update
+ * only affected views: changing one event's color need not
+ * re-render the whole month.
+ */
+export type IndexInvalidation = {
+    kind: 'day';
+    date: string;
+} | {
+    kind: 'range';
+    start: string;
+    end: string;
+} | {
+    kind: 'series';
+    seriesId: string;
+} | {
+    kind: 'all';
+};
+export type IndexListener = (invalidation: IndexInvalidation) => void;
+export interface EventIndexOptions {
+    /**
+     * Display timezone used to bucket timed events into calendar days.
+     * **Required** since Phase 8.10-D. Article 4: defaults are not
+     * decisions. Pass the user's IANA zone — the same one resolved in
+     * `ResolvedLocale.timezone`. Empty string is rejected.
+     */
+    timezone: string;
+}
+export declare class EventIndex<TMeta extends Record<string, unknown> = Record<string, unknown>> {
+    private buckets;
+    /**
+     * Reverse-index from event id to the day-keys it currently
+     * occupies. Used so `update` / `remove` can locate the buckets
+     * without scanning.
+     */
+    private byId;
+    private listeners;
+    private timezone;
+    constructor(opts: EventIndexOptions);
+    /**
+     * Switch the display zone used to bucket TIMED events into days,
+     * and rebuild every bucket. Required when `builder.timezone()`
+     * changes at runtime — without a rebuild, near-midnight events
+     * stay in the wrong day's bucket and `byDay` / `byRange` lie.
+     *
+     * Cheap on small data, O(N · avg_span_days) on large data; emits
+     * a single `'all'` invalidation so views fully re-render once.
+     * No-op when `tz` equals the current zone.
+     */
+    setTimezone(tz: string): void;
+    /** Read the active display zone. Useful for tests / diagnostics. */
+    getTimezone(): string;
+    /**
+     * Insert (or replace) an event. If the event's id already exists,
+     * the old version is removed first.
+     */
+    insert(event: CalendarEvent<TMeta>): void;
+    /**
+     * Update an existing event. Equivalent to `insert(event)` but
+     * emits a `series` invalidation rather than insert's same kind —
+     * semantically identical at this level.
+     */
+    update(event: CalendarEvent<TMeta>): void;
+    /**
+     * Remove an event by id. No-op if the id is unknown.
+     */
+    remove(id: string): void;
+    private _removeWithoutEmit;
+    /** Empty the index. Emits a single `'all'` invalidation. */
+    clear(): void;
+    /**
+     * Bulk-replace the index from a fresh array. Faster than calling
+     * `insert` per event because it builds the buckets in one pass
+     * and emits a single `'all'` invalidation.
+     */
+    replaceAll(events: ReadonlyArray<CalendarEvent<TMeta>>): void;
+    /** Events that intersect the given day. Order: insertion order. */
+    byDay(date: string | Temporal.PlainDate): readonly CalendarEvent<TMeta>[];
+    /**
+     * Events that intersect the given window. Each event appears at
+     * most once in the result, even if it spans multiple days inside
+     * the window.
+     */
+    byRange(window: ViewWindow): readonly CalendarEvent<TMeta>[];
+    /** Total number of distinct events currently indexed. */
+    get size(): number;
+    /** Subscribe to index changes. Returns an unsubscribe fn. */
+    subscribe(listener: IndexListener): () => void;
+    private emit;
+    /**
+     * Compute the list of `YYYY-MM-DD` day-keys an event occupies.
+     *
+     * For all-day events, the span is straightforward (PlainDate
+     * arithmetic). For timed events, we re-zone into the configured
+     * display zone and bucket by local day; `end` exactly at midnight
+     * counts as ending the previous day (RFC 5545 exclusive-end).
+     *
+     * Defaults:
+     *   - `end` missing for all-day → `start + 1 day` exclusive
+     *   - `end` missing for timed → same day as `start` (single bucket)
+     */
+    private spanDayKeys;
+}
+//# sourceMappingURL=eventIndex.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"eventIndex.d.ts","sourceRoot":"","sources":["../../src/core/eventIndex.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AACjD,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAMzD;;;;GAIG;AACH,MAAM,MAAM,iBAAiB,GACzB;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAC7B;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GAC7C;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GACpC;IAAE,IAAI,EAAE,KAAK,CAAA;CAAE,CAAC;AAEpB,MAAM,MAAM,aAAa,GAAG,CAAC,YAAY,EAAE,iBAAiB,KAAK,IAAI,CAAC;AAItE,MAAM,WAAW,iBAAiB;IAChC;;;;;OAKG;IACH,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,qBAAa,UAAU,CAAC,KAAK,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IACrF,OAAO,CAAC,OAAO,CAA6C;IAC5D;;;;OAIG;IACH,OAAO,CAAC,IAAI,CAA+B;IAC3C,OAAO,CAAC,SAAS,CAA4B;IAC7C,OAAO,CAAC,QAAQ,CAAS;gBAEb,IAAI,EAAE,iBAAiB;IAYnC;;;;;;;;;OASG;IACH,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IA8B7B,oEAAoE;IACpE,WAAW,IAAI,MAAM;IAMrB;;;OAGG;IACH,MAAM,CAAC,KAAK,EAAE,aAAa,CAAC,KAAK,CAAC,GAAG,IAAI;IAezC;;;;OAIG;IACH,MAAM,CAAC,KAAK,EAAE,aAAa,CAAC,KAAK,CAAC,GAAG,IAAI;IAIzC;;OAEG;IACH,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAMxB,OAAO,CAAC,kBAAkB;IAc1B,4DAA4D;IAC5D,KAAK,IAAI,IAAI;IAMb;;;;OAIG;IACH,UAAU,CAAC,MAAM,EAAE,aAAa,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,GAAG,IAAI;IAkB7D,mEAAmE;IACnE,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,CAAC,SAAS,GAAG,SAAS,aAAa,CAAC,KAAK,CAAC,EAAE;IAKzE;;;;OAIG;IACH,OAAO,CAAC,MAAM,EAAE,UAAU,GAAG,SAAS,aAAa,CAAC,KAAK,CAAC,EAAE;IAqB5D,yDAAyD;IACzD,IAAI,IAAI,IAAI,MAAM,CAEjB;IAID,6DAA6D;IAC7D,SAAS,CAAC,QAAQ,EAAE,aAAa,GAAG,MAAM,IAAI;IAK9C,OAAO,CAAC,IAAI;IAaZ;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,WAAW;CA0CpB"}

package/dist/core/index.d.ts

@@ -0,0 +1,32 @@
+/**
+ * `@cocoar/vue-calendar/core` — framework-agnostic layer.
+ *
+ * Files in this directory must NOT import from `../components/` or
+ * `../composables/`. The lint rule in the repo root enforces this.
+ *
+ * Phase 0 contents:
+ *   - measurementCache.ts  — Fenwick-tree-backed variable-size cache
+ *   - virtualScroll.ts     — pure range math + anchor adjustment
+ *
+ * Phase 1 will add:
+ *   - temporal.ts          — Temporal helpers (lifted from @cocoar/vue-ui)
+ *   - eventIndex.ts        — Map<dateKey, Event[]> with granular invalidation
+ *   - viewWindow.ts        — week/month/agenda window math
+ *   - overlapLayout.ts     — multi-day-bar interval-graph coloring
+ *   - recurrence.ts        — engine abstraction (rrule-rust + rrule.js)
+ *   - worker/recurrenceWorker.ts — off-main-thread expansion
+ */
+export type { CalendarEvent, CalendarView, ViewWindow, ResolvedLocale, RecurringSeries, RecurrencePattern, RecurrenceExpansionWindow, } from './types';
+export { isTimedEvent, isAllDayEvent, validateCalendarEvent, } from './types';
+export { Temporal, type DayOfWeek, detectFirstDayOfWeekFromLocale, detectHour12FromLocale, detectBrowserTimezone, startOfWeek, endOfWeek, startOfMonth, endOfMonth, isoWeekNumber, weekDates, monthGridDates, localizedWeekdayNames, dateKey, eventStartDateInZone, todayInZone, nowInZone, buildFormatOptions, type FormatOverrides, parseScheduledTime, parsePlainDate, formatScheduledTime, type ScheduledTimeWire, type DstPolicy, } from './temporal';
+export { expandSeries, EXPAND_SERIES_NOT_IMPLEMENTED_MESSAGE, } from './recurrence-public';
+export { computeViewWindow, daysInWindow, windowDayCount, windowContainsDate, navigateCursor, type ViewWindowOptions, } from './viewWindow';
+export { layoutDayEvents, layoutAllDayBand, type DayLayoutOptions, type AllDayBandOptions, type PositionedEvent, type AllDayBar, } from './timeGridLayout';
+export { layoutMonthGrid, type MonthLayout, type MonthLayoutOptions, type MonthWeekRow, type MonthMultiDayBar, type MonthCellPill, } from './monthGridLayout';
+export { buildAgendaItems, type AgendaItem, type AgendaHeaderItem, type AgendaEventItem, type AgendaLayoutOptions, } from './agendaLayout';
+export { MeasurementCache } from './measurementCache';
+export { getVisibleRange1D, getVisibleRange2D, computeAnchorAdjustment, type Range1D, type Range2D, } from './virtualScroll';
+export { layoutOverlappingIntervals, type IntervalInput, type IntervalLayout, type LayoutResult, } from './overlapLayout';
+export { hitTestVerticalSurface, computeAutoScrollVelocity, type VerticalHit, type AutoScrollOptions, type AutoScrollResult, } from './dragHitTest';
+export { applyMoveToEvent, buildDropPayload, DstResolutionError, MIN_RESIZE_MINUTES, type CalendarDragMode, type CalendarDropTarget, type DstDisambiguation, type EventDropPayload, type MoveResult, } from './dnd/move-math';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,YAAY,EACV,aAAa,EACb,YAAY,EACZ,UAAU,EACV,cAAc,EAEd,eAAe,EACf,iBAAiB,EACjB,yBAAyB,GAC1B,MAAM,SAAS,CAAC;AACjB,OAAO,EACL,YAAY,EACZ,aAAa,EACb,qBAAqB,GACtB,MAAM,SAAS,CAAC;AACjB,OAAO,EACL,QAAQ,EACR,KAAK,SAAS,EACd,8BAA8B,EAC9B,sBAAsB,EACtB,qBAAqB,EACrB,WAAW,EACX,SAAS,EACT,YAAY,EACZ,UAAU,EACV,aAAa,EACb,SAAS,EACT,cAAc,EACd,qBAAqB,EACrB,OAAO,EACP,oBAAoB,EACpB,WAAW,EACX,SAAS,EACT,kBAAkB,EAClB,KAAK,eAAe,EAEpB,kBAAkB,EAClB,cAAc,EACd,mBAAmB,EACnB,KAAK,iBAAiB,EACtB,KAAK,SAAS,GACf,MAAM,YAAY,CAAC;AAEpB,OAAO,EACL,YAAY,EACZ,qCAAqC,GACtC,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,iBAAiB,EACjB,YAAY,EACZ,cAAc,EACd,kBAAkB,EAClB,cAAc,EACd,KAAK,iBAAiB,GACvB,MAAM,cAAc,CAAC;AAYtB,OAAO,EACL,eAAe,EACf,gBAAgB,EAChB,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,EACtB,KAAK,eAAe,EACpB,KAAK,SAAS,GACf,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,eAAe,EACf,KAAK,WAAW,EAChB,KAAK,kBAAkB,EACvB,KAAK,YAAY,EACjB,KAAK,gBAAgB,EACrB,KAAK,aAAa,GACnB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,gBAAgB,EAChB,KAAK,UAAU,EACf,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACpB,KAAK,mBAAmB,GACzB,MAAM,gBAAgB,CAAC;AAUxB,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EACL,iBAAiB,EACjB,iBAAiB,EACjB,uBAAuB,EACvB,KAAK,OAAO,EACZ,KAAK,OAAO,GACb,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,0BAA0B,EAC1B,KAAK,aAAa,EAClB,KAAK,cAAc,EACnB,KAAK,YAAY,GAClB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,sBAAsB,EACtB,yBAAyB,EACzB,KAAK,WAAW,EAChB,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,GACtB,MAAM,eAAe,CAAC;AAOvB,OAAO,EACL,gBAAgB,EAChB,gBAAgB,EAChB,kBAAkB,EAClB,kBAAkB,EAClB,KAAK,gBAAgB,EACrB,KAAK,kBAAkB,EACvB,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EACrB,KAAK,UAAU,GAChB,MAAM,iBAAiB,CAAC"}

package/dist/core/measurementCache.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Variable-size virtualization needs three operations on item sizes, all of
+ * them in the hot path of every scroll frame:
+ *
+ *   1. `prefixSum(i)` — total pixels above item `i`
+ *   2. `indexAtOffset(px)` — which item is at scroll offset `px`
+ *   3. `set(i, size)` — update size of one item (e.g. on first measure)
+ *
+ * Naïve implementations are too slow at 10k items. A linear scan for prefix
+ * sum is O(n); recomputing every frame burns the entire budget.
+ *
+ * The implementation here uses a **Binary Indexed Tree (Fenwick tree)** to
+ * give all three ops in O(log n). The tree stores per-index *deltas from
+ * the size estimate*, so an unmeasured cache is a tree of zeros — no
+ * initialization pass needed at construction.
+ *
+ *   prefixSum(i)   = i * estimate + fenwickPrefixSum(i)
+ *   set(i, size)   updates fenwick by (size - estimate) - oldDelta
+ *   indexAtOffset  binary-searches over [0, count) using prefixSum
+ *
+ * For 10.000 items: each op is ≤ 14 fenwick steps × ≤ 14 binary-search
+ * steps = ~200 array reads. Sub-microsecond on the dev baseline.
+ *
+ * The cache is intentionally framework-agnostic. Vue components own
+ * `MeasurementCache` instances; they observe size changes via
+ * `ResizeObserver` and call `set()` from within a batched rAF.
+ */
+export declare class MeasurementCache {
+    /** Number of items represented in the cache. */
+    private _itemCount;
+    /** Estimated size used for any item that has not been measured. */
+    private _estimatedSize;
+    /**
+     * Indices that have a measured (non-estimate) size, mapped to that size.
+     * Used to compute the delta on re-measure and to answer `has()`.
+     */
+    private _measured;
+    /**
+     * Fenwick tree storing prefix sums of `(measured size - estimate)`. Index
+     * 0 is unused per Fenwick convention; tree[i] covers a span ending at i.
+     */
+    private _fenwick;
+    constructor(itemCount: number, estimatedSize: number);
+    get itemCount(): number;
+    get estimatedSize(): number;
+    get measuredCount(): number;
+    /** Returns true if `index` has a measured size (not just the estimate). */
+    has(index: number): boolean;
+    /** Size at `index` — measured value if present, else estimate. */
+    get(index: number): number;
+    /** Record a measured size for `index`. */
+    set(index: number, size: number): void;
+    /** Drop a measured value, falling back to the estimate. */
+    unset(index: number): void;
+    /** Drop everything; the cache reverts to all-estimates. */
+    clear(): void;
+    /**
+     * Change the item count. Existing measured indices that fall outside the
+     * new range are dropped. The caller is responsible for re-keying after a
+     * splice (inserting/removing in the middle invalidates indices above the
+     * splice point and is not handled here — `clear()` and remeasure is the
+     * supported path for that).
+     */
+    resize(newCount: number): void;
+    /**
+     * Sum of sizes of items in `[0, index)`. Returns 0 for `index <= 0`.
+     * Clamps `index > itemCount` to `itemCount`.
+     *
+     * O(log n).
+     */
+    prefixSum(index: number): number;
+    /** Total size = `prefixSum(itemCount)`. O(log n). */
+    totalSize(): number;
+    /**
+     * Smallest `i` such that `prefixSum(i + 1) > offset`. In other words:
+     * which item contains the pixel at `offset`?
+     *
+     * Returns 0 for `offset <= 0`. Returns `itemCount - 1` if offset is at or
+     * past the end (and `itemCount > 0`). Returns 0 if `itemCount === 0`.
+     *
+     * O(log² n) via binary search over `prefixSum`. Could be reduced to
+     * O(log n) with a Fenwick descent, but log² × log = ~200 reads at 10k
+     * items, dwarfed by the surrounding work. We keep the simpler form.
+     */
+    indexAtOffset(offset: number): number;
+}
+//# sourceMappingURL=measurementCache.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"measurementCache.d.ts","sourceRoot":"","sources":["../../src/core/measurementCache.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,qBAAa,gBAAgB;IAC3B,gDAAgD;IAChD,OAAO,CAAC,UAAU,CAAS;IAE3B,mEAAmE;IACnE,OAAO,CAAC,cAAc,CAAS;IAE/B;;;OAGG;IACH,OAAO,CAAC,SAAS,CAAsB;IAEvC;;;OAGG;IACH,OAAO,CAAC,QAAQ,CAAe;gBAEnB,SAAS,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM;IAepD,IAAI,SAAS,IAAI,MAAM,CAEtB;IAED,IAAI,aAAa,IAAI,MAAM,CAE1B;IAED,IAAI,aAAa,IAAI,MAAM,CAE1B;IAED,2EAA2E;IAC3E,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;IAI3B,kEAAkE;IAClE,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAS1B,0CAA0C;IAC1C,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI;IAwBtC,2DAA2D;IAC3D,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAiB1B,2DAA2D;IAC3D,KAAK,IAAI,IAAI;IAKb;;;;;;OAMG;IACH,MAAM,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IA8B9B;;;;;OAKG;IACH,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAahC,qDAAqD;IACrD,SAAS,IAAI,MAAM;IAInB;;;;;;;;;;OAUG;IACH,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;CAkBtC"}

package/dist/core/monthGridLayout.d.ts

@@ -0,0 +1,68 @@
+import { CalendarEvent } from './types';
+import { Temporal } from './temporal';
+export interface MonthMultiDayBar<TMeta extends Record<string, unknown> = Record<string, unknown>> {
+    event: CalendarEvent<TMeta>;
+    /** Lane within the week row. 0 = topmost. */
+    lane: number;
+    /** Total lanes used in this week row. */
+    laneCount: number;
+    /** Column 0..6 inclusive — first cell the bar covers. */
+    startCol: number;
+    /** Column 0..6 inclusive — last cell the bar covers. */
+    endCol: number;
+    /** True when the event extends earlier than the row's first day. */
+    clippedStart: boolean;
+    /** True when the event extends later than the row's last day. */
+    clippedEnd: boolean;
+}
+/**
+ * Single-day event rendered as a pill inside a specific cell.
+ * "Single-day" here means the event occupies exactly ONE day in
+ * the calendar — either a date-only event with no end, a date-only
+ * event with end == start + 1 day (RFC 5545 single-day all-day),
+ * or any timed event (timed events always render as pills, even
+ * if their wall-clock spans midnight, because their visual home
+ * in the month view is the start day).
+ */
+export interface MonthCellPill<TMeta extends Record<string, unknown> = Record<string, unknown>> {
+    event: CalendarEvent<TMeta>;
+    /** Visual order within the cell. Stable across renders for the
+     *  same input. */
+    order: number;
+}
+export interface MonthWeekRow<TMeta extends Record<string, unknown> = Record<string, unknown>> {
+    /** 0..5. */
+    rowIndex: number;
+    /** First date of the row (the cell-0 date). */
+    weekStart: Temporal.PlainDate;
+    /** All 7 dates of the row, in column order. */
+    days: ReadonlyArray<Temporal.PlainDate>;
+    /** Multi-day bars on this row, lane-resolved. */
+    multiDayBars: ReadonlyArray<MonthMultiDayBar<TMeta>>;
+    /** Per-cell single-day pills, indexed by `dateKey()`. */
+    cellPills: ReadonlyMap<string, ReadonlyArray<MonthCellPill<TMeta>>>;
+}
+export interface MonthLayout<TMeta extends Record<string, unknown> = Record<string, unknown>> {
+    /** Always 6 rows. */
+    weekRows: ReadonlyArray<MonthWeekRow<TMeta>>;
+}
+export interface MonthLayoutOptions {
+    /**
+     * The 42 dates of the month grid, in row-major order
+     * (cell 0 = top-left, cell 6 = top-right, cell 7 = next row,
+     * etc.). Use `monthGridDates(yearMonth, firstDayOfWeek)` from
+     * temporal.ts.
+     */
+    gridDates: ReadonlyArray<Temporal.PlainDate>;
+    /** Timezone for resolving timed events. */
+    timezone: string;
+}
+/**
+ * Compute the full layout for a month grid.
+ *
+ * Multi-day events that span across week-row boundaries are
+ * rendered as multiple bars (one per affected row), each correctly
+ * clipped to its row.
+ */
+export declare function layoutMonthGrid<TMeta extends Record<string, unknown> = Record<string, unknown>>(events: ReadonlyArray<CalendarEvent<TMeta>>, opts: MonthLayoutOptions): MonthLayout<TMeta>;
+//# sourceMappingURL=monthGridLayout.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"monthGridLayout.d.ts","sourceRoot":"","sources":["../../src/core/monthGridLayout.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAM7C,OAAO,EAAE,QAAQ,EAAiC,MAAM,YAAY,CAAC;AAIrE,MAAM,WAAW,gBAAgB,CAAC,KAAK,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAC/F,KAAK,EAAE,aAAa,CAAC,KAAK,CAAC,CAAC;IAC5B,6CAA6C;IAC7C,IAAI,EAAE,MAAM,CAAC;IACb,yCAAyC;IACzC,SAAS,EAAE,MAAM,CAAC;IAClB,yDAAyD;IACzD,QAAQ,EAAE,MAAM,CAAC;IACjB,wDAAwD;IACxD,MAAM,EAAE,MAAM,CAAC;IACf,oEAAoE;IACpE,YAAY,EAAE,OAAO,CAAC;IACtB,iEAAiE;IACjE,UAAU,EAAE,OAAO,CAAC;CACrB;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,aAAa,CAAC,KAAK,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAC5F,KAAK,EAAE,aAAa,CAAC,KAAK,CAAC,CAAC;IAC5B;sBACkB;IAClB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,YAAY,CAAC,KAAK,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAC3F,YAAY;IACZ,QAAQ,EAAE,MAAM,CAAC;IACjB,+CAA+C;IAC/C,SAAS,EAAE,QAAQ,CAAC,SAAS,CAAC;IAC9B,+CAA+C;IAC/C,IAAI,EAAE,aAAa,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC;IACxC,iDAAiD;IACjD,YAAY,EAAE,aAAa,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC,CAAC;IACrD,yDAAyD;IACzD,SAAS,EAAE,WAAW,CAAC,MAAM,EAAE,aAAa,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;CACrE;AAED,MAAM,WAAW,WAAW,CAAC,KAAK,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAC1F,qBAAqB;IACrB,QAAQ,EAAE,aAAa,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC;CAC9C;AAID,MAAM,WAAW,kBAAkB;IACjC;;;;;OAKG;IACH,SAAS,EAAE,aAAa,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC;IAC7C,2CAA2C;IAC3C,QAAQ,EAAE,MAAM,CAAC;CAClB;AAID;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,KAAK,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7F,MAAM,EAAE,aAAa,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,EAC3C,IAAI,EAAE,kBAAkB,GACvB,WAAW,CAAC,KAAK,CAAC,CAkJpB"}

package/dist/core/overlapLayout.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Multi-day-bar layout via interval-graph coloring.
+ *
+ * The classic calendar problem: given N events that span ranges of
+ * columns (e.g. days within a week row, or hours within a day
+ * column), assign each event a lane (vertical row inside the cell)
+ * such that no two events share a (lane × column) cell.
+ *
+ * Interval graphs are *perfect graphs*: their chromatic number
+ * equals their clique number. Greedy first-fit coloring sorted by
+ * start position is optimal — it uses the minimum number of lanes
+ * needed (= maximum overlap depth at any column).
+ *
+ * ── Algorithm ─────────────────────────────────────────────────────
+ *
+ * 1. Sort intervals by start ASC, then by end DESC, then by id ASC
+ *    (the secondary keys break ties deterministically; the primary
+ *    key is what makes the algorithm work).
+ * 2. Maintain a min-heap of `(endCol, laneId)` for intervals currently
+ *    active at the cursor's column. The heap top is the lane that
+ *    will free up earliest.
+ * 3. For each interval in sorted order:
+ *    a. Pop from the heap every entry whose `endCol < interval.start`
+ *       (those lanes are now free).
+ *    b. Pick the lowest-numbered free lane. We track free lanes in a
+ *       separate min-heap so this is O(log n).
+ *    c. Assign the interval that lane and push `(interval.end, lane)`
+ *       onto the active heap.
+ *
+ * Total: O(n log n). For n = 1.000 events that's ~ 10.000 heap ops,
+ * each a handful of array accesses — sub-millisecond on Tier A.
+ *
+ * ── Why a separate "free lane" structure ──────────────────────────
+ *
+ * Without it, "lowest-numbered free lane" would require scanning all
+ * possibly-free lanes at each step → O(n²) in the worst case.
+ *
+ * The free-lane heap stores lane-ids in ascending order. When a lane
+ * becomes free (its interval expired), we push it back. When we need
+ * a lane, we pop the smallest. If the heap is empty, we allocate a
+ * new lane (`laneCount++`).
+ *
+ * The implementation here uses simple binary heaps in flat arrays —
+ * no library dependency, ~ 30 lines, easy to verify.
+ */
+export interface IntervalInput {
+    /** Stable identifier preserved into the output. */
+    id: string;
+    /** Inclusive start column. */
+    start: number;
+    /** Inclusive end column. `end >= start`. */
+    end: number;
+}
+export interface IntervalLayout {
+    id: string;
+    /** Assigned lane. 0-indexed. Stable across calls for the same input. */
+    lane: number;
+    start: number;
+    end: number;
+}
+export interface LayoutResult {
+    /** One entry per input interval, in unspecified output order. */
+    bars: ReadonlyArray<IntervalLayout>;
+    /**
+     * Number of distinct lanes used. Equals the maximum overlap depth
+     * at any column (= clique number of the interval graph).
+     */
+    laneCount: number;
+}
+/**
+ * Greedy interval-graph coloring. Given N intervals, returns each
+ * interval annotated with a lane index such that no two intervals
+ * share a (lane, column) cell. The number of lanes used is optimal
+ * (= maximum overlap depth).
+ *
+ * Behavior on edge cases:
+ *   - Empty input: `{ bars: [], laneCount: 0 }`.
+ *   - Single interval: assigned lane 0; laneCount 1.
+ *   - Non-overlapping intervals: all on lane 0; laneCount 1.
+ *   - All intervals identical: each gets its own lane; laneCount = N.
+ *   - `end < start` is rejected at input validation.
+ *
+ * Output order is NOT preserved from input — bars come out in the
+ * order they were processed (sorted-by-start). The `id` field is
+ * the stable handle.
+ */
+export declare function layoutOverlappingIntervals(intervals: ReadonlyArray<IntervalInput>): LayoutResult;
+//# sourceMappingURL=overlapLayout.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"overlapLayout.d.ts","sourceRoot":"","sources":["../../src/core/overlapLayout.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AAEH,MAAM,WAAW,aAAa;IAC5B,mDAAmD;IACnD,EAAE,EAAE,MAAM,CAAC;IACX,8BAA8B;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,4CAA4C;IAC5C,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,wEAAwE;IACxE,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,YAAY;IAC3B,iEAAiE;IACjE,IAAI,EAAE,aAAa,CAAC,cAAc,CAAC,CAAC;IACpC;;;OAGG;IACH,SAAS,EAAE,MAAM,CAAC;CACnB;AA0FD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,0BAA0B,CACxC,SAAS,EAAE,aAAa,CAAC,aAAa,CAAC,GACtC,YAAY,CAqDd"}