ngwr 15.0.1 → 15.2.0

package/types/ngwr-charts-funnel-chart-testing.d.ts

@@ -0,0 +1,130 @@
+import { BaseHarnessFilters, ComponentHarness, HarnessPredicate } from "@angular/cdk/testing";
+/** Narrows which `<wr-funnel-chart>` a harness query matches. */
+interface WrFunnelChartHarnessFilters extends BaseHarnessFilters {
+  /** Match the chart's accessible name. */
+  readonly ariaLabel?: string | RegExp;
+  /** Match a chart with a stage of this label. */
+  readonly stageLabel?: string | RegExp;
+}
+/** One stage, as the chart draws and announces it. */
+interface WrFunnelChartHarnessStage {
+  /** The label printed beside the bar — the full text, ellipsised on screen or not. */
+  readonly label: string;
+  /**
+   * The value printed beside the bar, or `null` when none is: `showValues` is off, or the
+   * stage's value is missing.
+   */
+  readonly value: string | null;
+  /**
+   * The share of the first stage printed under the value — "40% of first" — or `null` when
+   * none is: the first stage, a stage with no such share, or a `conversion` that leaves it
+   * off the drawing.
+   */
+  readonly fromFirst: string | null;
+  /** What the stage announces: its label, its value and both conversions in one string. */
+  readonly name: string | null;
+  /**
+   * The bar's width as a percentage of the track, as the component wrote it, or `null` for
+   * a missing stage, which draws no bar. A stage of zero or below is `0`: its hairline is
+   * the stylesheet's floor, not a width.
+   */
+  readonly widthPercent: number | null;
+}
+/**
+ * One row of the chart's data table (`dataTable`): the stage it reads, as its row header,
+ * and its value and both conversions, in the order of the table's columns.
+ */
+interface WrFunnelChartTableRow {
+  /** The row header — the stage's label. */
+  readonly header: string;
+  /** The value, the share of the previous stage and the share of the first; `''` for a figure the stage does not have. */
+  readonly cells: readonly string[];
+}
+/**
+ * Test harness for `<wr-funnel-chart>`.
+ *
+ * **The bars are read as PERCENTAGES of the track, not as pixels.** Each bar's width is
+ * written inline as a share of the full width — the largest stage, or `max` — which is
+ * the one number that survives a test with no layout, and the component's whole job. It is
+ * read off the `style` ATTRIBUTE rather than through `getCssValue()`, which is
+ * `getComputedStyle()`: in a browser that answers the laid-out pixels and in jsdom the
+ * declaration, with nothing to say which, and with no inline width at all it would fall
+ * back to the stylesheet's and read as a stage of zero. The hairline a stage of zero keeps
+ * is the stylesheet's floor, so no method reports it.
+ *
+ * **Two questions are not one.** A stage's printed text and its accessible name are read
+ * separately ({@link WrFunnelChartHarnessStage.value} and {@link WrFunnelChartHarnessStage.name}): the
+ * row is an `img`, so the name is what a screen reader gets, and asserting only what is
+ * drawn would pass on a stage that announces nothing. The shares printed between the bars
+ * are `aria-hidden` for the same reason — {@link getGapLabels} reads what is drawn, the
+ * names carry the same figures.
+ *
+ * **The bands' shapes are not read.** Each is a `clip-path` polygon from one bar's width
+ * to the next, and asserting its corners would restate the bar widths this harness already
+ * reads; {@link getBandCount} counts them, since where one is missing is the decision
+ * worth catching — there is none next to a missing stage.
+ *
+ * **No hover method.** The tooltip repeats the stage's name, and the chip renders into
+ * the overlay container with nothing tying it to this chart, so a query for it would
+ * answer with whichever chart's chip is open. The same figures are in the names and in the
+ * data table, which {@link getTableRows} reads.
+ *
+ * @example
+ * ```ts
+ * const chart = await loader.getHarness(WrFunnelChartHarness);
+ *
+ * expect(await chart.getLabels()).toEqual(['Visited', 'Signed up', 'Paid']);
+ * expect((await chart.getStages())[1].widthPercent).toBe(40);
+ * expect(await chart.getGapLabels()).toEqual(['40%', '15%']);
+ * ```
+ *
+ * @see https://ngwr.dev/guides/testing
+ */
+export declare class WrFunnelChartHarness extends ComponentHarness {
+  static hostSelector: string;
+  /** Build a predicate that narrows the query — pass to `getHarness` / `getAllHarnesses`. */
+  static with(options?: WrFunnelChartHarnessFilters): HarnessPredicate<WrFunnelChartHarness>;
+  /** The chart's accessible name, on the `group` that holds the stages. */
+  getAccessibleName(): Promise<string | null>;
+  /** Every stage, from the top of the funnel down: what it prints, what it announces and how wide its bar is. */
+  getStages(): Promise<WrFunnelChartHarnessStage[]>;
+  /** How many stages the chart drew — one per stage given, a missing one included. */
+  getStageCount(): Promise<number>;
+  /** The labels beside the bars, in order — the full text, ellipsised on screen or not. */
+  getLabels(): Promise<string[]>;
+  /**
+   * The share of the stage above printed in each gap between two bars, from the top down —
+   * one entry per gap, so one fewer than there are stages. `null` where none is printed:
+   * a stage with no such share, or a `conversion` that leaves it off the drawing.
+   */
+  getGapLabels(): Promise<(string | null)[]>;
+  /**
+   * How many bands join two bars: one per gap whose two stages both have a value. A missing
+   * stage breaks the funnel on either side of it, since a band across it would draw a drop
+   * the data never gave.
+   */
+  getBandCount(): Promise<number>;
+  /** Whether any value is printed beside a bar (`showValues`). */
+  hasValues(): Promise<boolean>;
+  /** Whether the hidden data table is rendered (`dataTable`). */
+  hasDataTable(): Promise<boolean>;
+  /**
+   * The data table's column headings: the value, the share of the previous stage and the
+   * share of the first, in that order.
+   *
+   * Throws when the chart renders no table (`dataTable` off) rather than answering with
+   * no columns.
+   */
+  getTableColumns(): Promise<string[]>;
+  /**
+   * The data table's rows, one per stage: its label and its three figures, as a screen
+   * reader walks them. A stage above a fixed `max` is drawn full width and tabulated as
+   * itself, and a figure the stage does not have is `''`.
+   *
+   * Throws when the chart renders no table (`dataTable` off), for the reason
+   * {@link getTableColumns} gives.
+   */
+  getTableRows(): Promise<WrFunnelChartTableRow[]>;
+  private assertDataTable;
+}
+export type { WrFunnelChartHarnessFilters, WrFunnelChartHarnessStage, WrFunnelChartTableRow };

package/types/ngwr-charts-funnel-chart.d.ts

@@ -0,0 +1,296 @@
+import * as i0 from "@angular/core";
+import { WrChartTableData } from "ngwr/charts/core";
+/**
+ * @license
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/thekhegay/ngwr/blob/main/LICENSE
+ */
+/** One stage of a `<wr-funnel-chart>`: a name, how many reached it, and optionally its own colour. */
+interface WrFunnelStage {
+  /** The stage's name, beside its bar, in the tooltip and as its row header in the data table. */
+  readonly label: string;
+  /**
+   * How many reached the stage. A value that is not a finite number is MISSING: the stage
+   * draws no bar and no figure, and no conversion is worked out to or from it. Zero and a
+   * negative value draw a hairline, and a negative value is printed as given but gets no
+   * conversion, since a share of a negative count means nothing.
+   */
+  readonly value: number;
+  /** Any CSS colour, `var(--wr-…)` included. Left out, the stage takes the chart's `color`. */
+  readonly color?: string;
+}
+/**
+ * Which conversions a `<wr-funnel-chart>` prints on its drawing: `previous` puts each
+ * stage's share of the stage before it between the two bars, `first` puts its share of
+ * the first stage under its value, `both` does both and `none` neither. The tooltip, the
+ * accessible names and the data table carry both whatever this says.
+ */
+type WrFunnelConversion = 'both' | 'previous' | 'first' | 'none';
+/**
+ * Funnel chart: how many reached each stage of a sequence — visited, signed up, paid —
+ * and how many of them went on to the next. SVG-free and dependency-free: every part is
+ * HTML laid out by the stylesheet.
+ *
+ * @example
+ * ```html
+ * <wr-funnel-chart
+ *   [stages]="[
+ *     { label: 'Visited', value: 12000 },
+ *     { label: 'Signed up', value: 4800 },
+ *     { label: 'Activated', value: 2900 },
+ *     { label: 'Paid', value: 720 }
+ *   ]"
+ * />
+ * ```
+ *
+ * **The bars are honest about the values.** Each stage is a bar centred on the funnel's
+ * axis, its width proportional to its value — the largest stage, or `max`, is the full
+ * width. The funnel shape between two bars is a band from one bar's width to the next,
+ * so it narrows by exactly the drop and carries no value of its own. That is why this is
+ * bars and not a trapezoid per stage: a trapezoid's area depends on its neighbour, so a
+ * stage would look larger or smaller for what follows it.
+ *
+ * **What the data does not promise, the drawing does not assume.** A stage larger than
+ * the one before it is drawn WIDER and its conversion is above 100%, rather than clamped
+ * into a shape a funnel is expected to have. Zero and a negative value draw a hairline,
+ * never a negative width; a negative value is printed as given and gets no conversion. A
+ * value that is not a finite number is missing: no bar, no figure, no band to or from it,
+ * and no conversion that would need it.
+ *
+ * **The conversions.** Each stage after the first has two: its share of the stage before
+ * it, printed between the two bars, and its share of the first stage, printed under its
+ * value (`conversion` chooses which are printed). Both are percentages in `LOCALE_ID`,
+ * with one fraction digit and two significant digits below 1%, so a real conversion of
+ * 0.04% is not printed as `0%`; `percentFormat` replaces that.
+ *
+ * **What a screen reader gets.** The chart is a named `role="group"` of one `role="img"`
+ * per stage, as the bar chart's columns are, each named with its label, its value and both
+ * conversions — "Signed up: 4,800, 40% of previous, 40% of first". The whole sentence is a
+ * catalog template, one per shape — `funnelChart.stageName` with no conversion,
+ * `stageNameOne` with one and `stageNameBoth` with both — so a locale sets its own
+ * punctuation and order round the figures. The bands and the percentages between the bars
+ * are `aria-hidden`, since every figure they show is in a name already. `dataTable` adds
+ * the same figures as a table a reader can walk cell by cell. No part of the chart is a
+ * tab stop.
+ *
+ * Under RTL the labels and the figures swap sides; the bars and the bands are centred,
+ * so they read the same in both directions. A label takes its direction from its own
+ * text, so a Latin one is ellipsised at its end on an RTL page, and a figure from its
+ * own, so a sign stays in front of its digits.
+ *
+ * @see https://ngwr.dev/charts/funnel-chart
+ */
+export declare class WrFunnelChart {
+  /**
+   * The stages, from the top of the funnel down. Nothing is sorted: a stage is drawn where
+   * it is given, so a stage larger than the one before it shows as one.
+   */
+  readonly stages: import("@angular/core").InputSignal<readonly WrFunnelStage[]>;
+  /**
+   * Accessible name of the chart, and the data table's caption. Each stage names itself,
+   * so this says what the funnel is about. Falls back to `funnelChart.label`, then
+   * `'Funnel chart'`.
+   */
+  readonly ariaLabel: import("@angular/core").InputSignal<string | null>;
+  protected readonly resolvedAriaLabel: import("@angular/core").Signal<string>;
+  /**
+   * The colour of a stage with no `color` of its own. One colour by default, because the
+   * stages are one quantity measured along a sequence, not categories: every stage is
+   * named in text beside its bar, so colour tells nothing apart here.
+   * @default 'var(--wr-color-primary)'
+   */
+  readonly color: import("@angular/core").InputSignal<string>;
+  /**
+   * The value of a full-width bar. `0` makes it the largest stage shown; a value above
+   * `0` fixes it, so two funnels side by side share one scale. A stage above a fixed
+   * `max` is drawn full width, and its figure, the tooltip and the data table still give
+   * its own value. @default 0
+   */
+  readonly max: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  /**
+   * Which conversions are printed on the drawing: each stage's share of the stage before
+   * it, between the two bars (`previous`), its share of the first stage, under its value
+   * (`first`), `both` or `none`. The tooltip, every stage's accessible name and the data
+   * table carry both whatever this says. @default 'both'
+   */
+  readonly conversion: import("@angular/core").InputSignal<WrFunnelConversion>;
+  /** Print each stage's value beside its bar. @default true */
+  readonly showValues: import("@angular/core").InputSignalWithTransform<boolean, any>;
+  /**
+   * What the values count — visitors, orders — as the heading of the data table's value
+   * column. Falls back to `funnelChart.value` ("Value").
+   */
+  readonly valueLabel: import("@angular/core").InputSignal<string | null>;
+  /**
+   * Show a tooltip with the stage's label, value and both conversions on hover. Pointer
+   * only — each stage's accessible name already carries the same figures. @default true
+   */
+  readonly tooltip: import("@angular/core").InputSignalWithTransform<boolean, any>;
+  /**
+   * Writes every value the chart shows: beside the bars, in the tooltip, in the accessible
+   * names and in the data table. `null` uses `Intl.NumberFormat` in `LOCALE_ID`.
+   */
+  readonly valueFormat: import("@angular/core").InputSignal<((value: number) => string) | null>;
+  /**
+   * Writes every conversion the chart shows, given as a RATIO — `0.25` for a quarter, `1.2`
+   * for a stage that grew by a fifth — the number `Intl.NumberFormat`'s `percent` style
+   * takes, so one of those can be passed as it is. `null` uses that style in `LOCALE_ID`,
+   * with up to one fraction digit, and two significant digits below 1% so a small real
+   * conversion is not printed as `0%`.
+   */
+  readonly percentFormat: import("@angular/core").InputSignal<((ratio: number) => string) | null>;
+  /**
+   * Render the chart's figures as a table that only assistive technology reaches: a row
+   * per stage, headed by its label, with its value and both conversions, each written as
+   * the tooltip writes it. A figure the stage does not have is an empty cell.
+   *
+   * Each stage's accessible name already carries its figures; the table is for a reader
+   * who wants to move through them cell by cell, with the column headings read out. It is
+   * rendered beside the stages, clipped to nothing: it takes no room, draws nothing and
+   * holds no tab stop. @default false
+   */
+  readonly dataTable: import("@angular/core").InputSignalWithTransform<boolean, any>;
+  /** The figures in full, never compact, in `LOCALE_ID` unless `valueFormat` is given. */
+  private readonly numbers;
+  private readonly locale;
+  private readonly percents;
+  /** Below 1%, by significant digits, which keep 0.0004 from printing as `0%`. */
+  private readonly smallPercents;
+  private readonly stageName;
+  private readonly valueName;
+  private readonly fromPreviousName;
+  private readonly fromFirstName;
+  private readonly ofPrevious;
+  private readonly ofFirst;
+  /**
+   * A stage's accessible name, one sentence per shape, so a locale places the colon, the
+   * commas and the order itself: with no conversion (the first stage, or none that means
+   * anything), with one, and with both. Each conversion arrives already worded — "40% of
+   * previous" — from the two templates above.
+   */
+  private readonly stageNameText;
+  private readonly stageNameOneText;
+  private readonly stageNameBothText;
+  private readonly stageEls;
+  /** Whether the shares of the previous stage are printed between the bars. */
+  protected readonly showPrevious: import("@angular/core").Signal<boolean>;
+  /** Whether the shares of the first stage are printed under the values. */
+  protected readonly showFirst: import("@angular/core").Signal<boolean>;
+  /**
+   * Every stage, resolved. The full width is a fixed `max`, else the largest value given,
+   * else 1 — so a funnel of zeros draws hairlines rather than dividing by nothing.
+   */
+  private readonly resolved;
+  /**
+   * The stages as drawn and announced: every figure written once, here, so the drawing,
+   * the names, the tooltip and the table cannot disagree.
+   *
+   * `band` is the shape between a stage and the one above it: a `clip-path` polygon on
+   * the track's width, from the upper bar's width at its top edge to this bar's at its
+   * bottom, both centred. There is none next to a missing stage, since joining across one
+   * would draw a drop the data never gave.
+   */
+  protected readonly rows: import("@angular/core").Signal<{
+    label: string;
+    value: number | null;
+    color: string;
+    /** The bar's inline width, a percentage of the track. */
+    width: string;
+    valueText: string;
+    previousText: string;
+    firstText: string;
+    /** The share of the first stage as it is printed under the value: "40% of first". */
+    ofFirstText: string;
+    /** What the stage announces: its label, its value and both conversions. */
+    name: string;
+    band: string | null;
+    /** The paint of the stage above, where the band starts. */
+    bandFrom: string;
+  }[]>;
+  /**
+   * The figures for `dataTable`: the chart's name as the caption, a row per stage, and its
+   * value and both conversions as the columns, each cell written as the tooltip writes it.
+   */
+  protected readonly tableData: import("@angular/core").Signal<WrChartTableData>;
+  /**
+   * One tooltip for the whole chart, for the stage under the pointer: its label and value
+   * as the heading, and a row for each conversion it has. It points at the top edge of the
+   * BAR, so the chip sits over the band and the percentage it repeats; a stage of zero
+   * keeps its hairline to point at. A missing stage opens none — it has no figure to show.
+   */
+  protected readonly tip: import("ngwr/popover").WrChartTooltip;
+  /**
+   * The stage the open tooltip is about, which the active row's wash marks: the hovered
+   * stage, unless it is missing. A missing stage opens no tooltip, and `tip.active()` is
+   * the hovered index whatever the resolver returned, so without this the wash would mark
+   * a row with nothing to show.
+   */
+  protected readonly activeStage: import("@angular/core").Signal<number | null>;
+  /**
+   * The accessible name of a stage with a value: the sentence for the conversions it has,
+   * each already worded. A missing stage is named by its label alone.
+   */
+  private nameOf;
+  /** A conversion as the chart prints it: through `percentFormat`, or as a percentage in `LOCALE_ID`. */
+  private percent;
+  static ɵfac: i0.ɵɵFactoryDeclaration<WrFunnelChart, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<WrFunnelChart, "wr-funnel-chart", never, {
+    "stages": {
+      "alias": "stages";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaLabel": {
+      "alias": "ariaLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "color": {
+      "alias": "color";
+      "required": false;
+      "isSignal": true;
+    };
+    "max": {
+      "alias": "max";
+      "required": false;
+      "isSignal": true;
+    };
+    "conversion": {
+      "alias": "conversion";
+      "required": false;
+      "isSignal": true;
+    };
+    "showValues": {
+      "alias": "showValues";
+      "required": false;
+      "isSignal": true;
+    };
+    "valueLabel": {
+      "alias": "valueLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "tooltip": {
+      "alias": "tooltip";
+      "required": false;
+      "isSignal": true;
+    };
+    "valueFormat": {
+      "alias": "valueFormat";
+      "required": false;
+      "isSignal": true;
+    };
+    "percentFormat": {
+      "alias": "percentFormat";
+      "required": false;
+      "isSignal": true;
+    };
+    "dataTable": {
+      "alias": "dataTable";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+export type { WrFunnelConversion, WrFunnelStage };

package/types/ngwr-charts-gauge-testing.d.ts

@@ -35,6 +35,11 @@ export declare class WrGaugeHarness extends ComponentHarness {
   getMin(): Promise<number>;
   /** The top of the range, from `aria-valuemax`. */
   getMax(): Promise<number>;
+  /**
+   * A finite number off one of the meter's attributes, or a sentence saying which one
+   * it lacks. `Number(null)` is `0`, so a lost binding read as a range starting at zero.
+   */
+  private numberAttribute;
   /**
    * The spoken form of the value — the number with its suffix.
    *

package/types/ngwr-charts-gauge.d.ts

@@ -23,10 +23,12 @@ export declare class WrGauge {
   readonly value: import("@angular/core").InputSignalWithTransform<number, unknown>;
   /**
    * Low end of the scale — where the arc starts. Values below it clamp here.
+   * @default 0
    */
   readonly min: import("@angular/core").InputSignalWithTransform<number, unknown>;
   /**
    * High end of the scale — where the arc completes. Values above it clamp here.
+   * @default 100
    */
   readonly max: import("@angular/core").InputSignalWithTransform<number, unknown>;
   /** Diameter in CSS pixels. @default 160 */
@@ -35,12 +37,14 @@ export declare class WrGauge {
   readonly strokeWidth: import("@angular/core").InputSignalWithTransform<number, unknown>;
   /**
    * Colour of the unfilled arc behind the value. Any CSS colour; the default is
-   * the outline token at 60%, which reads as a hairline in both themes.
+   * `--wr-border-base` at 60%, which reads as a hairline in both themes.
+   * @default color-mix(in srgb, var(--wr-border-base) 60%, transparent)
    */
   readonly trackColor: import("@angular/core").InputSignal<string>;
   /**
    * Colour of the filled arc. Any CSS colour — pass an intent token to tie it to
    * a threshold, e.g. `var(--wr-color-danger)` once the value crosses one.
+   * @default 'var(--wr-color-primary)'
    */
   readonly valueColor: import("@angular/core").InputSignal<string>;
   /** Show the value text in the center. @default true */
@@ -61,10 +65,8 @@ export declare class WrGauge {
    * number.
    */
   readonly valueFormat: import("@angular/core").InputSignal<((value: number) => string) | null>;
-  private readonly locale;
+  /** The reading as the centre, the tooltip and `aria-valuetext` write it: never compact. */
   private readonly numbers;
-  /** Below one, by significant digits, which keep 0.0004 from rounding to `0`. */
-  private readonly smallNumbers;
   private readonly surface;
   protected readonly cx = 50;
   protected readonly cy = 50;

package/types/ngwr-charts-heatmap-chart-testing.d.ts

@@ -0,0 +1,148 @@
+import { BaseHarnessFilters, ComponentHarness, HarnessPredicate } from "@angular/cdk/testing";
+/** Narrows which `<wr-heatmap-chart>` a harness query matches. */
+interface WrHeatmapChartHarnessFilters extends BaseHarnessFilters {
+  /** Match the matrix's accessible name. */
+  readonly ariaLabel?: string | RegExp;
+  /** Match a chart with a row of this name. */
+  readonly rowLabel?: string | RegExp;
+  /** Match a chart with a column of this name. */
+  readonly columnLabel?: string | RegExp;
+}
+/** One cell as {@link WrHeatmapChartHarness.getCells} reads it, row by row. */
+interface WrHeatmapChartCell {
+  /** Its row's position, from 0, in the order of the row names. */
+  readonly row: number;
+  /** Its column's position, from 0, in the order of the column names. */
+  readonly column: number;
+  /** Its value, or `null` for an empty cell: no data, which is not zero. */
+  readonly value: number | null;
+  /**
+   * Its level as a place on the scale, as the component wrote it, from 0 (the lowest level)
+   * to 1 (the colour itself); `null` for an empty cell, which is hatched instead.
+   */
+  readonly level: number | null;
+  /** Whether it is drawn as empty — hatched and outlined. */
+  readonly empty: boolean;
+  /** The value printed in it with `showValues`, `''` when it prints none. */
+  readonly text: string;
+}
+/**
+ * One row of the chart's data table (`dataTable`): the row's name, as its row header,
+ * and one cell per column, in the order of the table's columns.
+ */
+interface WrHeatmapChartTableRow {
+  /** The row header — the row's name. */
+  readonly header: string;
+  /** Each column's value, written as the tooltip writes it; an empty cell is `noDataLabel`. */
+  readonly cells: readonly string[];
+}
+/**
+ * Test harness for `<wr-heatmap-chart>`.
+ *
+ * **A cell's colour is not read.** Its paint is a `color-mix()` the stylesheet works out
+ * from the level the component writes on it, and jsdom has no cascade to resolve one — a
+ * computed read would answer the same for a cell on the right level and one on the wrong
+ * one. What {@link getCells} reads instead is what the component WROTE: the value and the
+ * position on `data-*`, the level off the `style` attribute, and whether the cell
+ * is drawn empty. Those are what break when the data wiring does.
+ *
+ * **Whether a printed value fits is not read either.** The stylesheet hides a value wider
+ * than its cell by wrapping it out of sight, which takes a layout jsdom does not have;
+ * {@link getCells} gives the text the component printed, fitting or not.
+ *
+ * **Which column names are drawn is not read.** Where the names are wider than their
+ * columns the chart draws every n-th one and keeps the rest out of sight, decided by
+ * measuring the layout after render — jsdom has none, so every name is drawn there, and a
+ * method asking would answer "all of them" for a chart that thins and for one that is
+ * broken alike. {@link getColumnLabels} gives every name, drawn or not, as a screen reader
+ * reads them.
+ *
+ * **There is no hover method.** The tooltip renders into the overlay container, tied to
+ * nothing a harness could scope it by — the chip is `aria-hidden` and publishes no id —
+ * and the numbers it shows are on the cells and in the data table, which
+ * {@link getTableRows} reads, and which is where a screen reader finds them too.
+ *
+ * @example
+ * ```ts
+ * const chart = await loader.getHarness(WrHeatmapChartHarness);
+ *
+ * expect(await chart.getRowLabels()).toEqual(['Mon', 'Tue']);
+ * expect((await chart.getCell(1, 0)).empty).toBe(true);
+ * expect(await chart.getScaleRange()).toEqual({ min: '0', max: '41' });
+ * ```
+ *
+ * @see https://ngwr.dev/guides/testing
+ */
+export declare class WrHeatmapChartHarness extends ComponentHarness {
+  static hostSelector: string;
+  /** Build a predicate that narrows the query — pass to `getHarness` / `getAllHarnesses`. */
+  static with(options?: WrHeatmapChartHarnessFilters): HarnessPredicate<WrHeatmapChartHarness>;
+  /**
+   * The matrix's accessible name — the only name it has. Read off the cells, which carry
+   * the `img` role, rather than off the host: a name on a wrapper round the row and column
+   * names would take those names out of the accessibility tree.
+   */
+  getAccessibleName(): Promise<string | null>;
+  /** The rows' names, top to bottom, as drawn — the full text, ellipsised or not, positions included for unnamed rows. */
+  getRowLabels(): Promise<string[]>;
+  /** The columns' names, from inline start — the full text of every one, ellipsised, out of sight or neither. */
+  getColumnLabels(): Promise<string[]>;
+  /** How many cells were drawn: one per row and column, empty ones included. */
+  getCellCount(): Promise<number>;
+  /**
+   * Every cell, row by row: its position, its value, the level it was drawn on and the text
+   * it prints. Read from `data-row`, `data-column` and `data-value`, which the component
+   * writes for exactly this, and the level off the `style` ATTRIBUTE — never through
+   * `getCssValue()`, which would resolve whatever the stylesheet says at exactly the
+   * moment the binding is what broke.
+   */
+  getCells(): Promise<WrHeatmapChartCell[]>;
+  /**
+   * The cell at a row and a column, both from 0. Throws for a position the matrix does not
+   * have rather than answering with an empty cell, which is a real thing a cell can be.
+   */
+  getCell(row: number, column: number): Promise<WrHeatmapChartCell>;
+  /** Whether the legend is rendered (`showLegend`, and a scale or an empty cell to key). */
+  hasLegend(): Promise<boolean>;
+  /**
+   * The legend's two ends, the scale's minimum and maximum, compact from a thousand as the
+   * cells print a value. A scale with no span is keyed by one figure, which is both ends.
+   * Throws when the legend draws no scale — `showLegend` off, or no value and no bound to
+   * scale — rather than answering with two empty strings.
+   */
+  getScaleRange(): Promise<{
+    min: string;
+    max: string;
+  }>;
+  /**
+   * How many levels the legend keys — `levels`, as drawn, or 1 for a scale with no span.
+   * Throws when it draws no scale, as {@link getScaleRange} does.
+   */
+  getLevelCount(): Promise<number>;
+  /**
+   * The name the legend keys the hatching with (`noDataLabel`), or `null` while it keys
+   * none: no cell is empty, or the legend is off.
+   */
+  getNoDataLabel(): Promise<string | null>;
+  /** Whether the hidden data table is rendered (`dataTable`). */
+  hasDataTable(): Promise<boolean>;
+  /**
+   * The data table's column headings: one per column, in order.
+   *
+   * Throws when the chart renders no table (`dataTable` off) rather than answering with no
+   * columns, which is also what a matrix with no columns answers.
+   */
+  getTableColumns(): Promise<string[]>;
+  /**
+   * The data table's rows, one per row: its name and each column's value, as a screen
+   * reader walks them. A value outside a given `min` or `max` is drawn on the end level and
+   * tabulated as itself; an empty cell is `noDataLabel`.
+   *
+   * Throws when the chart renders no table (`dataTable` off), for the reason
+   * {@link getTableColumns} gives.
+   */
+  getTableRows(): Promise<WrHeatmapChartTableRow[]>;
+  private assertScale;
+  private assertDataTable;
+}
+export type { WrHeatmapChartCell, WrHeatmapChartHarnessFilters, WrHeatmapChartTableRow };