ngwr 15.0.1 → 15.2.0

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

@@ -0,0 +1,165 @@
+import { BaseHarnessFilters, ComponentHarness, HarnessPredicate } from "@angular/cdk/testing";
+/** Narrows which `<wr-boxplot-chart>` a harness query matches. */
+interface WrBoxplotChartHarnessFilters extends BaseHarnessFilters {
+  /** Match the plot's accessible name. */
+  readonly ariaLabel?: string | RegExp;
+  /** Match a chart with a group of this name. */
+  readonly groupLabel?: string | RegExp;
+}
+/** A group's summary, as the component wrote it beside the marks it drew. */
+interface WrBoxplotChartHarnessStats {
+  /** Where the lower whisker ends. */
+  readonly min: number;
+  readonly q1: number;
+  readonly median: number;
+  readonly q3: number;
+  /** Where the upper whisker ends. */
+  readonly max: number;
+  /** The outliers drawn, ascending. */
+  readonly outliers: readonly number[];
+}
+/**
+ * Where a group's marks sit, each as a percentage of the drawing's height from its top —
+ * read off the custom properties the component wrote, never off a layout.
+ */
+interface WrBoxplotChartHarnessPosition {
+  /** The upper whisker, from its end at `max` down to the box's upper edge. */
+  readonly upperWhisker: {
+    readonly top: number;
+    readonly bottom: number;
+  };
+  /** The lower whisker, from the box's lower edge down to its end at `min`. */
+  readonly lowerWhisker: {
+    readonly top: number;
+    readonly bottom: number;
+  };
+  /** The upper whisker's cap: where `max` sits. */
+  readonly max: number;
+  /** The box's upper edge: where `q3` sits, for a summary in order. */
+  readonly boxTop: number;
+  /** The median line. */
+  readonly median: number;
+  /** The box's lower edge: where `q1` sits, for a summary in order. */
+  readonly boxBottom: number;
+  /** The lower whisker's cap: where `min` sits. */
+  readonly min: number;
+  /** Each outlier's dot, in the order of `stats.outliers`. */
+  readonly outliers: readonly number[];
+}
+/** One group, as {@link WrBoxplotChartHarness.getGroups} reads it. */
+interface WrBoxplotChartHarnessGroup {
+  /** The name under the group's slot. */
+  readonly label: string;
+  /**
+   * Where the group's slot starts, as a percentage of the drawing's width from its inline
+   * start: the left edge, or the right one under RTL.
+   */
+  readonly slotStart: number;
+  /** How wide the group's slot is, as a percentage of the drawing's width. */
+  readonly slotWidth: number;
+  /** The colour the group is drawn in, as the component wrote it. */
+  readonly color: string | null;
+  /** The group's summary, or `null` when it has nothing to draw and its slot is empty. */
+  readonly stats: WrBoxplotChartHarnessStats | null;
+  /** Where its marks sit, or `null` when it draws none. */
+  readonly position: WrBoxplotChartHarnessPosition | null;
+}
+/** The axes' names as drawn, each `null` when the chart draws none (`xLabel` / `yLabel` not given). */
+interface WrBoxplotChartAxisTitles {
+  readonly x: string | null;
+  readonly y: string | null;
+}
+/** One row of the chart's data table (`dataTable`): a group, with one cell per column. */
+interface WrBoxplotChartTableRow {
+  /** The row header: the group's name. */
+  readonly header: string;
+  /**
+   * The lower whisker, Q1, the median, Q3 and the upper whisker, written as the tooltip
+   * writes them, then — when the table has the column — the outliers in one list. A
+   * group with nothing to draw has empty cells.
+   */
+  readonly cells: readonly string[];
+}
+/**
+ * Test harness for `<wr-boxplot-chart>`.
+ *
+ * **Groups are read off what the component WROTE, never off a layout.** jsdom lays
+ * nothing out, so a measured box would read 0 for a working chart and a broken one alike.
+ * Every group's slot carries its summary in `data-*` attributes, and every mark the
+ * percentages it was placed at in its own `style` — so {@link getGroups} answers both
+ * questions a spec has: what did the chart work out, and where did it draw it. A median
+ * computed right and placed wrong is exactly the defect worth catching.
+ *
+ * **There is deliberately no hover method.** The tooltip renders into an overlay outside
+ * the chart's host and is pointer only; a spec that needs it dispatches `mouseenter` on a
+ * `.wr-boxplot-chart__group` and reads `.wr-chart-tooltip` off `document`, as the
+ * component's own spec does. Its position is measured against boxes jsdom reports as
+ * 0×0, which only a stubbed `getBoundingClientRect` can make mean anything.
+ *
+ * @example
+ * ```ts
+ * const chart = await loader.getHarness(WrBoxplotChartHarness);
+ *
+ * expect(await chart.getGroupLabels()).toEqual(['EU', 'US']);
+ * expect((await chart.getGroups())[0].stats).toMatchObject({ q1: 101, median: 118, q3: 134 });
+ * ```
+ *
+ * @see https://ngwr.dev/guides/testing
+ */
+export declare class WrBoxplotChartHarness extends ComponentHarness {
+  static hostSelector: string;
+  /** Build a predicate that narrows the query — pass to `getHarness` / `getAllHarnesses`. */
+  static with(options?: WrBoxplotChartHarnessFilters): HarnessPredicate<WrBoxplotChartHarness>;
+  /** The plot's accessible name — the only name the drawing has. */
+  getAccessibleName(): Promise<string | null>;
+  /** The group names under the drawing, in the order of `groups` — groups with nothing to draw included. */
+  getGroupLabels(): Promise<string[]>;
+  /** How many slots the drawing has: one per group, drawn or empty. */
+  getGroupCount(): Promise<number>;
+  /**
+   * Every group, in the order of `groups`: its name, its slot, its colour, the summary the
+   * component worked out or was given, and the percentages it drew each mark at — both
+   * whiskers' spans, both caps, the box's edges, the median and every outlier. A group
+   * with nothing to draw answers `null` for both of the last two.
+   *
+   * Throws on a mark missing what the component writes on every one, rather than
+   * answering with a `NaN` a spec could compare against.
+   */
+  getGroups(): Promise<WrBoxplotChartHarnessGroup[]>;
+  /** Whether the gridlines are drawn (`showGrid`). */
+  hasGrid(): Promise<boolean>;
+  /** The value axis' tick labels, top to bottom; `[]` with `showGrid` off. */
+  getYTicks(): Promise<string[]>;
+  /**
+   * The axes' names as drawn. The chart draws a name only when `xLabel` or `yLabel` is
+   * given, so the catalog's fallback, which heads the data table's group column, never
+   * appears here.
+   */
+  getAxisTitles(): Promise<WrBoxplotChartAxisTitles>;
+  /** Whether the hidden data table is rendered (`dataTable`). */
+  hasDataTable(): Promise<boolean>;
+  /**
+   * The data table's column headings: the five numbers from the lower whisker up, and the
+   * outliers once a group has one — one per cell of {@link getTableRows}, as the other
+   * charts' harnesses read them.
+   *
+   * 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 group, as a screen reader walks them.
+   *
+   * Throws when the chart renders no table (`dataTable` off), for the reason
+   * {@link getTableColumns} gives.
+   */
+  getTableRows(): Promise<WrBoxplotChartTableRow[]>;
+  /**
+   * The plot's height in pixels, read off the `style` ATTRIBUTE the component wrote,
+   * not through `getCssValue()`, which answers from the laid-out box and so differs
+   * between jsdom and a browser.
+   */
+  getPlotHeight(): Promise<number>;
+  private assertDataTable;
+}
+export type { WrBoxplotChartAxisTitles, WrBoxplotChartHarnessFilters, WrBoxplotChartHarnessGroup, WrBoxplotChartHarnessPosition, WrBoxplotChartHarnessStats, WrBoxplotChartTableRow };

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

@@ -0,0 +1,308 @@
+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
+ */
+/**
+ * The five numbers a `<wr-boxplot-chart>` draws for one group, plus the values it draws
+ * as dots beyond them.
+ *
+ * `min` and `max` are the WHISKERS' ends, not the extremes of the data: with outliers,
+ * the whisker stops at the farthest value that is not one, and the outliers lie past it.
+ */
+interface WrBoxplotStats {
+  /** Where the lower whisker ends: the smallest value that is not an outlier. */
+  readonly min: number;
+  /** The first quartile: the box's lower edge. */
+  readonly q1: number;
+  /** The median: the line across the box. */
+  readonly median: number;
+  /** The third quartile: the box's upper edge. */
+  readonly q3: number;
+  /** Where the upper whisker ends: the largest value that is not an outlier. */
+  readonly max: number;
+  /** The values drawn as dots past the whiskers, in any order. One that is not a finite number is left out. */
+  readonly outliers?: readonly number[];
+}
+/**
+ * One box of a `<wr-boxplot-chart>`: a name, and either the raw values to summarise or
+ * the summary itself.
+ */
+interface WrBoxplotGroup {
+  /** The group's name: under its box, in the tooltip and as its data table row. */
+  readonly label: string;
+  /**
+   * The raw values, in any order. The chart works out the quartiles by linear
+   * interpolation (type 7: R's default, NumPy's and Excel's `QUARTILE.INC`) and draws
+   * the whiskers to the farthest value within 1.5 IQR of the box; anything farther is an
+   * outlier. A value that is not a finite number is left out. Ignored when `stats` is
+   * given.
+   */
+  readonly values?: readonly number[];
+  /**
+   * A summary worked out elsewhere, drawn as given: nothing is recomputed, reordered or
+   * checked against `values`. A summary with a number that is not finite draws nothing.
+   */
+  readonly stats?: WrBoxplotStats;
+  /** Any CSS colour, `var(--wr-…)` included. Without one, the group takes the chart's `color`. */
+  readonly color?: string;
+}
+/** A group's summary as the chart reads it: every number finite, the outliers ascending. */
+type Summary = Required<WrBoxplotStats>;
+/** Where one group's marks sit, each as a percentage of the drawing's height from its top. */
+interface DrawnBox {
+  /** The upper whisker, from its end down to the box. */
+  readonly upper: {
+    readonly top: number;
+    readonly bottom: number;
+  };
+  /** The lower whisker, from the box down to its end. */
+  readonly lower: {
+    readonly top: number;
+    readonly bottom: number;
+  };
+  /** The box, from the third quartile down to the first. */
+  readonly box: {
+    readonly top: number;
+    readonly bottom: number;
+  };
+  readonly max: number;
+  readonly median: number;
+  readonly min: number;
+  readonly outliers: readonly {
+    readonly value: number;
+    readonly top: number;
+  }[];
+  /** Everything the group draws, outliers included: what the tooltip points at. */
+  readonly extent: {
+    readonly top: number;
+    readonly bottom: number;
+  };
+}
+/** One group as the chart draws it: its data, its slot across the drawing and its marks. */
+interface DrawnGroup {
+  /** Its position in `groups`. */
+  readonly index: number;
+  readonly label: string;
+  readonly color: string;
+  /** Its summary, or `null` when it has nothing to draw. */
+  readonly stats: Summary | null;
+  /**
+   * Where its slot starts, as a percentage of the drawing's width from its inline start:
+   * the left, or the right under RTL.
+   */
+  readonly start: number;
+  /** How wide its slot is, as a percentage of the drawing's width. */
+  readonly slot: number;
+  readonly marks: DrawnBox | null;
+}
+/**
+ * Box-and-whisker plots of several groups side by side, on one value axis: a box from the
+ * first quartile to the third with a line at the median, a whisker either side, and a dot
+ * per outlier. No SVG and no dependency: every mark is an HTML element placed by
+ * percentage, so a box keeps its width however tall the plot is.
+ *
+ * @example
+ * ```html
+ * <wr-boxplot-chart
+ *   ariaLabel="Response time by region"
+ *   [groups]="[
+ *     { label: 'EU', values: [112, 98, 130, 141, 104, 99, 260] },
+ *     { label: 'US', stats: { min: 80, q1: 101, median: 118, q3: 134, max: 170, outliers: [240] } }
+ *   ]"
+ * />
+ * ```
+ *
+ * From `values`, the chart works out the quartiles by LINEAR INTERPOLATION — type 7 of
+ * Hyndman and Fan, the default of R's and NumPy's `quantile()` and what Excel's
+ * `QUARTILE.INC` computes — and Tukey's whiskers: each reaches the farthest value within
+ * 1.5 interquartile ranges of the box, and every value beyond is an outlier. A summary
+ * worked out elsewhere goes in `stats` and is drawn exactly as given.
+ *
+ * The value axis is fitted to every number drawn, outliers included, with no zero forced
+ * in — a box plot has no baseline — and snapped outward to a readable step. The groups
+ * share the drawing's width in equal slots under their names, in reading order: left to
+ * right, and right to left under RTL, as the bar chart's columns are, so the first group
+ * stands beside the value axis either way.
+ *
+ * The drawing is one named `role="img"` and takes no tab stop; the tooltip, with the five
+ * numbers and the outliers past them, is pointer only. `dataTable` renders every group's
+ * numbers as a table only assistive technology reaches.
+ *
+ * @see https://ngwr.dev/charts/boxplot-chart
+ */
+export declare class WrBoxplotChart {
+  /**
+   * One entry per box, in reading order: each with its raw `values` or a `stats` summary
+   * worked out elsewhere. A group with neither, or with nothing finite to summarise,
+   * keeps its slot and its name and draws no box.
+   */
+  readonly groups: import("@angular/core").InputSignal<readonly WrBoxplotGroup[]>;
+  /**
+   * Accessible name of the chart. The numbers are nowhere in text unless `dataTable`
+   * puts them there, so say what the chart shows. Falls back to `boxplotChart.label`
+   * ("Box plot").
+   */
+  readonly ariaLabel: import("@angular/core").InputSignal<string | null>;
+  protected readonly resolvedAriaLabel: import("@angular/core").Signal<string>;
+  /**
+   * What the groups are — a region, a release. Drawn under the group names only when
+   * given; either way it heads the group column of the data table, which falls back to
+   * `boxplotChart.group` ("Group").
+   */
+  readonly xLabel: import("@angular/core").InputSignal<string | null>;
+  /** What the values measure, with their unit. Drawn above the value axis only when given. */
+  readonly yLabel: import("@angular/core").InputSignal<string | null>;
+  protected readonly xName: import("@angular/core").Signal<string>;
+  private readonly upperName;
+  private readonly q3Name;
+  private readonly medianName;
+  private readonly q1Name;
+  private readonly lowerName;
+  private readonly outliersName;
+  /**
+   * Writes every number the chart shows: the axis ticks, the tooltip and the data table.
+   * `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) => string) | null>;
+  /** The figures in full and the axis' compact ticks, in `LOCALE_ID` unless `valueFormat` is given. */
+  private readonly numbers;
+  private readonly locale;
+  /** How many outliers the tooltip leaves unwritten, in the reader's own digits: a count, never a value to format. */
+  private readonly counts;
+  /** The tooltip's tail for the outliers past the first few it writes out. */
+  private readonly moreOutliers;
+  /**
+   * A group's outliers in one data table cell, as the locale lists them. A narrow
+   * CONJUNCTION list, because a unit list separates them with bare spaces in several
+   * locales, and a space is the digit grouping of Russian and French: `9 000 12 000`.
+   */
+  private readonly list;
+  /** The colour of every group with no `color` of its own. Any CSS colour. @default 'var(--wr-color-primary)' */
+  readonly color: import("@angular/core").InputSignal<string>;
+  /**
+   * The plot's height in px, at least 80. Under 160 the value axis aims for fewer ticks,
+   * so their labels keep clear of one another. @default 240
+   */
+  readonly height: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  /** Show the gridlines and the value axis' tick labels. @default true */
+  readonly showGrid: import("@angular/core").InputSignalWithTransform<boolean, any>;
+  /**
+   * Show a tooltip with the hovered group's five numbers — the whiskers' ends, the
+   * quartiles and the median — and its outliers' values, the lowest three, then how many
+   * more there are. Pointer only. @default true
+   */
+  readonly tooltip: import("@angular/core").InputSignalWithTransform<boolean, any>;
+  /**
+   * Render every group's numbers as a table only assistive technology reaches, beside the
+   * drawing: a row per group, a column for each of the five numbers from the lower
+   * whisker up and, when a group has any, one listing its outliers. The drawing is one
+   * named image, so without it the numbers are nowhere a screen reader can walk.
+   * @default false
+   */
+  readonly dataTable: import("@angular/core").InputSignalWithTransform<boolean, any>;
+  private readonly groupEls;
+  /** Every group with its colour and its summary, in order. */
+  private readonly resolvedGroups;
+  /**
+   * The value axis, from `chartAxis` over every number drawn — whisker ends, quartiles,
+   * medians and outliers alike, so a summary given out of order still lands inside it —
+   * with no zero forced in and both ends kept off the data (`symmetric`). A single value
+   * is centred with a step either side; with nothing to draw, the 0 to 1 frame.
+   *
+   * It aims for four gaps, and for fewer on a short plot: a gap per 40px of `height`, so
+   * the tick labels, a line of text each, never stand on one another — at the 80px
+   * floor, four gaps put five labels in 64px of drawing.
+   */
+  protected readonly axis: import("@angular/core").Signal<import("ngwr/charts/core").WrChartAxis>;
+  /** The groups as drawn: an equal slot each across the drawing, and their marks placed on the axis. */
+  protected readonly drawnGroups: import("@angular/core").Signal<readonly DrawnGroup[]>;
+  /** The value axis' 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;
+  }[]>;
+  /**
+   * One tooltip for the group under the pointer: its name and colour as the heading, then
+   * the five numbers top to bottom, the way the box is drawn, and its outliers when it has
+   * any — their VALUES, as the data table's column of the same name lists them: the lowest
+   * three a row each under the one label, so a long figure never shares a line with
+   * another and pushes past the chip, then a row counting the rest. It points at the top
+   * of everything the group draws, so the chip covers none of its marks.
+   */
+  protected readonly tip: import("ngwr/popover").WrChartTooltip;
+  /** The group the tooltip is reading, washed in the drawing. Never one with nothing drawn. */
+  protected readonly activeGroup: import("@angular/core").Signal<number | null>;
+  /**
+   * The figures for `dataTable`: the chart's name as the caption, a row per group headed
+   * by its name, and its five numbers ascending, as a five-number summary reads, written
+   * as the tooltip writes them. The outliers column appears once any group has an
+   * outlier, and lists that group's ascending. A group with nothing to draw has a row of
+   * empty cells.
+   */
+  protected readonly tableData: import("@angular/core").Signal<WrChartTableData>;
+  constructor();
+  /**
+   * The pointer entered a group's slot. A group with nothing drawn reads as leaving, so a
+   * chip open on its neighbour closes after the usual grace rather than at once.
+   */
+  protected onEnter(index: number, event: MouseEvent): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<WrBoxplotChart, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<WrBoxplotChart, "wr-boxplot-chart", never, {
+    "groups": {
+      "alias": "groups";
+      "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;
+    };
+    "valueFormat": {
+      "alias": "valueFormat";
+      "required": false;
+      "isSignal": true;
+    };
+    "color": {
+      "alias": "color";
+      "required": false;
+      "isSignal": true;
+    };
+    "height": {
+      "alias": "height";
+      "required": false;
+      "isSignal": true;
+    };
+    "showGrid": {
+      "alias": "showGrid";
+      "required": false;
+      "isSignal": true;
+    };
+    "tooltip": {
+      "alias": "tooltip";
+      "required": false;
+      "isSignal": true;
+    };
+    "dataTable": {
+      "alias": "dataTable";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+export type { WrBoxplotGroup, WrBoxplotStats };

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

@@ -0,0 +1,99 @@
+import { BaseHarnessFilters, ComponentHarness, HarnessPredicate } from "@angular/cdk/testing";
+/** Narrows which `<wr-bullet-chart>` a harness query matches. */
+interface WrBulletChartHarnessFilters extends BaseHarnessFilters {
+  /** Match the drawing's accessible name — the sentence, or `ariaLabel`. */
+  readonly ariaLabel?: string | RegExp;
+  /** Match the label shown beside the drawing. */
+  readonly label?: string | RegExp;
+}
+/**
+ * Where a part of the drawing lies along the scale, as {@link WrBulletChartHarness} reads
+ * it: shares of the scale from 0 at its start to 1 at its end, as the component wrote them.
+ */
+interface WrBulletChartExtent {
+  /** Where it starts. The value's bar starts at zero, or at the value for a negative one. */
+  readonly start: number;
+  /** Where it ends. */
+  readonly end: number;
+}
+/**
+ * Test harness for `<wr-bullet-chart>`.
+ *
+ * **Two questions, two methods.** What a screen reader hears is the drawing's name — the
+ * sentence "Revenue: 270 of target 250", or `ariaLabel` — and its description, the
+ * sub-label it names through `aria-describedby` ({@link getAccessibleName},
+ * {@link getDescription}). What a reader sees is the label column beside it, which is
+ * `aria-hidden` ({@link getLabel}, {@link getSubLabel}). A chart whose description points
+ * at nothing still SHOWS its sub-label, so the two are asked separately.
+ *
+ * **Where the marks lie is read as the component WROTE it**: shares of the scale from 0
+ * at its start to 1 at its end, off each mark's `style` attribute, never measured. jsdom
+ * lays nothing out, so a measured box would be 0×0 for a working chart and a broken one
+ * alike — but the share written is exactly what decides where the browser draws it, and
+ * it is what breaks when the scale does: a `max` read wrongly moves every share.
+ *
+ * **No colour is read.** The bands, the bar and the marker are painted by the stylesheet
+ * through the chart's `--wr-bullet-chart-*` hooks, and jsdom resolves no stylesheet, so a
+ * colour method would answer the same nothing whatever the theme said. Nor is there a
+ * method for the tooltip: it is pointer only, and it says what the accessible name says.
+ *
+ * @example
+ * ```ts
+ * const chart = await loader.getHarness(WrBulletChartHarness.with({ label: 'Revenue' }));
+ *
+ * expect(await chart.getAccessibleName()).toBe('Revenue: 270 of target 250');
+ * expect(await chart.getValueExtent()).toEqual({ start: 0, end: 0.9 });
+ * expect(await chart.getRanges()).toHaveLength(3);
+ * ```
+ *
+ * @see https://ngwr.dev/guides/testing
+ */
+export declare class WrBulletChartHarness extends ComponentHarness {
+  static hostSelector: string;
+  /** Build a predicate that narrows the query — pass to `getHarness` / `getAllHarnesses`. */
+  static with(options?: WrBulletChartHarnessFilters): HarnessPredicate<WrBulletChartHarness>;
+  private readonly drawing;
+  /** The drawing's accessible name: the sentence the chart writes, or `ariaLabel`. */
+  getAccessibleName(): Promise<string | null>;
+  /**
+   * The text a screen reader hears after the name — the sub-label, which the drawing names
+   * through `aria-describedby` — or `null` when it names nothing.
+   *
+   * Throws when it names an id nothing in the chart carries, rather than answering `null`:
+   * a description pointing at nothing is exactly the defect that leaves the sub-label on
+   * screen and silent.
+   */
+  getDescription(): Promise<string | null>;
+  /** The label shown beside the drawing, whole even where it is ellipsised, or `null` when there is none. */
+  getLabel(): Promise<string | null>;
+  /** The sub-label shown under the label, or `null` when there is none. */
+  getSubLabel(): Promise<string | null>;
+  /**
+   * Where the value's bar lies along the scale, or `null` when no bar is drawn — the value
+   * is not a finite number. It starts at zero, or at the value for a negative one; a value
+   * past a fixed `max` ends at 1, and a value of zero is a bar from zero to zero.
+   */
+  getValueExtent(): Promise<WrBulletChartExtent | null>;
+  /** Where the target marker sits along the scale, from 0 to 1, or `null` when there is no target. */
+  getTargetPosition(): Promise<number | null>;
+  /**
+   * Every qualitative band drawn, from the scale's start: where each lies along the scale.
+   * A band the scale leaves no room for is not drawn, so this can be shorter than `ranges`:
+   * one past a fixed `max`, and the first band when its limit is where the scale starts — a
+   * negative first limit lower than both the value and the target.
+   */
+  getRanges(): Promise<WrBulletChartExtent[]>;
+  /** Whether the scale's ticks are drawn under the drawing (`showScale`). */
+  hasScale(): Promise<boolean>;
+  /** The scale's tick labels from its start, as printed. `[]` with `showScale` off. */
+  getScaleLabels(): Promise<string[]>;
+  private extentOf;
+  /**
+   * A share the component wrote on a mark, off its `style` ATTRIBUTE — not `getCssValue()`,
+   * which would answer from the cascade, and a computed read of a custom property the
+   * stylesheet reads with a fallback answers plausibly at exactly the moment the binding
+   * that writes it is what broke.
+   */
+  private read;
+}
+export type { WrBulletChartExtent, WrBulletChartHarnessFilters };