@vizejs/ui 0.426.2 → 0.427.0

package/dist/scheduler-DqzOgTx4.d.mts

@@ -0,0 +1,401 @@
+import { l as Weekday, s as PlainDate } from "./plain-date-By3bTWQG.mjs";
+import { t as PlainDateTime } from "./plain-date-time-TY1jIYOW.mjs";
+import { t as DateTimeNow } from "./calendar-today-Djkf8bII.mjs";
+
+//#region src/families/date-time/scheduler/scheduler-layout.d.ts
+/** Scheduler view granularity. */
+type SchedulerView = "day" | "week" | "month";
+/** One consumer event. `Data` is the consumer's own payload type. */
+interface SchedulerEvent<Data = unknown> {
+  /** Stable unique id. */
+  readonly id: string;
+  /** Inclusive start. */
+  readonly start: PlainDateTime;
+  /** Exclusive end; events with `end <= start` are treated as zero-length. */
+  readonly end: PlainDateTime;
+  /** Whether the event spans whole days and belongs in all-day lanes. */
+  readonly allDay?: boolean;
+  /** Accessible title. */
+  readonly title: string;
+  /** Consumer payload, returned verbatim in every emit and slot. */
+  readonly data: Data;
+}
+/** Placement of a timed event inside one day column of a time grid. */
+interface TimeGridPlacement<Data = unknown> {
+  readonly event: SchedulerEvent<Data>;
+  /** ISO date of the day column. */
+  readonly day: string;
+  /** Visible start and end minute of day after clipping to the day window. */
+  readonly startMinute: number;
+  readonly endMinute: number;
+  /** Zero-based column inside the overlap cluster. */
+  readonly column: number;
+  /** Columns in the event's overlap cluster. */
+  readonly columns: number;
+  /** Columns the event may widen into without overlapping. */
+  readonly span: number;
+  /** Offset and size as fractions of the day window (`0`–`1`). */
+  readonly top: number;
+  readonly height: number;
+  /** Whether the event started before or continues after the visible window. */
+  readonly continuesBefore: boolean;
+  readonly continuesAfter: boolean;
+}
+/** Placement of an event across a row of consecutive days (all-day lanes, month weeks). */
+interface RowPlacement<Data = unknown> {
+  readonly event: SchedulerEvent<Data>;
+  /** First and last day index covered inside the row, inclusive. */
+  readonly startIndex: number;
+  readonly endIndex: number;
+  /** Zero-based stacking lane. */
+  readonly lane: number;
+  /** Whether the event started before or continues after the row. */
+  readonly continuesBefore: boolean;
+  readonly continuesAfter: boolean;
+}
+/** Options for {@link layoutTimeGrid}. */
+interface TimeGridWindow {
+  /** First visible minute of day. @default 0 */
+  readonly startMinute?: number;
+  /** Last visible minute of day, exclusive. @default 1440 */
+  readonly endMinute?: number;
+  /** Minimum rendered length in minutes so short events stay visible. @default 15 */
+  readonly minimumMinutes?: number;
+}
+/** Whether an event covers any part of `day` (all-day events cover whole days). */
+declare function eventTouchesDay<Data>(event: SchedulerEvent<Data>, day: PlainDate): boolean;
+/**
+ * Lay out timed events for one day column.
+ *
+ * Events are sorted by start (longer first on ties), grouped into clusters of
+ * transitively overlapping events, assigned the first free column, and then
+ * widened to the right across columns that stay free for their whole span.
+ */
+declare function layoutTimeGrid<Data>(events: readonly SchedulerEvent<Data>[], day: PlainDate, window?: TimeGridWindow): readonly TimeGridPlacement<Data>[];
+/**
+ * Stack events across a row of consecutive days into lanes.
+ *
+ * Used for all-day lanes above a time grid and for month-view week rows.
+ * Longer events claim lower lanes first so bars stay aligned.
+ */
+declare function layoutRow<Data>(events: readonly SchedulerEvent<Data>[], days: readonly PlainDate[], filter?: (event: SchedulerEvent<Data>) => boolean): readonly RowPlacement<Data>[];
+/** Days rendered by a view anchored at `date`. */
+declare function visibleDays(view: SchedulerView, date: PlainDate, weekStartsOn: Weekday): readonly PlainDate[];
+/** Split month-view days into week rows and flag days outside the anchor month. */
+declare function monthWeeks(days: readonly PlainDate[], anchor: PlainDate): readonly (readonly {
+  readonly date: PlainDate;
+  readonly outsideMonth: boolean;
+}[])[];
+/** Move the view anchor by one period. */
+declare function shiftAnchor(view: SchedulerView, date: PlainDate, step: number): PlainDate;
+/** Snap a minute of day to a multiple of `step` inside `[min, max]`. */
+declare function snapMinute(minute: number, step: number, min: number, max: number): number;
+/**
+ * Minute of day under a client Y coordinate inside a day column rectangle,
+ * snapped down to `step` inside the visible window.
+ */
+declare function minuteAtPoint(y: number, rect: {
+  readonly top: number;
+  readonly bottom: number;
+}, window: {
+  readonly startMinute: number;
+  readonly endMinute: number;
+  readonly step: number;
+}): number;
+//#endregion
+//#region src/families/date-time/scheduler/scheduler-types.d.ts
+/** Root state token mirrored to `data-state`. */
+type SchedulerState = "disabled" | "pending" | "readonly" | "ready";
+/** Requested new timing for an event; the consumer applies it to `events`. */
+interface SchedulerEventChange<Data = unknown> {
+  /** Event being moved or resized. */
+  readonly event: SchedulerEvent<Data>;
+  /** Requested start. */
+  readonly start: PlainDateTime;
+  /** Requested end. */
+  readonly end: PlainDateTime;
+}
+/** Time range of an activated slot. */
+interface SchedulerSlotRange {
+  readonly start: PlainDateTime;
+  readonly end: PlainDateTime;
+}
+/** One rendered day column or month cell. */
+interface SchedulerDay {
+  /** Calendar date. */
+  readonly date: PlainDate;
+  /** ISO date mirrored to `data-date`. */
+  readonly iso: string;
+  /** Localized column header, for example `Fri 25`. */
+  readonly label: string;
+  /** Localized short weekday, for example `Fri`. */
+  readonly weekdayLabel: string;
+  /** Localized full date used as the accessible name. */
+  readonly fullLabel: string;
+  /** Localized day of month. */
+  readonly dayLabel: string;
+  /** Whether the day equals the resolved current date. */
+  readonly today: boolean;
+  /** Whether the day belongs to an adjacent month in month view. */
+  readonly outsideMonth: boolean;
+}
+/** One time-slot row of the time grid. */
+interface SchedulerSlotRow {
+  /** Minute of day where the slot starts. */
+  readonly minute: number;
+  /** Localized slot start label. */
+  readonly label: string;
+}
+/** Timed placements of one day column. */
+interface SchedulerDayColumnState<Data = unknown> {
+  readonly day: SchedulerDay;
+  readonly placements: readonly TimeGridPlacement<Data>[];
+}
+/** One month-view week row with its lane placements. */
+interface SchedulerWeekState<Data = unknown> {
+  readonly days: readonly SchedulerDay[];
+  readonly placements: readonly RowPlacement<Data>[];
+  /** Events hidden beyond `maxLanes`, per day index. */
+  readonly overflow: readonly number[];
+}
+/** State shared by every scheduler slot and exposed from the root. */
+interface SchedulerSlotState<Data = unknown> {
+  readonly view: SchedulerView;
+  /** View anchor, or `null` while pending. */
+  readonly date: PlainDate | null;
+  readonly today: PlainDate | null;
+  readonly heading: string;
+  readonly days: readonly SchedulerDay[];
+  readonly slots: readonly SchedulerSlotRow[];
+  readonly columns: readonly SchedulerDayColumnState<Data>[];
+  /** All-day lane placements across the visible days (day and week views). */
+  readonly allDay: readonly RowPlacement<Data>[];
+  readonly weeks: readonly SchedulerWeekState<Data>[];
+  readonly locale: string;
+  readonly direction: "ltr" | "rtl";
+  readonly disabled: boolean;
+  readonly readOnly: boolean;
+  readonly pending: boolean;
+  readonly state: SchedulerState;
+}
+/** Public instance exposed by SchedulerRoot. */
+interface SchedulerRootExpose<Data = unknown> extends SchedulerSlotState<Data> {
+  /** Rendered root element. */
+  readonly root: HTMLDivElement | null;
+  /** Move the anchor by one period; returns whether it moved. */
+  readonly navigate: (step: -1 | 1) => boolean;
+  /** Show the resolved current date; returns whether it moved. */
+  readonly goToToday: () => boolean;
+  /** Request a view. */
+  readonly setView: (view: SchedulerView) => void;
+  /** Request an anchor date. */
+  readonly setDate: (date: PlainDate) => void;
+  /** Focus the roving slot or day cell; returns whether focus moved. */
+  readonly focus: (options?: FocusOptions) => boolean;
+}
+//#endregion
+//#region src/families/date-time/scheduler/scheduler-root.vue.d.ts
+declare const __VLS_export$7: <Data>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+  props: import("vue").PublicProps & __VLS_PrettifyLocal<{
+    /** Consumer-owned base id; nullish values use a deterministic fallback. @default undefined */readonly id?: string | null | undefined; /** Events to lay out; `data` keeps the consumer payload type. @default [] */
+    readonly events?: readonly SchedulerEvent<Data>[] | undefined; /** Controlled view; `undefined` selects uncontrolled mode. @default undefined */
+    readonly view?: SchedulerView | undefined; /** Initial uncontrolled view. @default "week" */
+    readonly defaultView?: SchedulerView | undefined; /** Controlled anchor date deciding the visible period. @default undefined */
+    readonly date?: PlainDate | null | undefined; /** Initial uncontrolled anchor date. @default undefined */
+    readonly defaultDate?: PlainDate | null | undefined; /** Explicit current date; the SSR-safe way to anchor and mark today. @default undefined */
+    readonly today?: PlainDate | null | undefined; /** Injectable clock evaluated during setup on server and client. @default undefined */
+    readonly now?: DateTimeNow | undefined; /** IANA time zone used with `now` and the post-mount host clock. @default undefined */
+    readonly timeZone?: string | undefined; /** BCP 47 locale; defaults to the nearest LocaleProvider. @default undefined */
+    readonly locale?: string | undefined; /** Text direction; defaults to the nearest LocaleProvider. @default undefined */
+    readonly dir?: "ltr" | "rtl" | undefined; /** First day of week; defaults to the locale preference. @default undefined */
+    readonly weekStartsOn?: Weekday | undefined; /** First visible hour of the time grid. @default 0 */
+    readonly dayStartHour?: number | undefined; /** Hour where the time grid ends, exclusive. @default 24 */
+    readonly dayEndHour?: number | undefined; /** Minutes per time-grid slot row. @default 30 */
+    readonly slotMinutes?: number | undefined; /** Minutes that drag and keyboard moves snap to. @default slotMinutes */
+    readonly snapMinutes?: number | undefined; /** Minimum rendered event length in minutes. @default 15 */
+    readonly minimumEventMinutes?: number | undefined; /** Month-view lanes rendered per week before counting overflow. @default 3 */
+    readonly maxLanes?: number | undefined; /** Disable navigation, activation, and editing. @default false */
+    readonly disabled?: boolean | undefined; /** Keep navigation and activation but block move and resize requests. @default false */
+    readonly readOnly?: boolean | undefined; /** Accessible name for the scheduler region. @default undefined */
+    readonly ariaLabel?: string | undefined;
+  } & {
+    "onUpdate:view"?: (view: SchedulerView) => any;
+    "onUpdate:date"?: (date: PlainDate) => any;
+    "onEvent-activate"?: (event: SchedulerEvent<Data>, nativeEvent: Event) => any;
+    "onSlot-activate"?: (range: SchedulerSlotRange, nativeEvent: Event) => any;
+    "onDay-activate"?: (date: PlainDate, nativeEvent: Event) => any;
+    "onEvent-move"?: (change: SchedulerEventChange<Data>, nativeEvent: Event | null) => any;
+    "onEvent-resize"?: (change: SchedulerEventChange<Data>, nativeEvent: Event | null) => any;
+  }> & (typeof globalThis extends {
+    __VLS_PROPS_FALLBACK: infer P;
+  } ? P : {});
+  expose: (exposed: import("vue").ShallowUnwrapRef<{
+    root: Readonly<import("vue").ShallowRef<HTMLDivElement | null>>;
+    view: import("vue").ComputedRef<SchedulerView>;
+    date: import("vue").ComputedRef<PlainDate | null>;
+    today: import("vue").ComputedRef<PlainDate | null>;
+    heading: import("vue").ComputedRef<string>;
+    days: import("vue").ComputedRef<readonly SchedulerDay[]>;
+    slots: import("vue").ComputedRef<readonly SchedulerSlotRow[]>;
+    columns: import("vue").ComputedRef<readonly SchedulerDayColumnState<Data>[]>;
+    allDay: import("vue").ComputedRef<readonly RowPlacement<Data>[]>;
+    weeks: import("vue").ComputedRef<readonly SchedulerWeekState<Data>[]>;
+    locale: import("vue").ComputedRef<string>;
+    direction: import("vue").ComputedRef<"rtl" | "ltr">;
+    disabled: import("vue").ComputedRef<boolean>;
+    readOnly: import("vue").ComputedRef<boolean>;
+    pending: import("vue").ComputedRef<boolean>;
+    state: import("vue").ComputedRef<SchedulerState>;
+    navigate: (step: -1 | 1) => boolean;
+    goToToday: () => boolean;
+    setView: (next: SchedulerView) => void;
+    setDate: (date: PlainDate) => void;
+    focus: () => boolean;
+  }>) => void;
+  attrs: any;
+  slots: {
+    /** Scheduler composition. Receives typed layout state; defaults to a header plus the view's grid. */default?(props: SchedulerSlotState<Data>): unknown;
+  };
+  emit: ((evt: "update:view", view: SchedulerView) => void) & ((evt: "update:date", date: PlainDate) => void) & ((evt: "event-activate", event: SchedulerEvent<Data>, nativeEvent: Event) => void) & ((evt: "slot-activate", range: SchedulerSlotRange, nativeEvent: Event) => void) & ((evt: "day-activate", date: PlainDate, nativeEvent: Event) => void) & ((evt: "event-move", change: SchedulerEventChange<Data>, nativeEvent: Event | null) => void) & ((evt: "event-resize", change: SchedulerEventChange<Data>, nativeEvent: Event | null) => void);
+}>) => import("vue").VNode & {
+  __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
+};
+declare const _default$7: typeof __VLS_export$7;
+type __VLS_PrettifyLocal<T> = (T extends any ? { [K in keyof T]: T[K] } : { [K in keyof T as K]: T[K] }) & {};
+//#endregion
+//#region src/families/date-time/scheduler/scheduler-day-column.vue.d.ts
+type __VLS_Props$4 = {
+  /** Day and timed placements rendered by this column. @default undefined (required) */readonly column: SchedulerDayColumnState<unknown>;
+};
+type __VLS_Slots$6 = {
+  /** Event content for each placement; defaults to the event title. */event(props: TimeGridPlacement<unknown>): unknown;
+};
+declare const __VLS_base$6: import("vue").DefineComponent<__VLS_Props$4, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props$4> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export$6: __VLS_WithSlots$6<typeof __VLS_base$6, __VLS_Slots$6>;
+declare const _default$6: typeof __VLS_export$6;
+type __VLS_WithSlots$6<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/families/date-time/scheduler/scheduler-event.vue.d.ts
+type __VLS_Props$3 = {
+  /** Event rendered by this item. @default undefined (required) */readonly event: SchedulerEvent<unknown>; /** Time-grid placement; drives `--vize-scheduler-*` position variables. @default undefined */
+  readonly placement?: TimeGridPlacement<unknown> | undefined; /** Row placement for all-day lanes and month weeks. @default undefined */
+  readonly row?: RowPlacement<unknown> | undefined; /** Render a resize handle at the end of time-grid events. @default true */
+  readonly resizable?: boolean;
+};
+type __VLS_Slots$5 = {
+  /** Event content. Receives the event and its placement; defaults to the title. */default(props: {
+    readonly event: SchedulerEvent<unknown>;
+    readonly placement: TimeGridPlacement<unknown> | undefined;
+    readonly row: RowPlacement<unknown> | undefined;
+    readonly label: string;
+  }): unknown;
+};
+declare const __VLS_base$5: import("vue").DefineComponent<__VLS_Props$3, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props$3> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export$5: __VLS_WithSlots$5<typeof __VLS_base$5, __VLS_Slots$5>;
+declare const _default$5: typeof __VLS_export$5;
+type __VLS_WithSlots$5<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/families/date-time/scheduler/scheduler-heading.vue.d.ts
+type __VLS_Slots$4 = {
+  /** Heading content. Receives the localized period label. */default(props: {
+    readonly heading: string;
+  }): unknown;
+};
+declare const __VLS_base$4: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export$4: __VLS_WithSlots$4<typeof __VLS_base$4, __VLS_Slots$4>;
+declare const _default$4: typeof __VLS_export$4;
+type __VLS_WithSlots$4<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/families/date-time/scheduler/scheduler-month-day.vue.d.ts
+type __VLS_Props$2 = {
+  /** Week row that owns this day. @default undefined (required) */readonly week: SchedulerWeekState<unknown>; /** Day index inside the week. @default undefined (required) */
+  readonly index: number;
+};
+type __VLS_Slots$3 = {
+  /** Day number content. */day(props: SchedulerDay): unknown; /** Event bar content for events starting in this cell. */
+  event(props: RowPlacement<unknown>): unknown; /** Overflow indicator content when more events exist than `maxLanes`. */
+  more(props: {
+    readonly count: number;
+    readonly day: SchedulerDay;
+  }): unknown;
+};
+declare const __VLS_base$3: import("vue").DefineComponent<__VLS_Props$2, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props$2> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export$3: __VLS_WithSlots$3<typeof __VLS_base$3, __VLS_Slots$3>;
+declare const _default$3: typeof __VLS_export$3;
+type __VLS_WithSlots$3<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/families/date-time/scheduler/scheduler-month-grid.vue.d.ts
+type __VLS_Slots$2 = {
+  /** Weekday column header content. */weekday(props: SchedulerDay): unknown; /** Day number content. */
+  day(props: SchedulerDay): unknown; /** Event bar content. */
+  event(props: RowPlacement<unknown>): unknown; /** Overflow indicator content. */
+  more(props: {
+    readonly count: number;
+    readonly day: SchedulerDay;
+  }): unknown;
+};
+declare const __VLS_base$2: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export$2: __VLS_WithSlots$2<typeof __VLS_base$2, __VLS_Slots$2>;
+declare const _default$2: typeof __VLS_export$2;
+type __VLS_WithSlots$2<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/families/date-time/scheduler/scheduler-nav.vue.d.ts
+type __VLS_Props$1 = {
+  /** Navigation performed by the button. @default undefined (required) */readonly action: "previous" | "next" | "today"; /** Accessible name; defaults to "Previous period", "Next period", or "Today". @default undefined */
+  readonly ariaLabel?: string;
+};
+type __VLS_Slots$1 = {
+  /** Button content. Receives the action. */default(props: {
+    readonly action: "previous" | "next" | "today";
+  }): unknown;
+};
+declare const __VLS_base$1: import("vue").DefineComponent<__VLS_Props$1, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props$1> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export$1: __VLS_WithSlots$1<typeof __VLS_base$1, __VLS_Slots$1>;
+declare const _default$1: typeof __VLS_export$1;
+type __VLS_WithSlots$1<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/families/date-time/scheduler/scheduler-time-grid.vue.d.ts
+type __VLS_Props = {
+  /** Corner column header announced for the time labels. @default "Time" */readonly timeHeader?: string; /** Accessible name of the all-day lane group. @default "All day" */
+  readonly allDayLabel?: string;
+};
+type __VLS_Slots = {
+  /** Day column header content. */dayHeader(props: SchedulerDay): unknown; /** Time label content for each slot row. */
+  time(props: SchedulerSlotRow): unknown; /** Timed event content. */
+  event(props: TimeGridPlacement<unknown>): unknown; /** All-day event content. */
+  allDayEvent(props: RowPlacement<unknown>): unknown;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+type __VLS_WithSlots<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+export { visibleDays as A, eventTouchesDay as C, monthWeeks as D, minuteAtPoint as E, shiftAnchor as O, TimeGridWindow as S, layoutTimeGrid as T, SchedulerWeekState as _, _default$4 as a, SchedulerView as b, _default$7 as c, SchedulerEventChange as d, SchedulerRootExpose as f, SchedulerState as g, SchedulerSlotState as h, _default$3 as i, snapMinute as k, SchedulerDay as l, SchedulerSlotRow as m, _default$1 as n, _default$5 as o, SchedulerSlotRange as p, _default$2 as r, _default$6 as s, _default as t, SchedulerDayColumnState as u, RowPlacement as v, layoutRow as w, TimeGridPlacement as x, SchedulerEvent as y };

package/dist/scheduler.d.mts

@@ -0,0 +1,5 @@
+import { S as formatIsoDate, z as parseIsoDate } from "./plain-date-By3bTWQG.mjs";
+import { o as formatIsoTime, u as parseIsoTime } from "./plain-time-CDNop94U.mjs";
+import { f as parseIsoDateTime, o as createPlainDateTime, s as formatIsoDateTime, t as PlainDateTime } from "./plain-date-time-TY1jIYOW.mjs";
+import { A as visibleDays, C as eventTouchesDay, D as monthWeeks, E as minuteAtPoint, O as shiftAnchor, S as TimeGridWindow, T as layoutTimeGrid, _ as SchedulerWeekState, a as _default$3, b as SchedulerView, c as _default, d as SchedulerEventChange, f as SchedulerRootExpose, g as SchedulerState, h as SchedulerSlotState, i as _default$4, k as snapMinute, l as SchedulerDay, m as SchedulerSlotRow, n as _default$6, o as _default$2, p as SchedulerSlotRange, r as _default$5, s as _default$1, t as _default$7, u as SchedulerDayColumnState, v as RowPlacement, w as layoutRow, x as TimeGridPlacement, y as SchedulerEvent } from "./scheduler-DqzOgTx4.mjs";
+export { type PlainDateTime, type RowPlacement, _default as Scheduler, _default as SchedulerRoot, type SchedulerDay, _default$1 as SchedulerDayColumn, type SchedulerDayColumnState, _default$2 as SchedulerEvent, type SchedulerEventChange, type SchedulerEvent as SchedulerEventData, _default$3 as SchedulerHeading, _default$4 as SchedulerMonthDay, _default$5 as SchedulerMonthGrid, _default$6 as SchedulerNav, type SchedulerRootExpose, type SchedulerSlotRange, type SchedulerSlotRow, type SchedulerSlotState, type SchedulerState, _default$7 as SchedulerTimeGrid, type SchedulerView, type SchedulerWeekState, type TimeGridPlacement, type TimeGridWindow, createPlainDateTime, eventTouchesDay, formatIsoDate, formatIsoDateTime, formatIsoTime, layoutRow, layoutTimeGrid, minuteAtPoint, monthWeeks, parseIsoDate, parseIsoDateTime, parseIsoTime, shiftAnchor, snapMinute, visibleDays };

package/dist/scheduler.mjs

@@ -0,0 +1,5 @@
+import { M as parseIsoDate, h as formatIsoDate } from "./plain-date-DHX8BIlm.mjs";
+import { r as formatIsoTime, s as parseIsoTime } from "./plain-time-Dd8AhiH4.mjs";
+import { a as formatIsoDateTime, i as createPlainDateTime, u as parseIsoDateTime } from "./plain-date-time-BQrJLa0I.mjs";
+import { a as layoutRow, c as monthWeeks, d as visibleDays, f as scheduler_nav_default, g as scheduler_heading_default, h as scheduler_event_default, i as eventTouchesDay, l as shiftAnchor, m as scheduler_month_day_default, n as scheduler_time_grid_default, o as layoutTimeGrid, p as scheduler_month_grid_default, r as scheduler_day_column_default, s as minuteAtPoint, t as scheduler_root_default, u as snapMinute } from "./scheduler-6sLVhSSP.mjs";
+export { scheduler_root_default as Scheduler, scheduler_root_default as SchedulerRoot, scheduler_day_column_default as SchedulerDayColumn, scheduler_event_default as SchedulerEvent, scheduler_heading_default as SchedulerHeading, scheduler_month_day_default as SchedulerMonthDay, scheduler_month_grid_default as SchedulerMonthGrid, scheduler_nav_default as SchedulerNav, scheduler_time_grid_default as SchedulerTimeGrid, createPlainDateTime, eventTouchesDay, formatIsoDate, formatIsoDateTime, formatIsoTime, layoutRow, layoutTimeGrid, minuteAtPoint, monthWeeks, parseIsoDate, parseIsoDateTime, parseIsoTime, shiftAnchor, snapMinute, visibleDays };

package/dist/scroll-area.d.mts

@@ -1,2 +1,2 @@
-import { $r as ScrollAreaOverscrollBehavior, Gr as ScrollAreaAriaState, Jr as ScrollAreaEmits, Kr as ScrollAreaAs, Qr as ScrollAreaOverflow, Wr as _default, Xr as ScrollAreaLength, Yr as ScrollAreaExpose, Zr as ScrollAreaOrientation, ai as ScrollAreaScrollbarGutter, ci as ScrollAreaState, ei as ScrollAreaProps, ii as ScrollAreaScrollBehavior, li as ScrollAreaStyle, ni as ScrollAreaResolvedLength, oi as ScrollAreaScrollbarWidth, qr as ScrollAreaDirection, ri as ScrollAreaRootElement, si as ScrollAreaSlotState, ti as ScrollAreaResolvedLayout } from "./announcer-BNpDcMK0.mjs";
+import { As as ScrollAreaExpose, Bs as ScrollAreaScrollbarGutter, Ds as ScrollAreaAs, Es as ScrollAreaAriaState, Fs as ScrollAreaProps, Hs as ScrollAreaSlotState, Is as ScrollAreaResolvedLayout, Ls as ScrollAreaResolvedLength, Ms as ScrollAreaOrientation, Ns as ScrollAreaOverflow, Os as ScrollAreaDirection, Ps as ScrollAreaOverscrollBehavior, Rs as ScrollAreaRootElement, Ts as _default, Us as ScrollAreaState, Vs as ScrollAreaScrollbarWidth, Ws as ScrollAreaStyle, js as ScrollAreaLength, ks as ScrollAreaEmits, zs as ScrollAreaScrollBehavior } from "./announcer-DwGlsSL_.mjs";
 export { _default as ScrollArea, type ScrollAreaAriaState, type ScrollAreaAs, type ScrollAreaDirection, type ScrollAreaEmits, type ScrollAreaExpose, type ScrollAreaLength, type ScrollAreaOrientation, type ScrollAreaOverflow, type ScrollAreaOverscrollBehavior, type ScrollAreaProps, type ScrollAreaResolvedLayout, type ScrollAreaResolvedLength, type ScrollAreaRootElement, type ScrollAreaScrollBehavior, type ScrollAreaScrollbarGutter, type ScrollAreaScrollbarWidth, type ScrollAreaSlotState, type ScrollAreaState, type ScrollAreaStyle };

package/dist/{scroll-lock-BcmK0baN.mjs → scroll-lock-B2hstCJR.mjs}

@@ -1,4 +1,4 @@
-import { getCurrentInstance, getCurrentScope, onMounted, onScopeDispose, shallowReadonly, shallowRef, toValue, watch } from "vue";
+import { getCurrentScope, hasInjectionContext, onMounted, onScopeDispose, shallowReadonly, shallowRef, toValue, watch } from "vue";
 //#region src/families/accessibility/scroll-lock/scroll-lock-internal.ts
 const optionDiagnostic = "VIZE_UI_SCROLL_LOCK_OPTION";
 function readDocument(source) {
@@ -304,7 +304,7 @@ function createScrollLock(options) {
 function useScrollLock(options) {
 	if (!getCurrentScope()) throw new Error(`${setupDiagnostic}: use inside component setup or an active effect scope`);
 	const controller = createScrollLock(options);
-	if (getCurrentInstance()) onMounted(controller.activate);
+	if (hasInjectionContext()) onMounted(controller.activate);
 	else controller.activate();
 	onScopeDispose(controller.dispose);
 	return controller;

package/dist/scroll-lock.mjs

@@ -1,2 +1,2 @@
-import { n as useScrollLock, t as createScrollLock } from "./scroll-lock-BcmK0baN.mjs";
+import { n as useScrollLock, t as createScrollLock } from "./scroll-lock-B2hstCJR.mjs";
 export { createScrollLock, useScrollLock };

package/dist/scroll-spy-UzNvEzBk.d.mts

@@ -0,0 +1,68 @@
+import { MaybeRefOrGetter, ShallowRef } from "vue";
+
+//#region src/families/interaction/scroll-spy/scroll-spy-types.d.ts
+/** Why the active target changed. */
+type ScrollSpyChangeReason = "navigation" | "scroll";
+/** Options shared by {@link createScrollSpy} and {@link useScrollSpy}. */
+interface ScrollSpyOptions {
+  /** Ids of observed target elements, in document order. */
+  readonly ids: MaybeRefOrGetter<readonly string[]>;
+  /**
+   * Scroll container whose top edge anchors the activation line. `null` and
+   * `undefined` select the document viewport.
+   *
+   * @default undefined
+   */
+  readonly root?: MaybeRefOrGetter<Element | null | undefined>;
+  /**
+   * Distance in CSS pixels below the container top where a target becomes
+   * active, for example the height of a sticky header.
+   *
+   * @default 0
+   */
+  readonly offset?: MaybeRefOrGetter<number | undefined>;
+  /**
+   * Active id assumed before the first measurement, which is what server
+   * rendering and hydration use.
+   *
+   * @default null
+   */
+  readonly initialActiveId?: string | null;
+  /**
+   * Stop tracking while true. The last active id is kept.
+   *
+   * @default false
+   */
+  readonly isDisabled?: MaybeRefOrGetter<boolean | undefined>;
+  /** Called after a distinct active-id change. */
+  readonly onActiveChange?: (id: string | null, previous: string | null, reason: ScrollSpyChangeReason) => void;
+}
+/** Scroll position tracker for a set of in-page targets. */
+interface ScrollSpyController {
+  /** Id of the last target whose top crossed the activation line, or `null`. */
+  readonly activeId: Readonly<ShallowRef<string | null>>;
+  /** Ids of targets currently intersecting the container, in document order. */
+  readonly visibleIds: Readonly<ShallowRef<readonly string[]>>;
+  /** Measure targets now instead of on the next animation frame. */
+  readonly refresh: () => void;
+  /** Scroll a target into view and make it active immediately. */
+  readonly scrollTo: (id: string, options?: ScrollIntoViewOptions) => boolean;
+  /** Remove listeners and stop tracking. Safe to repeat. */
+  readonly dispose: () => void;
+}
+//#endregion
+//#region src/families/interaction/scroll-spy/scroll-spy.d.ts
+/**
+ * Create an SSR-safe scroll spy for in-page targets such as headings.
+ *
+ * The active target is the last one whose top edge has crossed the activation
+ * line (`offset` pixels below the container top). When the container is
+ * scrolled to its end the last visible target wins, so short final sections
+ * still activate. Measurements are batched per animation frame and never run
+ * on the server; `initialActiveId` is the server and hydration value.
+ */
+declare function createScrollSpy(options: ScrollSpyOptions): ScrollSpyController;
+/** Create a scroll spy disposed with the current Vue effect scope. */
+declare function useScrollSpy(options: ScrollSpyOptions): ScrollSpyController;
+//#endregion
+export { ScrollSpyOptions as a, ScrollSpyController as i, useScrollSpy as n, ScrollSpyChangeReason as r, createScrollSpy as t };

package/dist/scroll-spy.d.mts

@@ -0,0 +1,2 @@
+import { a as ScrollSpyOptions, i as ScrollSpyController, n as useScrollSpy, r as ScrollSpyChangeReason, t as createScrollSpy } from "./scroll-spy-UzNvEzBk.mjs";
+export { type ScrollSpyChangeReason, type ScrollSpyController, type ScrollSpyOptions, createScrollSpy, useScrollSpy };

package/dist/scroll-spy.mjs

@@ -0,0 +1,122 @@
+import { getCurrentScope, onScopeDispose, shallowReadonly, shallowRef, toValue, watch } from "vue";
+//#region src/families/interaction/scroll-spy/scroll-spy.ts
+const setupDiagnostic = "VIZE_UI_SCROLL_SPY_SETUP";
+const disposedDiagnostic = "VIZE_UI_SCROLL_SPY_DISPOSED";
+function sameIds(left, right) {
+	return left.length === right.length && left.every((id, index) => id === right[index]);
+}
+/**
+* Create an SSR-safe scroll spy for in-page targets such as headings.
+*
+* The active target is the last one whose top edge has crossed the activation
+* line (`offset` pixels below the container top). When the container is
+* scrolled to its end the last visible target wins, so short final sections
+* still activate. Measurements are batched per animation frame and never run
+* on the server; `initialActiveId` is the server and hydration value.
+*/
+function createScrollSpy(options) {
+	const activeId = shallowRef(options.initialActiveId ?? null);
+	const visibleIds = shallowRef(Object.freeze([]));
+	const view = typeof window === "undefined" ? null : window;
+	let frame = null;
+	let disposed = false;
+	let unbind = null;
+	const setActive = (next, reason) => {
+		const previous = activeId.value;
+		if (next === previous) return;
+		activeId.value = next;
+		options.onActiveChange?.(next, previous, reason);
+	};
+	const measure = () => {
+		frame = null;
+		if (disposed || view === null || toValue(options.isDisabled) === true) return;
+		const doc = view.document;
+		const root = toValue(options.root) ?? null;
+		const rootRect = root?.getBoundingClientRect() ?? null;
+		const top = rootRect?.top ?? 0;
+		const bottom = rootRect?.bottom ?? view.innerHeight;
+		const line = top + (toValue(options.offset) ?? 0);
+		let candidate = null;
+		const visible = [];
+		for (const id of toValue(options.ids)) {
+			const target = doc.getElementById(id);
+			if (target === null) continue;
+			const rect = target.getBoundingClientRect();
+			if (rect.top <= line + 1) candidate = id;
+			if (rect.bottom > top && rect.top < bottom) visible.push(id);
+		}
+		const scroller = root ?? doc.scrollingElement;
+		if (scroller !== null && scroller.scrollHeight > scroller.clientHeight && scroller.scrollTop + scroller.clientHeight >= scroller.scrollHeight - 1 && visible.length > 0) candidate = visible.at(-1) ?? candidate;
+		if (!sameIds(visible, visibleIds.value)) visibleIds.value = Object.freeze(visible);
+		setActive(candidate, "scroll");
+	};
+	const schedule = () => {
+		if (disposed || view === null || frame !== null) return;
+		frame = typeof view.requestAnimationFrame === "function" ? view.requestAnimationFrame(measure) : view.setTimeout(measure, 16);
+	};
+	const cancelFrame = () => {
+		if (frame === null || view === null) return;
+		if (typeof view.cancelAnimationFrame === "function") view.cancelAnimationFrame(frame);
+		else view.clearTimeout(frame);
+		frame = null;
+	};
+	const bind = (root) => {
+		unbind?.();
+		if (view === null) return;
+		const target = root ?? view;
+		target.addEventListener("scroll", schedule, { passive: true });
+		view.addEventListener("resize", schedule, { passive: true });
+		unbind = () => {
+			target.removeEventListener("scroll", schedule);
+			view.removeEventListener("resize", schedule);
+			unbind = null;
+		};
+	};
+	const stopWatch = view === null ? () => void 0 : watch([
+		() => toValue(options.root) ?? null,
+		() => toValue(options.ids),
+		() => toValue(options.offset)
+	], ([root], previous) => {
+		if (previous === void 0 || previous[0] !== root) bind(root);
+		schedule();
+	}, {
+		immediate: true,
+		flush: "post"
+	});
+	const assertActive = () => {
+		if (disposed) throw new Error(`${disposedDiagnostic}: the controller has been disposed`);
+	};
+	return Object.freeze({
+		activeId: shallowReadonly(activeId),
+		visibleIds: shallowReadonly(visibleIds),
+		refresh: () => {
+			assertActive();
+			cancelFrame();
+			measure();
+		},
+		scrollTo: (id, scrollOptions) => {
+			assertActive();
+			const target = view?.document.getElementById(id) ?? null;
+			if (target === null) return false;
+			target.scrollIntoView(scrollOptions ?? { block: "start" });
+			setActive(id, "navigation");
+			return true;
+		},
+		dispose: () => {
+			if (disposed) return;
+			disposed = true;
+			stopWatch();
+			cancelFrame();
+			unbind?.();
+		}
+	});
+}
+/** Create a scroll spy disposed with the current Vue effect scope. */
+function useScrollSpy(options) {
+	if (!getCurrentScope()) throw new Error(`${setupDiagnostic}: use inside component setup or an active effect scope`);
+	const controller = createScrollSpy(options);
+	onScopeDispose(controller.dispose);
+	return controller;
+}
+//#endregion
+export { createScrollSpy, useScrollSpy };