@alfadocs/ui-kit 1.54.3 → 1.56.0

package/dist/components/entity-summary/index.js

@@ -1,4 +1,4 @@
-import { E as t } from "../../_chunks/entity-summary-C3E4JKVr.js";
+import { E as t } from "../../_chunks/entity-summary-DcB0fIiv.js";
 export {
   t as EntitySummary
 };

package/dist/components/error-boundary/index.js

@@ -1,4 +1,4 @@
-import { E as a } from "../../_chunks/error-boundary-Bzjk9Q2l.js";
+import { E as a } from "../../_chunks/error-boundary-ChowhO6w.js";
 export {
   a as ErrorBoundary
 };

package/dist/components/error-summary/error-summary.d.ts

@@ -0,0 +1,50 @@
+import { type HTMLAttributes, type ReactNode } from 'react';
+/** One problem in the summary. */
+export interface ErrorSummaryItem {
+    /** What is wrong, already translated: the same words as the field's own
+     *  message, so the two read as one. */
+    message: string;
+    /**
+     * The field's label, for a message that does not name its field, such
+     * as "This field is required.": the item then reads "First name: This
+     * field is required.". Pass it translated. Leave it out when the
+     * message already says which field it is about.
+     */
+    label?: string;
+    /**
+     * Where the item's link leads: the `id` of the control, or of the
+     * element around it, such as the `FormField`. For an element that cannot
+     * take focus itself, the link moves focus to the control its label
+     * names, else to the first control inside it. Without a `targetId` the
+     * message shows as plain text: use that for a problem that belongs to no
+     * single field.
+     */
+    targetId?: string;
+    /** The field's name, emitted as `data-error-field` on the item. */
+    field?: string;
+}
+export interface ErrorSummaryProps extends Omit<HTMLAttributes<HTMLDivElement>, 'title'> {
+    /** The problems, in the order their fields appear. Nothing renders while
+     *  the list is empty. */
+    errors: readonly ErrorSummaryItem[];
+    /** Replaces the heading "There is a problem". Pass it translated. */
+    title?: string;
+    /** A line between the heading and the list. Pass it translated. */
+    description?: ReactNode;
+    /** The heading's level: one below the heading of the form it sits in.
+     *  Default 2. */
+    headingLevel?: 2 | 3 | 4 | 5 | 6;
+    /**
+     * Ids of other text read with the summary when it takes focus, after the
+     * description and before the list: a message about the whole form that
+     * shows outside the summary, say. Keep that message quiet (no live
+     * region) while the summary shows, or the two are read over each other.
+     */
+    'aria-describedby'?: string;
+}
+/**
+ * Lists every problem with a form after a refused submit, at the top of
+ * the form. Move focus to it (its ref) each time a submit is refused.
+ */
+export declare const ErrorSummary: import("react").ForwardRefExoticComponent<ErrorSummaryProps & import("react").RefAttributes<HTMLDivElement>>;
+//# sourceMappingURL=error-summary.d.ts.map

package/dist/components/error-summary/index.d.ts

@@ -0,0 +1,2 @@
+export { ErrorSummary, type ErrorSummaryItem, type ErrorSummaryProps, } from './error-summary';
+//# sourceMappingURL=index.d.ts.map

package/dist/components/error-summary/index.js

@@ -0,0 +1,5 @@
+import { E as o } from "../../_chunks/error-summary-BhM8FEkl.js";
+export {
+  o as ErrorSummary
+};
+//# sourceMappingURL=index.js.map

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

@@ -1,4 +1,4 @@
-import { A as e, F as o, a as n, b as A, c as i, d as f, e as t, I, f as N, g as T, h as F, i as _, j as E, k as c, l as h, m as r, n as p, o as O, p as S, q as m, r as l, s as d, t as C, u as D } from "../../_chunks/face-scheme-Doodi6A6.js";
+import { A as e, F as o, a as n, b as A, c as i, d as f, e as t, I, f as N, g as T, h as F, i as _, j as E, k as c, l as h, m as r, n as p, o as O, p as S, q as m, r as l, s as d, t as C, u as D } from "../../_chunks/face-scheme-BicuUA2K.js";
 export {
   e as ANNOTATION_TOOL_KIND,
   o as FACE_ANNOTATION_TOOLS,

package/dist/components/fetal-weight/index.js

@@ -1,4 +1,4 @@
-import { F as a, e as i } from "../../_chunks/fetal-weight-DBgEaMoJ.js";
+import { F as a, e as i } from "../../_chunks/fetal-weight-BWaqqjea.js";
 export {
   a as FetalWeight,
   i as estimateFetalWeight

package/dist/components/field-array/index.js

@@ -1,4 +1,4 @@
-import { F as e, f } from "../../_chunks/field-array-DGiIHCdy.js";
+import { F as e, f } from "../../_chunks/field-array-BO-kaKFK.js";
 export {
   e as FieldArray,
   f as fieldArrayAgent

package/dist/components/file-manager/index.js

@@ -1,4 +1,4 @@
-import { F as r, f } from "../../_chunks/file-manager-BDNSnr7f.js";
+import { F as r, f } from "../../_chunks/file-manager-Cc_uO8r2.js";
 export {
   r as FileManager,
   f as fileManagerAgent

package/dist/components/finished-terminal/index.js

@@ -1,4 +1,4 @@
-import { F as r } from "../../_chunks/finished-terminal-BguGAUdg.js";
+import { F as r } from "../../_chunks/finished-terminal-CPSDrIMB.js";
 export {
   r as FinishedTerminal
 };

package/dist/components/fiscal-code-input/index.js

@@ -1,4 +1,4 @@
-import { F as c, c as i, a as e, b as o, f as l, w as d, i as C, d as t } from "../../_chunks/fiscal-code-input-DNA_SbQx.js";
+import { F as c, c as i, a as e, b as o, f as l, w as d, i as C, d as t } from "../../_chunks/fiscal-code-input-DesSQ6Fh.js";
 export {
   c as FiscalCodeInput,
   i as calculateCodiceFiscale,

package/dist/components/form-field/form-field.d.ts

@@ -29,6 +29,15 @@ interface BaseFormFieldProps extends Omit<HTMLAttributes<HTMLDivElement>, 'child
     labelEnd?: React.ReactNode;
     description?: string;
     error?: string;
+    /**
+     * Read the error out the moment it appears (`role="alert"`). Default
+     * true: right for a field checked on its own, as the user leaves it.
+     * Pass false while an `ErrorSummary` lists this field's error: the
+     * summary takes focus and reads every problem once, so the fields stay
+     * quiet instead of each interrupting at the same time. The message is
+     * still tied to the control, so it is read when the control has focus.
+     */
+    announceError?: boolean;
     disabled?: boolean;
     children: React.ReactNode;
 }

package/dist/components/form-field/index.js

@@ -1,4 +1,4 @@
-import { F } from "../../_chunks/form-field-Db0liyI8.js";
+import { F } from "../../_chunks/form-field-Ani72sVY.js";
 import { F as s, u as l, a as m, b as a } from "../../_chunks/form-field-context-DtiROUJV.js";
 export {
   F as FormField,

package/dist/components/freemium-paywall/index.js

@@ -1,4 +1,4 @@
-import { F as m, f as l } from "../../_chunks/freemium-paywall-CtUCj-ND.js";
+import { F as m, f as l } from "../../_chunks/freemium-paywall-DIKuhX8b.js";
 export {
   m as FreemiumPaywall,
   l as freemiumPaywallAgent

package/dist/components/gestational-age-calculator/index.js

@@ -1,4 +1,4 @@
-import { G as t } from "../../_chunks/gestational-age-calculator-BVBz_5dm.js";
+import { G as t } from "../../_chunks/gestational-age-calculator-DqVeJke2.js";
 export {
   t as GestationalAgeCalculator
 };

package/dist/components/hcg-doubling/index.js

@@ -1,4 +1,4 @@
-import { H, M as g, a as o } from "../../_chunks/hcg-doubling-BECrAUu3.js";
+import { H, M as g, a as o } from "../../_chunks/hcg-doubling-BIYyI2Yo.js";
 export {
   H as HcgDoubling,
   g as MINIMAL_48H_RISE_PERCENT,

package/dist/components/header/index.js

@@ -1,4 +1,4 @@
-import { H as r, a as d, b as H, c as s, d as n, e as t, f as i, g as o } from "../../_chunks/header--a4ZTiM5.js";
+import { H as r, a as d, b as H, c as s, d as n, e as t, f as i, g as o } from "../../_chunks/header-B9552pLh.js";
 export {
   r as Header,
   d as HeaderBrand,

package/dist/components/header-settings/index.js

@@ -1,4 +1,4 @@
-import { H as t } from "../../_chunks/header-settings-kkVm9VP3.js";
+import { H as t } from "../../_chunks/header-settings-ge_3gYEq.js";
 export {
   t as HeaderSettings
 };

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

@@ -0,0 +1,21 @@
+import type { HeatmapDescriber } from './heatmap-format';
+import type { HeatmapCellInfo } from './heatmap-model';
+import type { ResolvedHeatmapScale } from './heatmap-scale';
+import type { HeatmapPalette } from './heatmap-variants';
+export interface HeatmapContextValue {
+    palette: HeatmapPalette;
+    scale: ResolvedHeatmapScale;
+    describer: HeatmapDescriber;
+    /** True when some cells fall below `minCount`, so the legend explains it. */
+    hasLowSample: boolean;
+    /** True when some cells have no data. */
+    hasEmpty: boolean;
+    /** The sample threshold, when one is set. */
+    minCount?: number;
+    /** The tooltip text for a cell: the consumer's, or the default sentence. */
+    tooltipText: (cell: HeatmapCellInfo) => string;
+}
+export declare const HeatmapContext: import("react").Context<HeatmapContextValue | null>;
+/** The surrounding Heatmap's context, or null outside one. */
+export declare function useHeatmapContext(): HeatmapContextValue | null;
+//# sourceMappingURL=heatmap-context.d.ts.map

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

@@ -0,0 +1,59 @@
+import type { TFunction } from 'i18next';
+import type { HeatmapColumn, HeatmapGroup, HeatmapRow, ModelCell } from './heatmap-model';
+import type { HeatmapAggregate } from './heatmap-scale';
+/** What the values are: plain numbers, or rates between 0 and 1. */
+export type HeatmapValueType = 'number' | 'rate';
+/**
+ * What privacy mode masks. `rows`: the row labels, which name people,
+ * chairs or patients. `all`: the column and group labels too. The kit rule
+ * (src/components/_shared/privacy-mask.tsx) is to mask the identity and keep
+ * time, place and status, so columns (hours, days) and groups (practices)
+ * stay readable unless the host asks for more.
+ */
+export type HeatmapPrivacyScope = 'rows' | 'all';
+/** The default value format: a percentage for rates, a decimal otherwise. */
+export declare function defaultValueFormatter(locale: string, valueType: HeatmapValueType): (value: number) => string;
+/** Whole-number format for counts. */
+export declare function countFormatter(locale: string): (count: number) => string;
+/** Builds every sentence the heatmap speaks or shows. */
+export interface HeatmapDescriber {
+    /** True when privacy mode hides the row labels. */
+    masksRows: boolean;
+    /** True when privacy mode hides the column labels. */
+    masksColumns: boolean;
+    /** True when privacy mode hides the group labels. */
+    masksGroups: boolean;
+    rowLabel: (row: HeatmapRow) => string;
+    columnLabel: (column: HeatmapColumn) => string;
+    groupLabel: (groupId: string) => string;
+    /** A cell by its headers: "Tuesday, 10:00". */
+    cellName: (rowText: string, columnText: string) => string;
+    /** A group header row: "Mos Eisley (Average)". */
+    groupRowText: (groupText: string, method: HeatmapAggregate) => string;
+    /** A cell as the table view shows it: "26%, 10 of 39". */
+    tableText: (cell: ModelCell) => string;
+    /** Label for a margin: "Total" for a sum, "Average" for a mean. */
+    methodLabel: (method: HeatmapAggregate) => string;
+    /** The value as text: formatted, a cell label, "no data" or "too few". */
+    valueText: (cell: ModelCell) => string;
+    /** The value as shown inside a cell, or '' when the cell shows none. */
+    visibleText: (cell: ModelCell) => string;
+    /** "10 of 39" for a rate, "39 records" otherwise; null without a count. */
+    countText: (cell: ModelCell) => string | null;
+    /** "Tuesday, 10:00: 26%, 10 of 39". */
+    sentence: (rowText: string, columnText: string, cell: ModelCell) => string;
+    /** Format for a raw value, used by the legend. */
+    formatValue: (value: number) => string;
+}
+export interface DescriberOptions {
+    t: TFunction<'ui'>;
+    privacyMode: boolean;
+    /** What privacy mode masks. Default `rows`. */
+    privacyScope?: HeatmapPrivacyScope;
+    valueType: HeatmapValueType;
+    formatValue: (value: number) => string;
+    formatCount: (count: number) => string;
+    groups?: readonly HeatmapGroup[];
+}
+export declare function createDescriber({ t, privacyMode, privacyScope, valueType, formatValue, formatCount, groups, }: DescriberOptions): HeatmapDescriber;
+//# sourceMappingURL=heatmap-format.d.ts.map

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

@@ -0,0 +1,66 @@
+import type { HeatmapDescriber } from './heatmap-format';
+import { type BodyRow, type HeatmapCellInfo, type HeatmapColumn, type HeatmapRow, type HeatmapTotals, type ModelCell } from './heatmap-model';
+import { type HeatmapAggregate, type ResolvedHeatmapScale } from './heatmap-scale';
+import { type HeatmapPalette } from './heatmap-variants';
+/** How the selection behaves. */
+export type HeatmapSelectionMode = 'none' | 'single' | 'multiple' | 'range';
+/** A position in the navigable matrix: a body or footer row and a column
+ *  (the last column is the row-totals column when there is one). */
+export interface GridPosition {
+    rowKey: string;
+    col: number;
+}
+/** Internal selection key for a data cell: its row id and column id, never
+ *  its position, so a change to the columns cannot move it. */
+export declare const selectionKey: (rowId: string, columnId: string | number) => string;
+/** The row id and the column id (as a string) a selection key holds. */
+export declare const splitSelectionKey: (key: string) => [string, string];
+export interface HeatmapGridProps {
+    title: string;
+    rowsLabel?: string;
+    rows: readonly HeatmapRow[];
+    columns: readonly HeatmapColumn[];
+    matrix: readonly ModelCell[][];
+    body: readonly BodyRow[];
+    scale: ResolvedHeatmapScale;
+    palette: HeatmapPalette;
+    describer: HeatmapDescriber;
+    showValues: boolean;
+    totals: HeatmapTotals | null;
+    rowTotals: HeatmapAggregate | false;
+    columnTotals: HeatmapAggregate | false;
+    /** How a group header's per-column totals are worked out. */
+    groupColumnMethod: HeatmapAggregate;
+    /** Each group's public id: what DOM hooks carry, never a label. */
+    groupIds: ReadonlyMap<string, string>;
+    minCount?: number;
+    selectionMode: HeatmapSelectionMode;
+    /** Selection keys (row id + column id) of the selected cells. */
+    selected: ReadonlySet<string>;
+    /** Column index for the column id a selection key holds. */
+    columnIndexOfKey: (columnKey: string) => number | undefined;
+    interactive: boolean;
+    virtualised: boolean;
+    size: 'sm' | 'md' | 'lg';
+    density: 'compact' | 'default';
+    cellInfo: (rowIndex: number, columnIndex: number) => HeatmapCellInfo;
+    /** A data cell's tooltip text. */
+    tooltipText: (cell: HeatmapCellInfo) => string;
+    /** Describe the focused data cell with its tooltip text (a consumer's
+     *  renderTooltip says more than the cell's name). */
+    describeFocused: boolean;
+    /** A data cell was activated by click, Enter or Space. `select` is false
+     *  for a click that only reports the cell (a range press already chose). */
+    onActivate: (rowIndex: number, columnIndex: number, select: boolean) => void;
+    /** Range drag or Shift+arrows: select the rectangle anchor to target. */
+    onRange: (anchor: {
+        rowIndex: number;
+        col: number;
+    }, target: {
+        rowIndex: number;
+        col: number;
+    }) => void;
+    onToggleGroup: (groupId: string) => void;
+}
+export declare function HeatmapGrid(props: HeatmapGridProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=heatmap-grid.d.ts.map

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

@@ -0,0 +1,36 @@
+import { type HeatmapScale } from './heatmap-scale';
+import { type HeatmapPalette } from './heatmap-variants';
+export interface HeatmapLegendProps {
+    /**
+     * `stepped` separates the ten steps; `continuous` joins them in a bar.
+     * A quantile or threshold scale always shows its bands, one swatch per
+     * step it uses, with the cut points between them.
+     */
+    variant?: 'stepped' | 'continuous';
+    /** Palette. Inside a Heatmap it defaults to the Heatmap's. */
+    palette?: HeatmapPalette;
+    /** Scale. Inside a Heatmap it defaults to the Heatmap's resolved scale. */
+    scale?: HeatmapScale;
+    /** Values an `auto` or quantile scale is worked out from (outside a Heatmap). */
+    values?: readonly number[];
+    /** Formats the end labels. Inside a Heatmap it defaults to the Heatmap's. */
+    valueFormatter?: (value: number) => string;
+    /** Show the key for empty cells. Inside a Heatmap: when any cell is empty. */
+    showEmpty?: boolean;
+    /** Show the key for low-sample cells. Inside a Heatmap: when any is. */
+    showLowSample?: boolean;
+    /** The sample threshold, named in the low-sample key. Inside a Heatmap it
+     *  defaults to the Heatmap's `minCount`. */
+    minCount?: number;
+    className?: string;
+}
+/**
+ * Heatmap.Legend: the colour steps with the low and high ends of the scale,
+ * plus keys for empty and low-sample cells. A diverging scale shows its
+ * midpoint between the two hues as a neutral swatch carrying the midpoint
+ * value, the colour of a cell exactly on it. Inside a Heatmap it reads the
+ * Heatmap's scale; render it elsewhere with `legend={false}` on the Heatmap
+ * and the same `scale`, `palette` and `values` here.
+ */
+export declare const HeatmapLegend: import("react").ForwardRefExoticComponent<HeatmapLegendProps & import("react").RefAttributes<HTMLDivElement>>;
+//# sourceMappingURL=heatmap-legend.d.ts.map

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

@@ -0,0 +1,152 @@
+import { type AggregateResult, type HeatmapAggregate } from './heatmap-scale';
+/** One row of the heatmap. */
+export interface HeatmapRow {
+    /** Stable, opaque id. Emitted in DOM hooks, so never a name. */
+    id: string;
+    /** Visible label. Masked in privacy mode. */
+    label: string;
+    /**
+     * Group id. Rows that share it are grouped when `groupRows` is on. Without
+     * a matching entry in `groups` the id doubles as the visible label, so it
+     * may be a name: privacy mode masks it, and DOM hooks and agent state
+     * carry an index-based id (`group-1`, `group-2` in order of first
+     * appearance), never this one.
+     */
+    group?: string;
+}
+/** One column of the heatmap. */
+export interface HeatmapColumn {
+    /**
+     * Stable, opaque id. Emitted in DOM hooks (`data-heatmap-cell-id`) and in
+     * agent state, so never a name.
+     */
+    id: string | number;
+    /**
+     * Visible label. Masked in privacy mode only with `privacyScope="all"`:
+     * columns are usually hours or days, which privacy mode keeps.
+     */
+    label: string;
+}
+/** A group's visible label, keyed by the id rows carry in `group`. */
+export interface HeatmapGroup {
+    /** Stable, opaque id. Emitted in DOM hooks and agent state, so never a name. */
+    id: string;
+    /**
+     * Visible label. Masked in privacy mode only with `privacyScope="all"`:
+     * groups are usually practices or sites, which privacy mode keeps.
+     */
+    label: string;
+}
+/**
+ * The id each group shows to DOM hooks and agents. A group listed in
+ * `groups` keeps its own (opaque) id. One that is not has only its id for a
+ * label, which may be a name, so it gets `group-<n>` by order of first
+ * appearance instead.
+ */
+export declare function publicGroupIds(rows: readonly HeatmapRow[], groups: readonly HeatmapGroup[] | undefined): Map<string, string>;
+/** The data behind one cell. */
+export interface HeatmapCellData {
+    /** The value to colour. `null` means no data. */
+    value: number | null;
+    /**
+     * How many records the value rests on (the denominator of a rate). Weights
+     * the mean totals and drives `minCount`.
+     */
+    count?: number;
+    /**
+     * Text shown and announced instead of the formatted value, for example
+     * "Closed". Replaced by the formatted value in privacy mode.
+     */
+    label?: string;
+}
+/** What `getCell` or the `cells` matrix may hold for a cell. */
+export type HeatmapCellInput = HeatmapCellData | number | null | undefined;
+/** How a cell renders: a coloured value, no data, or too few records. */
+export type HeatmapCellStatus = 'value' | 'empty' | 'low-sample';
+/** Addresses one cell. */
+export interface HeatmapCellKey {
+    rowId: string;
+    columnId: string | number;
+}
+/** Everything known about one cell, as passed to callbacks. */
+export interface HeatmapCellInfo extends HeatmapCellKey {
+    row: HeatmapRow;
+    column: HeatmapColumn;
+    /** Index into the `rows` prop. */
+    rowIndex: number;
+    /** Index into the `columns` prop. */
+    columnIndex: number;
+    value: number | null;
+    count?: number;
+    label?: string;
+    status: HeatmapCellStatus;
+    /**
+     * Colour step, 0 to 9, when `status` is `'value'`; otherwise null. On a
+     * diverging scale a value exactly on the midpoint keeps step 5 but is
+     * painted in the neutral `--heatmap-midpoint` colour: compare `value`
+     * with the midpoint to tell it from the palest step above.
+     */
+    step: number | null;
+}
+/** A cell after normalisation. */
+export interface ModelCell {
+    value: number | null;
+    count?: number;
+    label?: string;
+    status: HeatmapCellStatus;
+}
+/** How rows are ordered (within their group when grouped). */
+export type HeatmapSortRows = 'none' | 'label' | 'total-asc' | 'total-desc';
+/** Whether a cell or total falls below the sample threshold. */
+export declare function isLowSample(count: number | undefined, minCount: number | undefined): boolean;
+/** Normalises one cell input. */
+export declare function toModelCell(input: HeatmapCellInput, minCount: number | undefined): ModelCell;
+/** Builds the `[row][column]` matrix in the order of the props. */
+export declare function buildMatrix(rows: readonly HeatmapRow[], columns: readonly HeatmapColumn[], getCell: ((row: HeatmapRow, column: HeatmapColumn, rowIndex: number, columnIndex: number) => HeatmapCellInput) | undefined, cells: readonly (readonly HeatmapCellInput[])[] | undefined, minCount: number | undefined): ModelCell[][];
+/** The values that render a colour, for the scale's domain. */
+export declare function shownValues(matrix: readonly ModelCell[][]): number[];
+/** Whether at least one cell carries data (a value or a low sample). */
+export declare function hasAnyData(matrix: readonly ModelCell[][]): boolean;
+export interface HeatmapTotals {
+    /** Per row index (props order), by the row method. */
+    rows: AggregateResult[];
+    /** Per column index, by the column method. */
+    columns: AggregateResult[];
+    /** Every cell, by the row method (it sits in the row-totals column). */
+    grand: AggregateResult;
+    /** Per group id: one result per column, by the group column method. */
+    groupColumns: Map<string, AggregateResult[]>;
+    /** Per group id: every cell in the group, by the row method (it sits in
+     *  the row-totals column). */
+    groups: Map<string, AggregateResult>;
+}
+/**
+ * Works out every margin. A total in the row-totals column (a row's, a
+ * group's, the grand total) uses the row method, so the column means one
+ * thing; a group's per-column totals use the group column method. Low-sample
+ * cells count: their data is real, only too thin to show on its own.
+ */
+export declare function computeTotals(matrix: readonly ModelCell[][], rows: readonly HeatmapRow[], columnCount: number, rowMethod: HeatmapAggregate, columnMethod: HeatmapAggregate, groupColumnMethod: HeatmapAggregate): HeatmapTotals;
+/** A row the grid body renders. */
+export type BodyRow = {
+    kind: 'group';
+    /** Navigation key, unique among body rows. */
+    key: string;
+    groupId: string;
+    collapsed: boolean;
+    /** Row indexes (props order) in display order. */
+    rowIndexes: number[];
+} | {
+    kind: 'data';
+    key: string;
+    rowIndex: number;
+    groupId?: string;
+};
+export declare const dataRowKey: (rowId: string) => string;
+export declare const groupRowKey: (groupId: string) => string;
+export declare const FOOTER_ROW_KEY = "f";
+/** Orders row indexes. Ties keep the props order (a stable sort). */
+export declare function sortRowIndexes(indexes: readonly number[], rows: readonly HeatmapRow[], totals: readonly AggregateResult[], sort: HeatmapSortRows, collator: Intl.Collator): number[];
+/** Builds the body: group headers (when grouping) and data rows. */
+export declare function buildBodyRows(rows: readonly HeatmapRow[], sortedIndexes: readonly number[], groupRows: boolean, collapsed: ReadonlySet<string>): BodyRow[];
+//# sourceMappingURL=heatmap-model.d.ts.map

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

@@ -0,0 +1,125 @@
+/** Number of colour steps every palette carries. */
+export declare const HEATMAP_STEPS = 10;
+/**
+ * How values map to colour steps.
+ *
+ * - `sequential`: low to high. `domain: 'auto'` (the default) uses the min
+ *   and max of the cells that show a value; a fixed `[min, max]` clamps.
+ * - `diverging`: two hues either side of `midpoint`. `auto` makes the
+ *   domain symmetric around the midpoint, so equal distances either side
+ *   get equal intensity. The midpoint defaults to 0, or to the centre of a
+ *   fixed domain that does not include 0.
+ * - `quantile`: equal-count buckets (default 10) from the shown values.
+ *   Repeated values never split: buckets that would cut through a run of
+ *   equal values merge, so the minimum always takes the first step.
+ * - `threshold`: ascending cut points; `n` thresholds make `n + 1`
+ *   buckets, spread across the ten steps. At most nine; duplicates merge.
+ *
+ * A fixed domain is `[min, max]`. A reversed pair is put in order, with a
+ * warning in development builds.
+ */
+export type HeatmapScale = {
+    type: 'sequential';
+    domain?: 'auto' | readonly [number, number];
+} | {
+    type: 'diverging';
+    domain?: 'auto' | readonly [number, number];
+    midpoint?: number;
+} | {
+    type: 'quantile';
+    buckets?: number;
+} | {
+    type: 'threshold';
+    thresholds: readonly number[];
+};
+/** A scale with its domain worked out against the data. */
+export interface ResolvedHeatmapScale {
+    type: HeatmapScale['type'];
+    /** Low end of the domain, or of the data for quantile and threshold. */
+    min: number | null;
+    /** High end of the domain, or of the data for quantile and threshold. */
+    max: number | null;
+    /** Diverging only: the value that separates the two hues. */
+    midpoint?: number;
+    /** Quantile and threshold: the ascending bucket edges. */
+    thresholds: readonly number[];
+    /** Maps a value to a step, 0 to 9. */
+    stepOf: (value: number) => number;
+}
+/** Min and max of the finite values, or null when there are none. */
+export declare function extent(values: readonly number[]): [number, number] | null;
+/**
+ * Sequential step: the domain is cut into ten equal bands. A value on a
+ * band edge takes the band above; the top edge belongs to the top step.
+ * Values outside the domain clamp to the end steps.
+ */
+export declare function sequentialStep(value: number, low: number, high: number): number;
+/**
+ * Diverging step: steps 0 to 4 sit below the midpoint (0 is the furthest),
+ * steps 5 to 9 above it (9 is the furthest). Ten steps have no middle one,
+ * so a value exactly on the midpoint takes step 5, the palest step above.
+ * It is painted in the neutral midpoint colour instead (see `onMidpoint`).
+ */
+export declare function divergingStep(value: number, low: number, midpoint: number, high: number): number;
+/**
+ * Whether a value sits exactly on a diverging scale's midpoint, so it is
+ * painted neutral (`--heatmap-midpoint`) rather than in either hue. Exact
+ * up to floating-point rounding, a few units in the last place of the
+ * scale's largest magnitude: the centre of [0.1, 0.2] is computed as
+ * 0.15000000000000002, and 0.1 + 0.2 - 0.3 is not quite 0. A value that
+ * merely rounds to the midpoint when printed keeps its step. Other scale
+ * types have no midpoint.
+ */
+export declare function onMidpoint(scale: ResolvedHeatmapScale, value: number): boolean;
+/**
+ * Quantile of a sorted array at `p` (0 to 1), interpolating linearly
+ * between neighbours (the R-7 method spreadsheets use).
+ */
+export declare function quantileSorted(sorted: readonly number[], p: number): number;
+/** The `buckets - 1` inner edges that cut sorted values into equal counts. */
+export declare function quantileThresholds(sorted: readonly number[], buckets: number): number[];
+/**
+ * Quantile edges that cut something. Each raw edge moves up to the first
+ * value at or above it, which puts every value in the same bucket but makes
+ * the edge a value the data holds, so no bucket is left empty (an edge
+ * between two values could cut a band nothing falls in). Then edges that
+ * repeat go: when many values repeat (60% of cells at zero), several raw
+ * edges land on the same value, and kept they would put the minimum
+ * mid-scale. An edge at the minimum has nothing below it, so it goes too.
+ */
+export declare function usableQuantileEdges(sorted: readonly number[], buckets: number): number[];
+/** How many edges are at or below `value`: its bucket, 0 to edges.length. */
+export declare function thresholdBucket(value: number, thresholds: readonly number[]): number;
+/** Spreads bucket `bucket` of `bucketCount` evenly across the ten steps. */
+export declare function bucketStep(bucket: number, bucketCount: number): number;
+/**
+ * Works out a scale against the values that will be shown. Pass only the
+ * values of cells that render a colour: empty and low-sample cells must not
+ * stretch the domain.
+ */
+export declare function resolveScale(scale: HeatmapScale, values: readonly number[]): ResolvedHeatmapScale;
+/** How a margin combines its cells. */
+export type HeatmapAggregate = 'sum' | 'mean';
+/** One cell as aggregation sees it. */
+export interface AggregateInput {
+    value: number | null;
+    count?: number;
+}
+/** A combined value and the count behind it. */
+export interface AggregateResult {
+    value: number | null;
+    /** Sum of the counts, when any cell carried one. */
+    count?: number;
+}
+/** Sum of the values; empty cells are skipped. Null when nothing is left. */
+export declare function sumOf(cells: readonly AggregateInput[]): AggregateResult;
+/**
+ * Mean weighted by count: sum(value x count) / sum(count). This is the only
+ * correct way to combine rates (26% of 39 and 50% of 2 is 27%, not 38%).
+ * A cell without a count weighs 1, so data with no counts at all gets a
+ * plain mean. Cells with a count of 0 add nothing.
+ */
+export declare function weightedMean(cells: readonly AggregateInput[]): AggregateResult;
+/** Combines cells with the given method. */
+export declare function aggregate(cells: readonly AggregateInput[], method: HeatmapAggregate): AggregateResult;
+//# sourceMappingURL=heatmap-scale.d.ts.map