@alfadocs/ui-kit 1.54.3 → 1.56.0

package/dist/components/heatmap/heatmap-table-view.d.ts

@@ -0,0 +1,35 @@
+import type { HeatmapDescriber } from './heatmap-format';
+import type { BodyRow, HeatmapColumn, HeatmapRow, HeatmapTotals, ModelCell } from './heatmap-model';
+import type { HeatmapAggregate } from './heatmap-scale';
+/** Starts fetching the table chunk ahead of a switch to the table view, so
+ * the switch does not wait on the download. Safe to call repeatedly. */
+export declare function preloadHeatmapTable(): void;
+export interface HeatmapTableViewProps {
+    title: string;
+    rowsLabel?: string;
+    rows: readonly HeatmapRow[];
+    columns: readonly HeatmapColumn[];
+    matrix: readonly ModelCell[][];
+    /** Group headers and rows in display order, every group expanded. */
+    body: readonly BodyRow[];
+    grouped: boolean;
+    /** Each group's public id, for the table's row ids (never a label). */
+    groupIds: ReadonlyMap<string, string>;
+    describer: HeatmapDescriber;
+    totals: HeatmapTotals | null;
+    rowTotals: HeatmapAggregate | false;
+    columnTotals: HeatmapAggregate | false;
+    groupColumnMethod: HeatmapAggregate;
+    minCount?: number;
+    /** The table failed to load or render (announced by the heatmap). */
+    onLoadError?: () => void;
+}
+/**
+ * The heatmap's "View as table": the same rows, columns, values, counts and
+ * totals as a DataTable, so every number is reachable without colour and
+ * without a pointer. Group header rows carry their totals, and rows stay in
+ * their groups in the grid's order. Labels go through the same privacy
+ * masking as the grid.
+ */
+export declare function HeatmapTableView({ title, rowsLabel, rows, columns, matrix, body, grouped, groupIds, describer, totals, rowTotals, columnTotals, groupColumnMethod, minCount, onLoadError, }: HeatmapTableViewProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=heatmap-table-view.d.ts.map

package/dist/components/heatmap/heatmap-tooltip.d.ts

@@ -0,0 +1,40 @@
+import type { ReactElement } from 'react';
+import type { HeatmapCellInfo } from './heatmap-model';
+export interface HeatmapTooltipProps {
+    /** The cell the tooltip describes. */
+    cell: HeatmapCellInfo;
+    /**
+     * Tooltip text. Defaults to the Heatmap's `renderTooltip`, or to the
+     * sentence every cell is named with ("Tuesday, 10:00: 26%, 10 of 39").
+     * Plain text only: the kit Tooltip never carries interactive content.
+     */
+    label?: string;
+    /** Controlled open state. */
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    /** Logical side. Default `'top'`. */
+    side?: 'top' | 'end' | 'bottom' | 'start';
+    /** The trigger. */
+    children: ReactElement;
+}
+/**
+ * Heatmap.Tooltip: the kit Tooltip with a cell's description. The grid uses
+ * it for the cell under the pointer or the keyboard focus; a consumer can
+ * use it to describe a cell somewhere else, with the same wording and the
+ * same privacy masking.
+ */
+export declare function HeatmapTooltip({ cell, label, open, onOpenChange, side, children, }: HeatmapTooltipProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace HeatmapTooltip {
+    var displayName: string;
+}
+/**
+ * The anchor the grid hangs a cell's tooltip on: an inert box over the
+ * cell, so the cell itself never re-mounts (and never drops focus) when the
+ * tooltip moves to it. Takes the text, not a cell, so a group header cell
+ * (which has no single row) gets one too.
+ */
+export declare function HeatmapCellTooltip({ label, onOpenChange, }: {
+    label: string;
+    onOpenChange: (open: boolean) => void;
+}): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=heatmap-tooltip.d.ts.map

package/dist/components/heatmap/heatmap-variants.d.ts

@@ -0,0 +1,87 @@
+/** Palettes, each backed by ten `--heatmap-<palette>-<step>` tokens. */
+export type HeatmapPalette = 'primary' | 'success' | 'destructive' | 'diverging';
+/** One colour step of one palette, the neutral midpoint of a diverging
+ *  scale, or a cell with no colour of its own. */
+export type HeatmapTone = `${HeatmapPalette}-${0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9}` | 'midpoint' | 'empty' | 'low-sample' | 'aggregate';
+/** The tone for a palette step. */
+export declare const stepTone: (palette: HeatmapPalette, step: number) => HeatmapTone;
+/** Root: a column of legend bar, grid and live region. Never wider than
+ *  its container, so the page never scrolls sideways. */
+export declare const heatmapRootVariants: (props?: import("class-variance-authority/types").ClassProp | undefined) => string;
+/** The bar above the grid: legend at the start, view toggle at the end. */
+export declare const heatmapToolbarVariants: (props?: import("class-variance-authority/types").ClassProp | undefined) => string;
+/** The scroll box. Only this box scrolls; sticky headers stick to it. */
+export declare const heatmapScrollerVariants: (props?: import("class-variance-authority/types").ClassProp | undefined) => string;
+/**
+ * The table view's box. `fit` lets the DataTable grow with its rows up to
+ * the maximum; `capped` holds the maximum and the DataTable fills it,
+ * scrolling inside.
+ */
+export declare const heatmapTableViewVariants: (props?: ({
+    capped?: boolean | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+/**
+ * The grid. Columns come from `--heatmap-columns` (set on the scroll box);
+ * rows share the column tracks through subgrid. Size sets the cell box,
+ * density the gap, and a virtualised grid pins every track to one size so
+ * the window arithmetic holds.
+ */
+export declare const heatmapGridVariants: (props?: ({
+    size?: "sm" | "md" | "lg" | null | undefined;
+    density?: "default" | "compact" | null | undefined;
+    virtualised?: boolean | null | undefined;
+    totalsColumn?: boolean | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+/** A row: spans every column and lines its cells up through subgrid. */
+export declare const heatmapRowVariants: (props?: ({
+    position?: "body" | "footer" | "header" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+/** A spacer standing in for rows or columns the window skipped. */
+export declare const heatmapSpacerVariants: (props?: ({
+    axis?: "row-lead" | "row-middle" | "row-tail" | "col-lead" | "col-middle" | "col-tail" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+/** Column header: the hour, day or other column label. */
+export declare const heatmapColumnHeaderVariants: (props?: ({
+    corner?: boolean | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+/** Row header: the row's label, sticky at the inline start. */
+export declare const heatmapRowHeaderVariants: (props?: ({
+    kind?: "data" | "group" | "total" | null | undefined;
+    virtualised?: boolean | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+/** The label inside a row header. */
+export declare const heatmapRowLabelVariants: (props?: ({
+    virtualised?: boolean | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+/**
+ * A cell. Colour comes from `tone`; selection, focus and hover come from
+ * state attributes so a cell's classes only change when its data does.
+ *
+ * Focus: an inset ring in `--ring` over an inset band of the page colour,
+ * so it reads on every step. Selection: a dark line framed by two light
+ * ones, also inset, so it reads on every step too and is a shape, not a
+ * colour. On a focused, selected cell the selection lines move inward by
+ * `--focus-ring-width`, so the ring (3px in the accessible theme) never
+ * covers them. Windows high contrast keeps the cell colours
+ * (forced-color-adjust: none) and paints focus in the system Highlight
+ * colour.
+ */
+export declare const heatmapCellVariants: (props?: ({
+    tone?: HeatmapTone | null | undefined;
+    interactive?: boolean | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+/** Legend container. */
+export declare const heatmapLegendVariants: (props?: import("class-variance-authority/types").ClassProp | undefined) => string;
+/** The bar of colour steps in the legend. It shrinks with its container
+ *  rather than pushing the page wider. */
+export declare const heatmapLegendBarVariants: (props?: ({
+    variant?: "stepped" | "continuous" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+/** A legend swatch: a step in the bar, the key for an empty or low-sample
+ *  cell, or the diverging midpoint, which carries its value in its own ink.
+ *  Same tone classes as the cells. */
+export declare const heatmapSwatchVariants: (props?: ({
+    tone?: HeatmapTone | null | undefined;
+    shape?: "label" | "key" | "stepped" | "continuous" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+//# sourceMappingURL=heatmap-variants.d.ts.map

package/dist/components/heatmap/heatmap-window.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Cell count above which the grid virtualises. Measured in Chromium on a
+ * production build (heatmap mdx, "Performance"): a full render took about
+ * 10 ms at 840 cells and 14 ms (p95 18 ms) at 1,200, against the 16 ms
+ * budget in src/docs/19-performance.mdx. Above 1,000 cells the window keeps
+ * render and hover cost tied to the viewport, not to the data.
+ */
+export declare const VIRTUALISE_CELL_THRESHOLD = 1000;
+/** Rows or columns rendered beyond each edge of the viewport. */
+export declare const OVERSCAN = 3;
+/** Inputs for one axis. All lengths in CSS pixels. */
+export interface AxisMetrics {
+    /** Scroll offset along the axis (absolute; RTL scrollLeft is negative). */
+    offset: number;
+    /** Visible length of the scroll container along the axis. */
+    viewport: number;
+    /** Space before the first item: the sticky header or row header. */
+    lead: number;
+    /** Item length plus the gap after it. */
+    pitch: number;
+    /** Number of items on the axis. */
+    count: number;
+}
+/** Half-open range `[start, end)` of item indexes in view. */
+export declare function visibleRange({ offset, viewport, lead, pitch, count }: AxisMetrics, overscan?: number): [number, number];
+/** What an axis renders: item indexes and the spans of the gaps. */
+export interface AxisWindow {
+    /** Sorted item indexes to render. */
+    indexes: number[];
+    /** Items skipped before the first rendered one. */
+    lead: number;
+    /**
+     * Items skipped between the pinned (focused) item and the visible range,
+     * when the pinned item lies outside it. Zero otherwise.
+     */
+    middle: number;
+    /** Where the middle gap sits: after this many rendered items. */
+    middleAfter: number;
+    /** Items skipped after the last rendered one. */
+    tail: number;
+}
+/** Combines the visible range with the item that must stay rendered. */
+export declare function axisWindow(range: [number, number], count: number, pinned: number | null): AxisWindow;
+/** A window that renders everything (the grid below the threshold). */
+export declare function fullWindow(count: number): AxisWindow;
+/**
+ * A window with every index at or past `count` dropped: what a window built
+ * for more items renders in the one pass before it is worked out again.
+ * Returns the same window when nothing is past the end.
+ */
+export declare function trimWindow(window: AxisWindow, count: number): AxisWindow;
+/** Whether two windows render the same items (skips a needless render). */
+export declare function sameWindow(a: AxisWindow, b: AxisWindow): boolean;
+//# sourceMappingURL=heatmap-window.d.ts.map

package/dist/components/heatmap/heatmap.agent.d.ts

@@ -0,0 +1,4 @@
+import type { AgentAdapter } from '../../agent/types';
+import type { HeatmapHandle } from './heatmap';
+export declare const heatmapAgent: AgentAdapter<HeatmapHandle>;
+//# sourceMappingURL=heatmap.agent.d.ts.map

package/dist/components/heatmap/heatmap.d.ts

@@ -0,0 +1,186 @@
+import { type ReactNode } from 'react';
+import { type HeatmapPrivacyScope, type HeatmapValueType } from './heatmap-format';
+import { type HeatmapSelectionMode } from './heatmap-grid';
+import { type HeatmapCellInfo, type HeatmapCellInput, type HeatmapCellKey, type HeatmapColumn, type HeatmapGroup, type HeatmapRow, type HeatmapSortRows } from './heatmap-model';
+import { type HeatmapAggregate, type HeatmapScale } from './heatmap-scale';
+import { HeatmapTooltip } from './heatmap-tooltip';
+import { type HeatmapPalette } from './heatmap-variants';
+export type { HeatmapCellData, HeatmapCellInfo, HeatmapCellInput, HeatmapCellKey, HeatmapCellStatus, HeatmapColumn, HeatmapGroup, HeatmapRow, HeatmapSortRows, } from './heatmap-model';
+export type { HeatmapAggregate, HeatmapScale } from './heatmap-scale';
+export type { HeatmapPalette } from './heatmap-variants';
+export type { HeatmapPrivacyScope, HeatmapValueType } from './heatmap-format';
+export type { HeatmapSelectionMode } from './heatmap-grid';
+/** What `renderTooltip` is told besides the cell. */
+export interface HeatmapTooltipContext {
+    /**
+     * True in privacy mode. The cell's labels are then already masked (and
+     * its free-text `label` dropped), so text built from them is safe to show.
+     */
+    privacyMode: boolean;
+}
+/** Which presentation is showing. */
+export type HeatmapView = 'heatmap' | 'table';
+/** What one cell reads back to an agent: structure and numbers, no labels. */
+export interface HeatmapCellReading {
+    value: number | null;
+    count?: number;
+    status: HeatmapCellInfo['status'];
+    /** As `HeatmapCellInfo.step`: a value exactly on a diverging midpoint
+     *  reads step 5, though it is painted neutral grey. */
+    step: number | null;
+}
+/**
+ * Curated handle for the agent adapter (see heatmap.agent.ts). Ids only,
+ * never labels. Group ids are the public ones: a group's own id when it is
+ * listed in `groups`, else `group-<n>`. Every write throws on an id the
+ * heatmap does not have, before it changes or announces anything.
+ */
+export interface HeatmapHandle {
+    getSelection: () => HeatmapCellKey[];
+    getSelectionMode: () => HeatmapSelectionMode;
+    selectCells: (cells: readonly HeatmapCellKey[]) => void;
+    selectRange: (from: HeatmapCellKey, to: HeatmapCellKey) => void;
+    clearSelection: () => void;
+    readCell: (cell: HeatmapCellKey) => HeatmapCellReading | null;
+    getView: () => HeatmapView;
+    setView: (view: HeatmapView) => void;
+    getSortRows: () => HeatmapSortRows;
+    setSortRows: (sort: HeatmapSortRows) => void;
+    /** Row ids in display order, every group expanded. */
+    getRowIds: () => string[];
+    /** Column ids in order. */
+    getColumnIds: () => (string | number)[];
+    /** Group ids in display order; empty unless `groupRows` is on. */
+    getGroupIds: () => string[];
+    getCollapsedGroups: () => string[];
+    setGroupCollapsed: (groupId: string, collapsed: boolean) => void;
+}
+export interface HeatmapProps {
+    /**
+     * Required. Names the grid for assistive technology and the table view.
+     * Never masked, so it must not name a person.
+     */
+    title: string;
+    /** Rows, top to bottom. Keep the array stable (see Memoisation). */
+    rows: readonly HeatmapRow[];
+    /** Columns, in reading order. Keep the array stable. */
+    columns: readonly HeatmapColumn[];
+    /**
+     * Returns a cell's data. Use this or `cells`. Keep it stable
+     * (`useCallback`): an inline function rebuilds the matrix every render.
+     */
+    getCell?: (row: HeatmapRow, column: HeatmapColumn, rowIndex: number, columnIndex: number) => HeatmapCellInput;
+    /** The cells as a `[row][column]` matrix, in the order of `rows` and `columns`. */
+    cells?: readonly (readonly HeatmapCellInput[])[];
+    /** Visible labels for the group ids rows carry. Keep the array stable. */
+    groups?: readonly HeatmapGroup[];
+    /** How values map to colour steps. Default sequential with an auto domain. */
+    scale?: HeatmapScale;
+    /** Colour palette. Default `diverging` for a diverging scale, else `primary`. */
+    palette?: HeatmapPalette;
+    /**
+     * `rate` for proportions between 0 and 1: formats as a percentage and
+     * reads counts as "10 of 39". Default `number`.
+     */
+    valueType?: HeatmapValueType;
+    /**
+     * Cells with a count below this render as "too few to show", hatched.
+     * A display rule, not disclosure control: `read_cell`, `onCellClick`,
+     * `onSelectionChange` and the totals still carry the value.
+     */
+    minCount?: number;
+    /** Formats a value. Default: Intl in the active locale. Keep it stable. */
+    valueFormatter?: (value: number) => string;
+    /** Print the value inside each cell. */
+    showValues?: boolean;
+    /** Built-in legend above the grid, or `false` to place `Heatmap.Legend` yourself. */
+    legend?: 'stepped' | 'continuous' | false;
+    /**
+     * A totals column at the row ends. A mean weights by count. Everything in
+     * that column uses this method: each row's total, each group's and the
+     * grand total in the corner.
+     */
+    rowTotals?: HeatmapAggregate | false;
+    /**
+     * A totals row under the columns. A mean weights by count. A group
+     * header's per-column totals use this method too (else `rowTotals`).
+     */
+    columnTotals?: HeatmapAggregate | false;
+    /**
+     * Row order (within each group). Controlled when set. In privacy mode
+     * `label` keeps the given order: sorting by masked names would reveal
+     * their order.
+     */
+    sortRows?: HeatmapSortRows;
+    /** Initial row order when uncontrolled. Default `none`. */
+    defaultSortRows?: HeatmapSortRows;
+    /** Called when the row order changes (agent `sort_rows`). */
+    onSortRowsChange?: (sort: HeatmapSortRows) => void;
+    /** Group rows by `row.group`, each group collapsible with its totals. */
+    groupRows?: boolean;
+    /** Group ids that start collapsed. */
+    defaultCollapsedGroups?: readonly string[];
+    /** How cells are selected. Default `none`. */
+    selection?: HeatmapSelectionMode;
+    /** Selected cells. Controlled when set. */
+    selectedCells?: readonly HeatmapCellKey[];
+    /** Initially selected cells when uncontrolled. */
+    defaultSelectedCells?: readonly HeatmapCellKey[];
+    /** Called with every cell in the new selection. */
+    onSelectionChange?: (cells: HeatmapCellInfo[]) => void;
+    /** Called when a cell is clicked, or activated with Enter or Space. */
+    onCellClick?: (cell: HeatmapCellInfo) => void;
+    /**
+     * Tooltip text for a cell. Plain text: the kit Tooltip is text-only. It
+     * also describes the focused cell to screen readers (aria-describedby).
+     * In privacy mode the cell arrives with its labels masked, its free-text
+     * `label` dropped and `row.group` replaced by the public group id, and
+     * the context says so.
+     */
+    renderTooltip?: (cell: HeatmapCellInfo, context: HeatmapTooltipContext) => string;
+    /** `compact` removes the gap between cells. Cells never shrink below the target size. */
+    density?: 'compact' | 'default';
+    /** Cell size. Every size keeps cells at least `--min-target-size`. */
+    size?: 'sm' | 'md' | 'lg';
+    /** Shows a skeleton while data loads. */
+    loading?: boolean;
+    /**
+     * Masks row labels (people, chairs, patients) in the grid, the tooltip,
+     * the table view and the announcements, and drops free-text cell labels.
+     * Columns and groups stay readable unless `privacyScope="all"`. `title`
+     * and `rowsLabel` are never masked.
+     */
+    privacyMode?: boolean;
+    /**
+     * What privacy mode masks: `rows` (default) or `all`, which masks column
+     * and group labels too.
+     */
+    privacyScope?: HeatmapPrivacyScope;
+    /**
+     * Names what the rows are ("Chair"): the corner header and the table's
+     * first column. Never masked, so it must not name a person.
+     */
+    rowsLabel?: string;
+    /** Initial presentation. Default `heatmap`. */
+    defaultView?: HeatmapView;
+    /** Called when the view switches between heatmap and table. */
+    onViewChange?: (view: HeatmapView) => void;
+    /** Instance id: `data-component-id`, and the agent registry key. */
+    id?: string;
+    className?: string;
+    /**
+     * Rendered inside the heatmap's context, after the grid (e.g.
+     * `Heatmap.Legend`). Also while loading and when empty.
+     */
+    children?: ReactNode;
+}
+/**
+ * Heatmap: a grid of cells coloured by value on a token scale, for patterns
+ * such as chair occupancy by hour or no-shows by weekday and hour. Keyboard,
+ * screen reader and table view are built in; see heatmap.mdx.
+ */
+export declare const Heatmap: import("react").ForwardRefExoticComponent<HeatmapProps & import("react").RefAttributes<HTMLDivElement>> & {
+    Legend: import("react").ForwardRefExoticComponent<import("./heatmap-legend").HeatmapLegendProps & import("react").RefAttributes<HTMLDivElement>>;
+    Tooltip: typeof HeatmapTooltip;
+};
+//# sourceMappingURL=heatmap.d.ts.map

package/dist/components/heatmap/index.d.ts

@@ -0,0 +1,8 @@
+export { Heatmap } from './heatmap';
+export type { HeatmapProps, HeatmapHandle, HeatmapView, HeatmapCellReading, HeatmapCellData, HeatmapCellInfo, HeatmapCellInput, HeatmapCellKey, HeatmapCellStatus, HeatmapColumn, HeatmapGroup, HeatmapRow, HeatmapSortRows, HeatmapAggregate, HeatmapScale, HeatmapPalette, HeatmapValueType, HeatmapSelectionMode, HeatmapPrivacyScope, HeatmapTooltipContext, } from './heatmap';
+export { HeatmapLegend } from './heatmap-legend';
+export type { HeatmapLegendProps } from './heatmap-legend';
+export { HeatmapTooltip } from './heatmap-tooltip';
+export type { HeatmapTooltipProps } from './heatmap-tooltip';
+export { heatmapAgent } from './heatmap.agent';
+//# sourceMappingURL=index.d.ts.map

package/dist/components/heatmap/index.js

@@ -0,0 +1,8 @@
+import { H as t, a as p, b as m, h as o } from "../../_chunks/heatmap-Gf9r7Tn1.js";
+export {
+  t as Heatmap,
+  p as HeatmapLegend,
+  m as HeatmapTooltip,
+  o as heatmapAgent
+};
+//# sourceMappingURL=index.js.map

package/dist/components/hover-card/index.js

@@ -1,4 +1,4 @@
-import { H as e, h as o, u as s } from "../../_chunks/hover-card-CcRSI4gy.js";
+import { H as e, h as o, u as s } from "../../_chunks/hover-card-BnTueNS2.js";
 export {
   e as HoverCard,
   o as hoverCardAgent,

package/dist/components/iban-input/index.js

@@ -1,4 +1,4 @@
-import { I as n, a as I, M as i, b, c as N, i as p, d as r, w as t, e as A } from "../../_chunks/iban-input-CpOUMMR-.js";
+import { I as n, a as I, M as i, b, c as N, i as p, d as r, w as t, e as A } from "../../_chunks/iban-input-B9L2QDHh.js";
 export {
   n as IBAN_LENGTHS,
   I as IbanInput,

package/dist/components/icon-button/index.js

@@ -1,4 +1,4 @@
-import { I as n } from "../../_chunks/icon-button-mKIvw90h.js";
+import { I as n } from "../../_chunks/icon-button-COX76Jdj.js";
 export {
   n as IconButton
 };

package/dist/components/icon-button-group/index.js

@@ -1,4 +1,4 @@
-import { I as t } from "../../_chunks/icon-button-group-BsQkbCX4.js";
+import { I as t } from "../../_chunks/icon-button-group-C5hhI-R5.js";
 export {
   t as IconButtonGroup
 };

package/dist/components/icon-picker/index.js

@@ -1,4 +1,4 @@
-import { I as i, i as o } from "../../_chunks/icon-picker-JZzs1ol_.js";
+import { I as i, i as o } from "../../_chunks/icon-picker-DWrqmI1c.js";
 export {
   i as IconPicker,
   o as iconPickerAgent

package/dist/components/image-cropper/index.js

@@ -1,4 +1,4 @@
-import { I as p, a as r, c as s, b as t, d as c, i as o, t as m } from "../../_chunks/image-cropper-CNBGkG7P.js";
+import { I as p, a as r, c as s, b as t, d as c, i as o, t as m } from "../../_chunks/image-cropper-D0kkQ4lG.js";
 export {
   p as ImageCropper,
   r as applyAspect,

package/dist/components/index.d.ts

@@ -128,6 +128,7 @@ export * from './appointment-timeline';
 export * from './dialog';
 export * from './dropdown-menu';
 export * from './error-boundary';
+export * from './error-summary';
 export * from './finished-terminal';
 export * from './hover-card';
 export * from './info-tip';
@@ -163,6 +164,7 @@ export * from './theme-root';
 export * from './unit-converter';
 export * from './visually-hidden';
 export * from './chart';
+export * from './heatmap';
 export * from './ai-prompt-input';
 export * from './ai-sparkle';
 export * from './audio-recorder';
@@ -176,6 +178,7 @@ export * from './streaming-text';
 export * from './suggestion-chip';
 export * from './transcript-panel';
 export * from './typing-indicator';
+export * from './voice-control-panel';
 export * from './anamnesis-card';
 export * from './muscle-scheme';
 export * from './optical-prescription';

package/dist/components/info-tip/index.js

@@ -1,4 +1,4 @@
-import { I as f, i as n } from "../../_chunks/info-tip-Czh1izZ6.js";
+import { I as f, i as n } from "../../_chunks/info-tip-B0jmIt6M.js";
 export {
   f as InfoTip,
   n as infoTipAgent

package/dist/components/kbd/index.js

@@ -1,4 +1,4 @@
-import { K as b, k as d } from "../../_chunks/kbd-BLovyx1R.js";
+import { K as b, k as d } from "../../_chunks/kbd-Bx7eQv9f.js";
 export {
   b as Kbd,
   d as kbdGlyphs

package/dist/components/key-value-pair/index.js

@@ -1,4 +1,4 @@
-import { K as r, a as s } from "../../_chunks/key-value-pair-BkXjt88Z.js";
+import { K as r, a as s } from "../../_chunks/key-value-pair-BNNITp6S.js";
 export {
   r as KeyValueList,
   s as KeyValuePair

package/dist/components/locale-picker/index.js

@@ -1,4 +1,4 @@
-import { L, a as c, b as r } from "../../_chunks/locale-picker-BhNIgeXA.js";
+import { L, a as c, b as r } from "../../_chunks/locale-picker-DfNSdOpy.js";
 export {
   L as LOCALE_STORAGE_KEY,
   c as LocalePicker,

package/dist/components/logo/index.js

@@ -1,4 +1,4 @@
-import { L } from "../../_chunks/logo-CuaqxTGK.js";
+import { L } from "../../_chunks/logo-hIsyVE96.js";
 export {
   L as Logo
 };

package/dist/components/map-view/index.js

@@ -1,4 +1,4 @@
-import { M as o } from "../../_chunks/map-view-CQmqQJwK.js";
+import { M as o } from "../../_chunks/map-view-CO2v0hfp.js";
 export {
   o as MapView
 };

package/dist/components/message-card/index.js

@@ -1,4 +1,4 @@
-import { M as a } from "../../_chunks/message-card-C1buKlzM.js";
+import { M as a } from "../../_chunks/message-card-DVo8-dOm.js";
 import { m as o } from "../../_chunks/message-card.agent-ZLhx3Bs5.js";
 import { i as f } from "../../_chunks/is-safe-url-DkETxeHz.js";
 export {

package/dist/components/message-tray/index.js

@@ -1,4 +1,4 @@
-import { M as s, m as r } from "../../_chunks/message-tray-DyBVqlGj.js";
+import { M as s, m as r } from "../../_chunks/message-tray-BB95DA82.js";
 export {
   s as MessageTray,
   r as messageTrayAgent

package/dist/components/money/index.js

@@ -1,4 +1,4 @@
-import { M as m } from "../../_chunks/money-GypsuFk2.js";
+import { M as m } from "../../_chunks/money-CeClE1nH.js";
 import { m as n } from "../../_chunks/money.agent-BjJ6gOkx.js";
 export {
   m as Money,

package/dist/components/multi-select/index.js

@@ -1,4 +1,4 @@
-import { M as a, m as l, a as i } from "../../_chunks/multi-select-CVb6PJOK.js";
+import { M as a, m as l, a as i } from "../../_chunks/multi-select-BT23EnSA.js";
 export {
   a as MultiSelect,
   l as multiSelectAgent,

package/dist/components/multi-select/multi-select.d.ts

@@ -28,6 +28,12 @@ export interface MultiSelectProps<T extends string = string> extends Omit<HTMLDi
     filter?: (query: string, option: OptionShape<T>) => boolean;
     size?: 'sm' | 'md' | 'lg';
     disabled?: boolean;
+    /**
+     * Let a long option label wrap onto a second line instead of ending in an
+     * ellipsis. Longer still, it is clipped after two lines. Off by default.
+     * An option's `description` always sits on its own line under the label.
+     */
+    wrapOptionLabels?: boolean;
 }
 interface MultiSelectComponent {
     <T extends string = string>(props: MultiSelectProps<T> & {

package/dist/components/muscle-scheme/index.js

@@ -1,4 +1,4 @@
-import { D as a, F as r, a as t, M as g, b as i, e as m, f as o, g as E, c as F, m as c, r as I, v as M } from "../../_chunks/muscle-scheme-DfYQ0Z3v.js";
+import { D as a, F as r, a as t, M as g, b as i, e as m, f as o, g as E, c as F, m as c, r as I, v as M } from "../../_chunks/muscle-scheme-BDgIaGeW.js";
 export {
   a as DEFAULT_MUSCLE_VIEW,
   r as FINDING_MARKER,

package/dist/components/nav-grid/index.js

@@ -1,4 +1,4 @@
-import { N as i, n, t as s } from "../../_chunks/nav-grid-BPbmzHY0.js";
+import { N as i, n, t as s } from "../../_chunks/nav-grid-BqCPH8sm.js";
 export {
   i as NavGrid,
   n as navGridAgent,

package/dist/components/notes-panel/index.js

@@ -1,4 +1,4 @@
-import { N as a } from "../../_chunks/notes-panel-DWJY3WV8.js";
+import { N as a } from "../../_chunks/notes-panel-DceRhthG.js";
 export {
   a as NotesPanel
 };

package/dist/components/notification-card/index.js

@@ -1,4 +1,4 @@
-import { N as a, i as t } from "../../_chunks/notification-card-DubeUbVJ.js";
+import { N as a, i as t } from "../../_chunks/notification-card-BGCIL6Mu.js";
 import { n as f } from "../../_chunks/notification-card.agent-DxGBZb8T.js";
 export {
   a as NotificationCard,

package/dist/components/notification-tray/index.js

@@ -1,4 +1,4 @@
-import { N as o, n as t } from "../../_chunks/notification-tray-DJ0gtfu6.js";
+import { N as o, n as t } from "../../_chunks/notification-tray-__sJXnsz.js";
 export {
   o as NotificationTray,
   t as notificationTrayAgent

package/dist/components/number-input/index.js

@@ -1,4 +1,4 @@
-import { N as r, u as a } from "../../_chunks/number-input-DRDRYZJg.js";
+import { N as r, u as a } from "../../_chunks/number-input-CVwI1ltI.js";
 export {
   r as NumberInput,
   a as useLocaleNumber

package/dist/components/operator-hero/index.js

@@ -1,4 +1,4 @@
-import { O as e, o as a } from "../../_chunks/operator-hero-BnBPxwOi.js";
+import { O as e, o as a } from "../../_chunks/operator-hero-Dyd2IGbR.js";
 export {
   e as OperatorHero,
   a as operatorHeroAgent