ngwr 15.0.1 → 15.2.0

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

@@ -0,0 +1,396 @@
+import * as i0 from "@angular/core";
+import { WrChartLegendItem } from "ngwr/charts/chart-legend";
+import { WrChartAxis, WrChartMarkerExtent, WrChartMarkerShape, 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 point of a {@link WrScatterSeries}: where it sits, and optionally how large it is and what it is called. */
+interface WrScatterPoint {
+  /** Where the point sits along the x axis. A point whose `x` or `y` is not a finite number is not drawn. */
+  readonly x: number;
+  /** Where the point sits along the y axis. */
+  readonly y: number;
+  /**
+   * A third value, drawn as the marker's AREA, which makes the chart a bubble chart: the
+   * largest size shown is drawn at `maxRadius`. A size that is not a finite number at or
+   * above zero counts as none, and the point is drawn at the plain point size.
+   */
+  readonly size?: number;
+  /**
+   * The point's own name — a country, a product. It heads the point's tooltip beside the
+   * series' name and is the point's row header in the data table, which numbers the
+   * points of a series from 1 otherwise.
+   */
+  readonly label?: string;
+}
+/** One series of a `<wr-scatter-chart>`: a name, its points, and optionally its colour. */
+interface WrScatterSeries {
+  /** The series' name, in the legend, the tooltip and the data table. */
+  readonly label: string;
+  /** The points, in any order. Repeated and uneven `x` values are fine. */
+  readonly data: readonly WrScatterPoint[];
+  /** Any CSS colour, `var(--wr-…)` included. Without one, the series takes the next palette colour. */
+  readonly color?: string;
+}
+/**
+ * Which number `valueFormat` is writing: an x value, a y value, or a point's `size`. The
+ * axis ticks pass `'x'` or `'y'`, the tooltip and the data table pass all three.
+ */
+type WrScatterAxis = 'x' | 'y' | 'size';
+/** One point as the chart draws it: its data, where it sits and how large it is. */
+interface DrawnPoint {
+  /** Its series' position and its own position in that series' `data`, which no other point shares. */
+  readonly key: string;
+  /** Its series' position in `series`. */
+  readonly series: number;
+  readonly seriesLabel: string;
+  readonly color: string;
+  readonly marker: WrChartMarkerShape;
+  /** Its position in its series' `data`, from 1: the row header of a point with no `label`. */
+  readonly n: number;
+  readonly x: number;
+  readonly y: number;
+  readonly size: number | null;
+  readonly label: string | null;
+  /** Its centre, as percentages of the drawing's width from the left and height from the top. */
+  readonly left: number;
+  readonly top: number;
+  /** Its radius in px. */
+  readonly r: number;
+  /** Its marker's path about the origin. */
+  readonly d: string;
+  /** How far its hover ring reaches from its centre, in px: what the tooltip points at and the pointer reads. */
+  readonly halo: WrChartMarkerExtent;
+}
+/**
+ * Points on two numeric axes: one series per marker shape, and an optional third value
+ * drawn as each point's area, which makes it a bubble chart. SVG-only — no external
+ * dependency.
+ *
+ * @example
+ * ```html
+ * <wr-scatter-chart
+ *   xLabel="Price"
+ *   yLabel="Rating"
+ *   [series]="[
+ *     { label: 'Laptops', data: [{ x: 899, y: 4.1 }, { x: 1299, y: 4.6 }] },
+ *     { label: 'Tablets', data: [{ x: 329, y: 3.9 }, { x: 599, y: 4.4 }] }
+ *   ]"
+ * />
+ * ```
+ *
+ * Each series is told apart by its marker's SHAPE as well as its colour — a circle, a
+ * square, a triangle, a diamond, a cross, a downward triangle — since the palette's
+ * colours sit too close in lightness to be read alone. Neither axis is forced to include
+ * zero: each is fitted to its data and snapped outward to a readable step, so no point
+ * lands exactly on the frame, and a single value sits in the middle with a step either
+ * side. A point can still sit a hair inside the frame, so the plot's padding grows to
+ * the largest marker drawn, and a bubble at the edge stays inside the chart's own box.
+ *
+ * The drawing is one named `role="img"` and takes no tab stop; the tooltip is pointer
+ * only. `dataTable` renders every value as a table only assistive technology reaches.
+ * The legend is a `ul[wr-chart-legend]` (`ngwr/charts/chart-legend`), and with
+ * `toggleableLegend` its rows show and hide their series through `hiddenSeries`.
+ *
+ * Hovering finds the nearest point by measuring every one, so a chart meant for more
+ * than a few thousand points is better served by binning them first.
+ *
+ * @see https://ngwr.dev/charts/scatter-chart
+ */
+export declare class WrScatterChart {
+  /**
+   * One entry per series. A series with no `color` takes the next entry from the chart's
+   * palette, and every series takes the next marker shape, so several series are told
+   * apart unconfigured.
+   */
+  readonly series: import("@angular/core").InputSignal<readonly WrScatterSeries[]>;
+  /**
+   * Accessible name of the chart. The legend carries the series NAMES only — the values
+   * are nowhere in text unless `dataTable` puts them there — so say what the chart shows.
+   * Falls back to `scatterChart.label` ("Scatter chart").
+   */
+  readonly ariaLabel: import("@angular/core").InputSignal<string | null>;
+  protected readonly resolvedAriaLabel: import("@angular/core").Signal<string>;
+  /**
+   * The x axis' name. Drawn under the axis only when given; either way it names the x
+   * row of the tooltip and the x column of the data table, which fall back to
+   * `scatterChart.x` ("X").
+   */
+  readonly xLabel: import("@angular/core").InputSignal<string | null>;
+  /**
+   * The y axis' name. Drawn above the axis only when given; either way it names the y
+   * row of the tooltip and the y column of the data table, which fall back to
+   * `scatterChart.y` ("Y").
+   */
+  readonly yLabel: import("@angular/core").InputSignal<string | null>;
+  /**
+   * What a point's `size` measures. It names the size row of the tooltip and the size
+   * column of the data table, which appear only when a point has a size, and falls back
+   * to `scatterChart.size` ("Size").
+   */
+  readonly sizeLabel: import("@angular/core").InputSignal<string | null>;
+  protected readonly xName: import("@angular/core").Signal<string>;
+  protected readonly yName: import("@angular/core").Signal<string>;
+  protected readonly sizeName: import("@angular/core").Signal<string>;
+  /**
+   * Writes every number the chart shows — the axis ticks, the tooltip and the data table —
+   * and is told which number it is writing: `'x'`, `'y'` or `'size'`, so the two axes can
+   * carry different units. A `(value) => string` written for another chart fits too. `null`
+   * uses `Intl.NumberFormat` in `LOCALE_ID`, with compact ticks (`1.2K`, `3.4M`) unless the
+   * full numbers are shorter.
+   */
+  readonly valueFormat: import("@angular/core").InputSignal<((value: number, axis: WrScatterAxis) => string) | null>;
+  /** The exact figures and the axes' compact ticks, in `LOCALE_ID` unless `valueFormat` is given. */
+  private readonly numbers;
+  /** The row headers of points with no `label`, which number them in the reader's own digits. */
+  private readonly ordinals;
+  /** The plot's height in px, at least 80. @default 240 */
+  readonly height: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  /** Show the gridlines and the tick labels of both axes. @default true */
+  readonly showGrid: import("@angular/core").InputSignalWithTransform<boolean, any>;
+  /** Show the legend above the chart. @default true */
+  readonly showLegend: import("@angular/core").InputSignalWithTransform<boolean, any>;
+  /**
+   * Make each legend row a toggle button that shows and hides its series, through
+   * `hiddenSeries`. A row is a `<button aria-pressed>`, pressed while its series is
+   * shown, so the legend becomes one tab stop per series. @default false
+   */
+  readonly toggleableLegend: import("@angular/core").InputSignalWithTransform<boolean, any>;
+  /**
+   * The positions in `series` of the series that are hidden. Positions rather than
+   * labels, since two series may share a label. A toggleable legend writes it, and a host
+   * may bind it with or without one: `[(hiddenSeries)]`.
+   *
+   * A hidden series is left out of everything that reads its values: it draws no points,
+   * the tooltip cannot land on them, the data table drops its rows, and both axes and the
+   * bubble scale are fitted to the series still shown, so hiding an outlier lets the rest
+   * fill the plot. Its legend row stays, struck through, so it can be shown again. With
+   * every series hidden the plot is the empty 0 to 1 frame. A position past the end of
+   * `series` is kept and ignored.
+   */
+  readonly hiddenSeries: import("@angular/core").ModelSignal<readonly number[]>;
+  /** Show a tooltip with the series, x, y and size of the point under the pointer. Pointer only. @default true */
+  readonly tooltip: import("@angular/core").InputSignalWithTransform<boolean, any>;
+  /**
+   * Render every point's values as a table only assistive technology reaches, beside the
+   * drawing: one group of rows per series shown, headed by the series' name, a row per
+   * point, and a column for x, for y and, when a point has one, for size. The drawing is
+   * one named image, so without it the values are nowhere a screen reader can walk.
+   * @default false
+   */
+  readonly dataTable: import("@angular/core").InputSignalWithTransform<boolean, any>;
+  /**
+   * The radius, in px, the largest `size` shown is drawn at. Every other sized point is
+   * scaled by AREA against it — a point of half the size has half the area, not half the
+   * radius — and none is drawn under 4px. At least 4. @default 20
+   */
+  readonly maxRadius: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  private readonly svg;
+  /**
+   * Every series, resolved: its palette colour, its marker shape, and its points with
+   * every one dropped whose `x` or `y` is not a finite number. Hidden ones included, since
+   * the legend lists them.
+   *
+   * A point that cannot be placed is left out rather than kept: one NaN in the pooled
+   * minimum makes every coordinate in every series NaN, and the whole chart vanishes
+   * instead of one point. A point keeps its position in its series' `data` all the same,
+   * so the data table numbers the rest as the consumer numbered them.
+   */
+  protected readonly resolvedSeries: import("@angular/core").Signal<{
+    index: number;
+    label: string;
+    color: string;
+    marker: WrChartMarkerShape;
+    points: {
+      n: number;
+      x: number;
+      y: number;
+      size: number | null;
+      label: string | null;
+    }[];
+  }[]>;
+  /** The legend's rows: every series, keyed by its own marker. */
+  protected readonly legendItems: import("@angular/core").Signal<readonly WrChartLegendItem[]>;
+  /** The series drawn, read and fitted to: every one `hiddenSeries` does not name. */
+  protected readonly visibleSeries: import("@angular/core").Signal<{
+    index: number;
+    label: string;
+    color: string;
+    marker: WrChartMarkerShape;
+    points: {
+      n: number;
+      x: number;
+      y: number;
+      size: number | null;
+      label: string | null;
+    }[];
+  }[]>;
+  /** The largest `size` among the points shown, or `null` when none has one — a plain scatter. */
+  private readonly maxSize;
+  /** Whether any point shown has a size, which adds the size row and column. */
+  protected readonly sized: import("@angular/core").Signal<boolean>;
+  /**
+   * The x axis, from `chartAxis` over the points shown: fitted to the data with no zero
+   * forced in, since a scatter has no baseline, snapped outward at both ends and lifted a
+   * step at EITHER end a point would sit on (`symmetric`), so no point lands exactly on
+   * the frame. A single value — one point, or a column of them — is centred with a step
+   * either side. With nothing to fit, the 0 to 1 frame.
+   */
+  protected readonly xAxis: import("@angular/core").Signal<WrChartAxis>;
+  /** The y axis, fitted the way {@link xAxis} is. */
+  protected readonly yAxis: import("@angular/core").Signal<WrChartAxis>;
+  /**
+   * The points as drawn: placed by percentage on both axes, sized, and ordered LARGEST
+   * FIRST so a small bubble is never buried under a large one. Points of equal size keep
+   * the series' order, so a plain scatter draws series by series.
+   */
+  protected readonly points: import("@angular/core").Signal<readonly DrawnPoint[]>;
+  /**
+   * How far the largest marker drawn reaches past its centre, in px, sideways and up or
+   * down — its hover ring included, so hovering moves nothing. The axes keep a point
+   * off the frame only when it lands exactly on it, and one a fraction of a step inside
+   * sits a few px from it; the stylesheet takes the larger of this and the plot's inset
+   * tokens as the plot's padding, so the marker stays inside the plot rather than over
+   * the tick labels or past the chart's own box. By SHAPE, not radius: a triangle's
+   * point reaches 1.56 times its radius up. The ring's stroke is the stylesheet's.
+   *
+   * Up or down it is held to a quarter of `height`, so a short plot with a large
+   * `maxRadius` keeps half its height for the drawing and lets the marker overhang.
+   */
+  protected readonly reach: import("@angular/core").Signal<{
+    x: number;
+    y: number;
+  }>;
+  /** The y ticks, top to bottom: each value's label and its gridline's distance from the top, in percent. */
+  protected readonly yTicks: import("@angular/core").Signal<{
+    label: string;
+    top: number;
+  }[]>;
+  /** The x ticks, left to right: each value's label and its gridline's distance from the left, in percent. */
+  protected readonly xTicks: import("@angular/core").Signal<{
+    label: string;
+    left: number;
+  }[]>;
+  /**
+   * How far apart two neighbouring x ticks are, as a percentage of the drawing's width —
+   * the room each tick label has, half on either side of its gridline, which the
+   * stylesheet bounds it to and ellipsises past.
+   */
+  protected readonly xSlot: import("@angular/core").Signal<number>;
+  /**
+   * One tooltip for the point under the pointer: the series' swatch and name with the
+   * point's own label as its heading, then a row each for x, y and size. It points at
+   * the box of the marker's hover ring from above, so the chip clears a large bubble and
+   * a triangle's point rather than sitting on its centre.
+   *
+   * Points are found by POSITION — the nearest within 16px of the pointer, or anywhere a
+   * larger marker reaches — so a point under the open chip can still be reached by
+   * moving onto it, the way a sparkline is scrubbed.
+   */
+  protected readonly tip: import("ngwr/popover").WrChartTooltip;
+  /** The point the tooltip is reading, ringed in the drawing. */
+  protected readonly activePoint: import("@angular/core").Signal<DrawnPoint | null>;
+  /** The ring round the hovered point: its own shape, a little larger. */
+  protected readonly haloPath: import("@angular/core").Signal<string>;
+  /**
+   * The figures for `dataTable`: the chart's name as the caption, one group per series
+   * shown and headed by its name, and a row per point headed by the point's `label` or
+   * its position in the series. Every value is written as the tooltip writes it; a point
+   * with no size has an empty size cell in a chart where others have one.
+   */
+  protected readonly tableData: import("@angular/core").Signal<WrChartTableData>;
+  /**
+   * The point under the pointer. A MOUSE event, as every chart's is: a tap fires the
+   * compatibility `mousemove` and no `pointermove`. Off every point, the open tooltip
+   * starts its grace period.
+   */
+  protected onPointerMove(event: MouseEvent): void;
+  /**
+   * The point nearest a viewport position: within 16px of its centre, or within the
+   * circle its hover ring fits in where that is larger — a triangle's point or a
+   * diamond's tips reach past its radius — and the nearest centre where several qualify.
+   * A drawing with no box (nothing laid out yet) answers nothing.
+   */
+  private pointAt;
+  /** One axis over the points shown: `chartAxis` with both ends kept off the data, and one value centred. */
+  private fit;
+  static ɵfac: i0.ɵɵFactoryDeclaration<WrScatterChart, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<WrScatterChart, "wr-scatter-chart", never, {
+    "series": {
+      "alias": "series";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaLabel": {
+      "alias": "ariaLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "xLabel": {
+      "alias": "xLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "yLabel": {
+      "alias": "yLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "sizeLabel": {
+      "alias": "sizeLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "valueFormat": {
+      "alias": "valueFormat";
+      "required": false;
+      "isSignal": true;
+    };
+    "height": {
+      "alias": "height";
+      "required": false;
+      "isSignal": true;
+    };
+    "showGrid": {
+      "alias": "showGrid";
+      "required": false;
+      "isSignal": true;
+    };
+    "showLegend": {
+      "alias": "showLegend";
+      "required": false;
+      "isSignal": true;
+    };
+    "toggleableLegend": {
+      "alias": "toggleableLegend";
+      "required": false;
+      "isSignal": true;
+    };
+    "hiddenSeries": {
+      "alias": "hiddenSeries";
+      "required": false;
+      "isSignal": true;
+    };
+    "tooltip": {
+      "alias": "tooltip";
+      "required": false;
+      "isSignal": true;
+    };
+    "dataTable": {
+      "alias": "dataTable";
+      "required": false;
+      "isSignal": true;
+    };
+    "maxRadius": {
+      "alias": "maxRadius";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "hiddenSeries": "hiddenSeriesChange";
+  }, never, never, true, never>;
+}
+export type { WrScatterAxis, WrScatterPoint, WrScatterSeries };

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

@@ -39,7 +39,10 @@ export declare class WrSparklineHarness extends ComponentHarness {
    * screen reader announces a graphic with nothing to say about it.
    */
   isDecorative(): Promise<boolean>;
-  /** Whether a trend line was drawn — `false` for an empty or single-point dataset. */
+  /**
+   * Whether a trend line was drawn — `false` for an empty dataset. A single point is a
+   * line that returns to its start, which the round cap paints as a dot, so it is `true`.
+   */
   hasLine(): Promise<boolean>;
   /** Whether the area under the line is filled (`showArea`). */
   hasArea(): Promise<boolean>;

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

@@ -23,7 +23,7 @@ export declare class WrSparkline {
    * named `role="img"` only when a consumer says what it shows.
    */
   readonly ariaLabel: import("@angular/core").InputSignal<string | null>;
-  /** Stroke colour. @default `var(--wr-color-primary)` */
+  /** Stroke colour. @default 'var(--wr-color-primary)' */
   readonly color: import("@angular/core").InputSignal<string>;
   /**
    * Line thickness in CSS pixels — `vector-effect="non-scaling-stroke"` keeps it at
@@ -31,7 +31,7 @@ export declare class WrSparkline {
    * @default 1.5
    */
   readonly strokeWidth: import("@angular/core").InputSignalWithTransform<number, unknown>;
-  /** Fill the area below the line. @default false */
+  /** Fill the area below the line, faintly (`--wr-sparkline-area-opacity`). @default false */
   readonly showArea: import("@angular/core").InputSignalWithTransform<boolean, any>;
   /** Show a dot at the last data point. @default true */
   readonly showTip: import("@angular/core").InputSignalWithTransform<boolean, any>;
@@ -48,11 +48,8 @@ export declare class WrSparkline {
    * Writes the value in the tooltip. `null` uses `Intl.NumberFormat` in `LOCALE_ID`.
    */
   readonly valueFormat: import("@angular/core").InputSignal<((value: number) => string) | null>;
-  private readonly locale;
+  /** The value as the tooltip writes it — in full, never compact, to `Intl`'s default precision. */
   private readonly numbers;
-  /** Below one, by significant digits, which keep 0.0004 from rounding to `0`. */
-  private readonly smallNumbers;
-  private formatValue;
   private readonly host;
   private readonly svg;
   private readonly marker;
@@ -72,6 +69,11 @@ export declare class WrSparkline {
     x: number;
     y: number;
   }[]>;
+  /**
+   * The line through every point. A lone point repeats itself: a subpath of one `M` is
+   * never stroked, so a one-value sparkline with `showTip` off drew nothing at all, and
+   * the round cap paints the repeat as a dot of the line's width.
+   */
   protected readonly linePath: import("@angular/core").Signal<string>;
   protected readonly areaPath: import("@angular/core").Signal<string>;
   /** A zero-length line at the last point, which a round cap paints as the tip dot. */

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

@@ -0,0 +1,131 @@
+import { BaseHarnessFilters, ComponentHarness, HarnessPredicate } from "@angular/cdk/testing";
+/** Narrows which `<wr-treemap-chart>` a harness query matches. */
+interface WrTreemapChartHarnessFilters extends BaseHarnessFilters {
+  /** Match the drawing's accessible name. */
+  readonly ariaLabel?: string | RegExp;
+  /** Match a chart that writes this name on one of its tiles. A tile too small for its name writes none. */
+  readonly tileLabel?: string | RegExp;
+}
+/**
+ * Where a tile was drawn, as the component wrote it: percentages of the plot, `start`
+ * from its inline-start edge — the left in LTR, the right in RTL.
+ */
+interface WrTreemapChartTileBox {
+  readonly start: number;
+  readonly top: number;
+  readonly width: number;
+  readonly height: number;
+}
+/** One tile as {@link WrTreemapChartHarness.getTiles} reads it, in the order drawn. */
+interface WrTreemapChartTile {
+  /** The name written on the tile, in its strip or in its corner; `null` when it has no room for one. */
+  readonly label: string | null;
+  /**
+   * The figure the component wrote on the tile, compact; `null` when the tile is too
+   * short for one or `showValues` is off. One wider than the tile is written and then
+   * wrapped out of sight by the stylesheet, which jsdom cannot show, so it is read here.
+   */
+  readonly value: string | null;
+  /** Whether its children are drawn inside it. A group too small for its children is drawn as one block, and is `false`. */
+  readonly group: boolean;
+  /** The colour the component handed the tile, which its tint is mixed from. */
+  readonly color: string | null;
+  /** Where it was drawn. */
+  readonly box: WrTreemapChartTileBox;
+}
+/**
+ * One row of the chart's data table (`dataTable`): the node's path as its row header,
+ * then its value and its share of the whole.
+ */
+interface WrTreemapChartTableRow {
+  /** The row header — the node's path, its names joined by ` / `. */
+  readonly header: string;
+  /** Its value and its share, as the tooltip writes them; `''` where it has none. */
+  readonly cells: readonly string[];
+}
+/**
+ * Test harness for `<wr-treemap-chart>`.
+ *
+ * **What it reads is what the component WROTE**: each tile's rectangle as the
+ * percentages on its `style` attribute, its colour as the custom property beside them,
+ * its name and figure as text, and the data table. Those are what the layout and the
+ * data wiring produce, and what breaks when either does. jsdom lays nothing out, so a
+ * name is read in full whether a browser would ellipsise it or not, and there is no
+ * method for whether it was. Nor for whether a value fits: the stylesheet hides a value
+ * wider than its tile by wrapping it out of sight, which takes a layout jsdom does not
+ * have, so {@link getTiles} gives the text the component printed, fitting or not.
+ *
+ * **The layout is cut for the plot's measured size**, and jsdom measures nothing: in a
+ * spec the chart cuts it for the width it assumes before measuring, 640 px, at its
+ * `height`. So a spec can pin areas and order, which hold at any size, and should not
+ * pin a tile's exact shape, which a browser's real width changes.
+ *
+ * **The tooltip is not opened from here.** It is pointer only, it renders into the
+ * overlay container rather than the chart, and it says nothing the data table does not:
+ * {@link getTableRows} reads the same path, value and share, which is where a keyboard
+ * and a screen reader find them too.
+ *
+ * @example
+ * ```ts
+ * const chart = await loader.getHarness(WrTreemapChartHarness.with({ ariaLabel: 'Budget' }));
+ *
+ * expect(await chart.getLabels()).toContain('Engineering');
+ * expect(await chart.getGroupCount()).toBe(2);
+ * ```
+ *
+ * @see https://ngwr.dev/guides/testing
+ */
+export declare class WrTreemapChartHarness extends ComponentHarness {
+  static hostSelector: string;
+  /** Build a predicate that narrows the query — pass to `getHarness` / `getAllHarnesses`. */
+  static with(options?: WrTreemapChartHarnessFilters): HarnessPredicate<WrTreemapChartHarness>;
+  /** The drawing's accessible name — the only thing about it a screen reader hears. */
+  getAccessibleName(): Promise<string | null>;
+  /**
+   * Every tile drawn, parents before their children and siblings largest first: its name
+   * and figure where it has room for them, whether it holds its children, its colour, and
+   * its rectangle.
+   *
+   * A node with no area — no value, zero, negative — draws no tile, and is in the data
+   * table all the same.
+   */
+  getTiles(): Promise<WrTreemapChartTile[]>;
+  /** How many tiles were drawn, groups and leaves together. */
+  getTileCount(): Promise<number>;
+  /** How many tiles hold their children inside them. */
+  getGroupCount(): Promise<number>;
+  /** How many tiles hold nothing: leaves, and groups too small to draw their children in. */
+  getLeafCount(): Promise<number>;
+  /**
+   * The names written on the tiles, in the order drawn — a group's in its strip, a leaf's
+   * in its corner. A tile too small for its name writes none, and `showLabels` off writes
+   * none at all.
+   */
+  getLabels(): Promise<string[]>;
+  /** Whether the hidden data table is rendered (`dataTable`). */
+  hasDataTable(): Promise<boolean>;
+  /**
+   * The data table's column headings: the value's name (`valueLabel`) and the share's.
+   *
+   * 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 node, parents before their children in the data's own
+   * order: its path, its value and its share of the whole, as a screen reader walks them.
+   * A node with no area has an empty share, and a leaf with no value an empty value too.
+   *
+   * Throws when the chart renders no table (`dataTable` off), for the reason
+   * {@link getTableColumns} gives.
+   */
+  getTableRows(): Promise<WrTreemapChartTableRow[]>;
+  /**
+   * The plot's height in pixels — `height` as the component wrote it — read off the
+   * `style` ATTRIBUTE of the plot rather than through `getCssValue()`, which answers from
+   * the laid-out box and so agrees in jsdom and not in a browser.
+   */
+  getPlotHeight(): Promise<number>;
+  private assertDataTable;
+}
+export type { WrTreemapChartHarnessFilters, WrTreemapChartTableRow, WrTreemapChartTile, WrTreemapChartTileBox };