@pioneer-code/pioneer-charts 22.2.28 → 22.2.30

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -1,47 +1,45 @@
1
- import * as _pioneer_code_pioneer_charts from '@pioneer-code/pioneer-charts';
2
- import * as _angular_core from '@angular/core';
3
- import { TemplateRef } from '@angular/core';
4
-
1
+ import * as i0 from "@angular/core";
2
+ import { TemplateRef } from "@angular/core";
5
3
  /**
6
4
  * Base configuration for all charts.
7
5
  * INewChart extends IChart
8
6
  */
9
- declare class PcacChartConfig {
10
- data: PcacData[];
11
- /**
12
- * Height in pixels
13
- */
14
- height: number;
15
- /**
16
- * When true, `height` becomes a *minimum* height: if the container the chart is placed in is
17
- * taller than `height`, the chart grows to fill it instead.
18
- *
19
- * The chart fills its own host element (`<pcac-bar-vertical-chart>` etc.), which it stretches
20
- * to `height: 100%` while this is on - so the consumer just needs to give the element wrapping
21
- * the chart a definite height (an explicit height, or a flex/grid track that resolves to one).
22
- * If that wrapper turns out to be auto-height, there's nothing definite to fill and the chart
23
- * falls back to `height`.
24
- *
25
- * Optional (rather than defaulted like the properties above) so that adding it doesn't force
26
- * every existing consumer that builds a config as an object literal to declare it; the `= false`
27
- * initializer still applies to anything constructed via `new`.
28
- */
29
- heightFull?: boolean;
30
- /**
31
- * What the chart shows, for screen readers - e.g. `'Sales by month, 2026'`. The chart's `<svg>` is
32
- * announced as one image with this name; when it isn't set, the chart's type is used (`'Bar
33
- * chart'`, `'Pie chart'`, ...). Optional for the same reason as `heightFull`.
34
- */
35
- ariaLabel?: string;
7
+ export declare class PcacChartConfig {
8
+ data: PcacData[];
9
+ /**
10
+ * Height in pixels
11
+ */
12
+ height: number;
13
+ /**
14
+ * When true, `height` becomes a *minimum* height: if the container the chart is placed in is
15
+ * taller than `height`, the chart grows to fill it instead.
16
+ *
17
+ * The chart fills its own host element (`<pcac-bar-vertical-chart>` etc.), which it stretches
18
+ * to `height: 100%` while this is on - so the consumer just needs to give the element wrapping
19
+ * the chart a definite height (an explicit height, or a flex/grid track that resolves to one).
20
+ * If that wrapper turns out to be auto-height, there's nothing definite to fill and the chart
21
+ * falls back to `height`.
22
+ *
23
+ * Optional (rather than defaulted like the properties above) so that adding it doesn't force
24
+ * every existing consumer that builds a config as an object literal to declare it; the `= false`
25
+ * initializer still applies to anything constructed via `new`.
26
+ */
27
+ heightFull?: boolean;
28
+ /**
29
+ * What the chart shows, for screen readers - e.g. `'Sales by month, 2026'`. The chart's `<svg>` is
30
+ * announced as one image with this name; when it isn't set, the chart's type is used (`'Bar
31
+ * chart'`, `'Pie chart'`, ...). Optional for the same reason as `heightFull`.
32
+ */
33
+ ariaLabel?: string;
36
34
  }
37
35
  /**
38
36
  * Up to three short labels placed along an axis by position rather than by value: `min` at its
39
37
  * start, `mid` at its center, `max` at its end. Any subset can be given.
40
38
  */
41
- declare class PcacAxisSubLabels {
42
- min?: string;
43
- mid?: string;
44
- max?: string;
39
+ export declare class PcacAxisSubLabels {
40
+ min?: string;
41
+ mid?: string;
42
+ max?: string;
45
43
  }
46
44
  /**
47
45
  * Everything configurable about one axis. Used twice per chart, as `xAxis` and `yAxis` on
@@ -56,190 +54,200 @@ declare class PcacAxisSubLabels {
56
54
  * is applied to the axis as the CSS custom property named on the field, so a stylesheet can set
57
55
  * the same property on any ancestor instead; a config value wins.
58
56
  */
59
- declare class PcacAxisConfig {
60
- /**
61
- * Don't draw this axis at all (labels, tick marks, line), and give the margins it would have
62
- * occupied back to the plot area. Hiding the y axis reclaims the left and top margins; hiding
63
- * the x axis reclaims the bottom and right. The chart's total footprint doesn't change.
64
- */
65
- hide?: boolean;
66
- /**
67
- * Draw grid lines from this axis's ticks (or, on a category axis, from each category) across
68
- * the plot: horizontal lines for the y axis, vertical for the x. Left unset, each chart keeps
69
- * the grid it has always drawn - the y axis's on vertical bar and line/area/plot charts, the
70
- * x axis's on the horizontal bar chart - and no other; set it to turn either grid on or off
71
- * explicitly. Deliberately has no initializer, since "unset" is what carries the per-chart
72
- * default.
73
- */
74
- showGrid?: boolean;
75
- /**
76
- * Grid line color (`--pcac-grid-color`), shown while this axis's grid is drawn - see `showGrid`.
77
- * Theme default `$gray-200`.
78
- */
79
- gridColor?: string;
80
- /**
81
- * Requested number of ticks (D3's `ticks()` hint, so the actual count can differ slightly) -
82
- * also the number of grid lines for this axis. Ignored by a category (band) axis, which has one
83
- * tick per category. Default 5.
84
- */
85
- ticks?: number;
86
- /**
87
- * Length in pixels of the small tick marks. Tick marks are not drawn at all unless this is set
88
- * (the theme hides them, as it always has), so setting a size is also what turns them on; D3's
89
- * default 6px is a sensible first value. `0` keeps them off but still pulls the labels in to
90
- * the axis. Labels follow the marks (D3 places them at tick length + 3px), and the chart's
91
- * margins grow or shrink by the same amount so the plot area makes room for them - a longer
92
- * tick means a slightly smaller plot, never labels pushed off the edge. Only the per-tick marks
93
- * change; the axis line's two end-caps keep their default length. Colored by `tickColor`, the
94
- * theme's `$gray-900` (like the axis line) by default. Ignored while `autoTickSize` is on.
95
- */
96
- tickSize?: number;
97
- /**
98
- * Size the tick marks from the chart's points instead of `tickSize`: half the largest mark
99
- * toward this axis, so a point sitting on the axis ends where its tick does and never covers a
100
- * tick label (D3's 3px tick padding is the gap left between them). This **overrides**
101
- * `tickSize` - with it on, any `tickSize` given is ignored - and turns the marks on the same
102
- * way a `tickSize` does. The largest mark is measured as drawn: a hovered dot, an image's box
103
- * (its height for the x axis, its width for the y axis), and a gauge ring around either,
104
- * after any shrinking to fit (dot plot). Honored by the charts that draw points - line, area,
105
- * plot and dot plot; ignored elsewhere. On the dot plot the marks never reach the axis (its
106
- * bottom row sits a `gap` above it), so there it only spaces the labels to the marks' size.
107
- * Default false.
108
- */
109
- autoTickSize?: boolean;
110
- /**
111
- * Tick mark color (`--pcac-axis-tick-color`), shown once `tickSize` has turned the marks on.
112
- * Theme default `$gray-900`.
113
- */
114
- tickColor?: string;
115
- /**
116
- * Tick label color (`--pcac-axis-tick-label-color`) - the values along the axis. Default is the
117
- * page's text color (`currentColor`), as d3-axis has always drawn them.
118
- */
119
- tickLabelColor?: string;
120
- /**
121
- * Draw a solid line along the axis itself (the full length of the axis, with D3's short
122
- * end-caps). Off by default, as the theme has always hidden it. Colored by `lineColor`, the
123
- * theme's `$gray-900` by default.
124
- */
125
- showLine?: boolean;
126
- /**
127
- * Axis line color (`--pcac-axis-line-color`), shown with `showLine` on. Theme default `$gray-900`.
128
- */
129
- lineColor?: string;
130
- /**
131
- * A title for the whole axis (e.g. "Revenue ($)"), drawn centered along it just inside the
132
- * chart's edge: below the tick labels for the x axis, rotated to read bottom-to-top left of
133
- * them for the y axis. The chart's margin grows by `PcacChart.AXIS_LABEL_SPACE` to make room,
134
- * shrinking the plot area the same way a longer tick does. Not drawn on a hidden axis. Styled
135
- * by the theme's `.pcac-axis-label` rule.
136
- */
137
- label?: string;
138
- /** `label` color (`--pcac-axis-label-color`). Theme default `$gray-700`. */
139
- labelColor?: string;
140
- /**
141
- * Min / mid / max sub labels (e.g. "Low" / "Medium" / "High") in their own row just outside the
142
- * tick labels, and inside the `label` if there is one: `min` left-aligned at the axis's start,
143
- * `mid` centered, `max` right-aligned at its end, so they never spill past the axis. On the
144
- * y axis they run bottom-to-top like the label, `min` at the bottom. The margin grows by
145
- * `PcacChart.AXIS_SUB_LABEL_SPACE` when any is set, shrinking the plot area. Not drawn on a
146
- * hidden axis. Styled by the theme's `.pcac-axis-sub-label` rule.
147
- *
148
- * On a zoomable line/area/plot axis each stands for the value at its spot on the unzoomed axis
149
- * and moves with it. Zoomed out of view, the nearest on each side is pinned to that end with an
150
- * arrow toward its value (`.pcac-axis-sub-label-out-of-view`, dimmed by the theme).
151
- */
152
- subLabels?: PcacAxisSubLabels;
153
- /** `subLabels` color, all three (`--pcac-axis-sub-label-color`). Theme default `$gray-600`. */
154
- subLabelColor?: string;
155
- /**
156
- * How the values along this axis are interpreted and shown - the tick labels, and the value
157
- * (`yAxis`) or key (`xAxis`) in the default tooltip. On the line/area/plot charts the x axis's
158
- * format is also what decides how a point's `key` maps to an x position (by index for the
159
- * default, `Decimal` and `DateTime` by the key's own value on a linear/time scale - see
160
- * `PcacLineAreaChartConfig`); on a bar chart's category axis it only formats keys that are
161
- * numbers, and shows any other key as it is. Default `None`, which
162
- * on those charts behaves as `DatasetLength`.
163
- */
164
- format?: PcacFormatEnum;
165
- /**
166
- * The value axis's domain: it runs from `domainMin` to `domainMax`, ignoring the data. Defaults
167
- * 0 and 100. Only the type of axis that has a domain to set reads them - a bar chart's category
168
- * axis ignores both, its value axis reads `domainMax` only (bars always grow from 0), and a
169
- * line/area/plot chart's x axis reads them only under the `Decimal` (numbers) and `DateTime`
170
- * (anything `new Date()` accepts, and required) formats - the index-based formats size the
171
- * axis from the data.
172
- */
173
- domainMin?: number | string;
174
- domainMax?: number | string;
57
+ export declare class PcacAxisConfig {
58
+ /**
59
+ * Don't draw this axis at all (labels, tick marks, line), and give the margins it would have
60
+ * occupied back to the plot area. Hiding the y axis reclaims the left and top margins; hiding
61
+ * the x axis reclaims the bottom and right. The chart's total footprint doesn't change.
62
+ */
63
+ hide?: boolean;
64
+ /**
65
+ * Draw grid lines from this axis's ticks (or, on a category axis, from each category) across
66
+ * the plot: horizontal lines for the y axis, vertical for the x. Left unset, each chart keeps
67
+ * the grid it has always drawn - the y axis's on vertical bar and line/area/plot charts, the
68
+ * x axis's on the horizontal bar chart - and no other; set it to turn either grid on or off
69
+ * explicitly. Deliberately has no initializer, since "unset" is what carries the per-chart
70
+ * default.
71
+ */
72
+ showGrid?: boolean;
73
+ /**
74
+ * Grid line color (`--pcac-grid-color`), shown while this axis's grid is drawn - see `showGrid`.
75
+ * Theme default `$gray-200`.
76
+ */
77
+ gridColor?: string;
78
+ /**
79
+ * Requested number of ticks (D3's `ticks()` hint, so the actual count can differ slightly) -
80
+ * also the number of grid lines for this axis. Ignored by a category (band) axis, which has one
81
+ * tick per category. Default 5.
82
+ */
83
+ ticks?: number;
84
+ /**
85
+ * Length in pixels of the small tick marks. Tick marks are not drawn at all unless this is set
86
+ * (the theme hides them, as it always has), so setting a size is also what turns them on; D3's
87
+ * default 6px is a sensible first value. `0` keeps them off but still pulls the labels in to
88
+ * the axis. Labels follow the marks (D3 places them at tick length + 3px), and the chart's
89
+ * margins grow or shrink by the same amount so the plot area makes room for them - a longer
90
+ * tick means a slightly smaller plot, never labels pushed off the edge. Only the per-tick marks
91
+ * change; the axis line's two end-caps keep their default length. Colored by `tickColor`, the
92
+ * theme's `$gray-900` (like the axis line) by default. Ignored while `autoTickSize` is on.
93
+ */
94
+ tickSize?: number;
95
+ /**
96
+ * Size the tick marks from the chart's points instead of `tickSize`: half the largest mark
97
+ * toward this axis, so a point sitting on the axis ends where its tick does and never covers a
98
+ * tick label (D3's 3px tick padding is the gap left between them). This **overrides**
99
+ * `tickSize` - with it on, any `tickSize` given is ignored - and turns the marks on the same
100
+ * way a `tickSize` does. The largest mark is measured as drawn: a hovered dot, an image's box
101
+ * (its height for the x axis, its width for the y axis), and a gauge ring around either,
102
+ * after any shrinking to fit (dot plot). Honored by the charts that draw points - line, area,
103
+ * plot and dot plot; ignored elsewhere. On the dot plot the marks never reach the axis (its
104
+ * bottom row sits a `gap` above it), so there it only spaces the labels to the marks' size.
105
+ * Default false.
106
+ */
107
+ autoTickSize?: boolean;
108
+ /**
109
+ * Tick mark color (`--pcac-axis-tick-color`), shown once `tickSize` has turned the marks on.
110
+ * Theme default `$gray-900`.
111
+ */
112
+ tickColor?: string;
113
+ /**
114
+ * Tick label color (`--pcac-axis-tick-label-color`) - the values along the axis. Default is the
115
+ * page's text color (`currentColor`), as d3-axis has always drawn them.
116
+ */
117
+ tickLabelColor?: string;
118
+ /**
119
+ * Draw a solid line along the axis itself (the full length of the axis, with D3's short
120
+ * end-caps). Off by default, as the theme has always hidden it. Colored by `lineColor`, the
121
+ * theme's `$gray-900` by default.
122
+ */
123
+ showLine?: boolean;
124
+ /**
125
+ * Axis line color (`--pcac-axis-line-color`), shown with `showLine` on. Theme default `$gray-900`.
126
+ */
127
+ lineColor?: string;
128
+ /**
129
+ * A title for the whole axis (e.g. "Revenue ($)"), drawn centered along it just inside the
130
+ * chart's edge: below the tick labels for the x axis, rotated to read bottom-to-top left of
131
+ * them for the y axis. The chart's margin grows by `PcacChart.AXIS_LABEL_SPACE` to make room,
132
+ * shrinking the plot area the same way a longer tick does. Not drawn on a hidden axis. Styled
133
+ * by the theme's `.pcac-axis-label` rule.
134
+ */
135
+ label?: string;
136
+ /** `label` color (`--pcac-axis-label-color`). Theme default `$gray-700`. */
137
+ labelColor?: string;
138
+ /**
139
+ * Min / mid / max sub labels (e.g. "Low" / "Medium" / "High") in their own row just outside the
140
+ * tick labels, and inside the `label` if there is one: `min` left-aligned at the axis's start,
141
+ * `mid` centered, `max` right-aligned at its end, so they never spill past the axis. On the
142
+ * y axis they run bottom-to-top like the label, `min` at the bottom. The margin grows by
143
+ * `PcacChart.AXIS_SUB_LABEL_SPACE` when any is set, shrinking the plot area. Not drawn on a
144
+ * hidden axis. Styled by the theme's `.pcac-axis-sub-label` rule.
145
+ *
146
+ * On a zoomable line/area/plot axis each stands for the value at its spot on the unzoomed axis
147
+ * and moves with it. Zoomed out of view, the nearest on each side is pinned to that end with an
148
+ * arrow toward its value (`.pcac-axis-sub-label-out-of-view`, dimmed by the theme).
149
+ */
150
+ subLabels?: PcacAxisSubLabels;
151
+ /** `subLabels` color, all three (`--pcac-axis-sub-label-color`). Theme default `$gray-600`. */
152
+ subLabelColor?: string;
153
+ /**
154
+ * How the values along this axis are interpreted and shown - the tick labels, and the value
155
+ * (`yAxis`) or key (`xAxis`) in the default tooltip. On the line/area/plot charts the x axis's
156
+ * format is also what decides how a point's `key` maps to an x position (by index for the
157
+ * default, `Decimal` and `DateTime` by the key's own value on a linear/time scale - see
158
+ * `PcacLineAreaChartConfig`); on a bar chart's category axis it only formats keys that are
159
+ * numbers, and shows any other key as it is. Default `None`, which
160
+ * on those charts behaves as `DatasetLength`.
161
+ */
162
+ format?: PcacFormatEnum;
163
+ /**
164
+ * The value axis's domain: it runs from `domainMin` to `domainMax`, ignoring the data. Defaults
165
+ * 0 and 100. Only the type of axis that has a domain to set reads them - a bar chart's category
166
+ * axis ignores both, its value axis reads `domainMax` only (bars always grow from 0), and a
167
+ * line/area/plot chart's x axis reads them only under the `Decimal` (numbers) and `DateTime`
168
+ * (anything `new Date()` accepts, and required) formats - the index-based formats size the
169
+ * axis from the data.
170
+ */
171
+ domainMin?: number | string;
172
+ domainMax?: number | string;
175
173
  }
176
174
  /**
177
175
  * Base configuration for every chart that has an x and y axis (bar, line, area, plot - not pie).
178
176
  */
179
- declare class PcacAxisChartConfig extends PcacChartConfig {
180
- xAxis?: PcacAxisConfig;
181
- yAxis?: PcacAxisConfig;
177
+ export declare class PcacAxisChartConfig extends PcacChartConfig {
178
+ xAxis?: PcacAxisConfig;
179
+ yAxis?: PcacAxisConfig;
182
180
  }
183
- declare class PcacData {
184
- key: string | number | null;
185
- value: string | number | null;
186
- /**
187
- * Hides the item while keeping its place in the color order, so a `<pcac-legend>` can toggle it
188
- * without the other items changing color. A line/area/plot series draws no line, area, points or
189
- * hover effects; a bar (or every bar of a group) is drawn at zero size, keeping its slot; a pie
190
- * slice takes no angle.
191
- */
192
- hide: boolean;
193
- data: PcacData[];
194
- /**
195
- * URL (or data URI) of an image to draw at this point *in place of* its dot. Currently honored
196
- * by the line/area/plot charts only, on the innermost (point-level) `PcacData`; sized by the
197
- * chart config's `pointImage` (see `PcacLineAreaChartConfig.pointImage`). Points without one
198
- * keep their regular dot, so the two can be mixed within a single series.
199
- *
200
- * Optional (rather than defaulted) for the same reason as `PcacChartConfig.heightFull`: so
201
- * existing object-literal / JSON data doesn't have to declare it.
202
- */
203
- image?: string;
204
- /**
205
- * The span this point's `key` / `value` stands for, when the point is really the middle of a
206
- * range: `x` for the key, `y` for the value, either or both. Currently honored by the
207
- * line/area/plot charts only, on the innermost (point-level) `PcacData`, and only drawn when
208
- * the chart config turns `pointRange` on (see `PcacPointRangeConfig`). Nothing is labeled on
209
- * the chart; a custom tooltip can read it off the point.
210
- *
211
- * Optional for the same reason as `image`.
212
- */
213
- range?: PcacDataRange;
214
- /**
215
- * A third number for this point, shown as how full a ring around its mark is - on a scatter of
216
- * two measures, say, a third one per point. Out of the chart config's `pointGauge.max`: at `max`
217
- * or above the ring is full, at `0` or below it's empty. Currently honored by the line/area/plot
218
- * charts only, on the innermost (point-level) `PcacData`, and only drawn when the chart config
219
- * turns `pointGauge` on (see `PcacPointGaugeConfig`). A point without one gets no ring at all,
220
- * which can itself say something ("doesn't apply").
221
- *
222
- * Optional for the same reason as `image`.
223
- */
224
- gauge?: number;
225
- /**
226
- * The consumer's own identifier for this item - a record's primary key, say. Nothing draws or
227
- * labels it; it's carried through untouched so a click output (`dotClicked`, `barClicked`,
228
- * `sliceClicked`, `itemClicked`) can be traced back to the record it came from. Click outputs
229
- * emit a copy of the item (the chart works on a copy of its config), so matching by object
230
- * identity doesn't work, and matching by `key` or `image` breaks as soon as two items share one.
231
- *
232
- * Optional for the same reason as `image`.
233
- */
234
- id?: string | number;
181
+ export declare class PcacData {
182
+ key: string | number | null;
183
+ value: string | number | null;
184
+ /**
185
+ * Hides the item while keeping its place in the color order, so a `<pcac-legend>` can toggle it
186
+ * without the other items changing color. A line/area/plot series draws no line, area, points or
187
+ * hover effects; a bar (or every bar of a group) is drawn at zero size, keeping its slot; a pie
188
+ * slice takes no angle.
189
+ */
190
+ hide: boolean;
191
+ data: PcacData[];
192
+ /**
193
+ * URL (or data URI) of an image to draw at this point *in place of* its dot. Currently honored
194
+ * by the line/area/plot charts only, on the innermost (point-level) `PcacData`; sized by the
195
+ * chart config's `pointImage` (see `PcacLineAreaChartConfig.pointImage`). Points without one
196
+ * keep their regular dot, so the two can be mixed within a single series.
197
+ *
198
+ * Optional (rather than defaulted) for the same reason as `PcacChartConfig.heightFull`: so
199
+ * existing object-literal / JSON data doesn't have to declare it.
200
+ */
201
+ image?: string;
202
+ /**
203
+ * The span this point's `key` / `value` stands for, when the point is really the middle of a
204
+ * range: `x` for the key, `y` for the value, either or both. Currently honored by the
205
+ * line/area/plot charts only, on the innermost (point-level) `PcacData`, and only drawn when
206
+ * the chart config turns `pointRange` on (see `PcacPointRangeConfig`). Nothing is labeled on
207
+ * the chart; a custom tooltip can read it off the point.
208
+ *
209
+ * Optional for the same reason as `image`.
210
+ */
211
+ range?: PcacDataRange;
212
+ /**
213
+ * A third number for this point, shown as how full a ring around its mark is - on a scatter of
214
+ * two measures, say, a third one per point. Out of the chart config's `pointGauge.max`: at `max`
215
+ * or above the ring is full, at `0` or below it's empty. Currently honored by the line/area/plot
216
+ * charts only, on the innermost (point-level) `PcacData`, and only drawn when the chart config
217
+ * turns `pointGauge` on (see `PcacPointGaugeConfig`). A point without one gets no ring at all,
218
+ * which can itself say something ("doesn't apply").
219
+ *
220
+ * Optional for the same reason as `image`.
221
+ */
222
+ gauge?: number;
223
+ /**
224
+ * A color for this point's dot, any CSS color, in place of its series' - to flag a reading, say
225
+ * one below a threshold, among the rest. Its ring at rest, and its fill while hovered or
226
+ * focused; the line or area through it, and the crosshair, keep the series' color. Currently
227
+ * honored by the line/area/plot charts only, on the innermost (point-level) `PcacData`. Say why
228
+ * in words too (a tooltip, a label), for a reader who can't tell the colors apart.
229
+ *
230
+ * Optional for the same reason as `image`.
231
+ */
232
+ color?: string;
233
+ /**
234
+ * The consumer's own identifier for this item - a record's primary key, say. Nothing draws or
235
+ * labels it; it's carried through untouched so a click output (`dotClicked`, `barClicked`,
236
+ * `sliceClicked`, `itemClicked`) can be traced back to the record it came from. Click outputs
237
+ * emit a copy of the item (the chart works on a copy of its config), so matching by object
238
+ * identity doesn't work, and matching by `key` or `image` breaks as soon as two items share one.
239
+ *
240
+ * Optional for the same reason as `image`.
241
+ */
242
+ id?: string | number;
235
243
  }
236
244
  /**
237
245
  * One side of a `PcacDataRange`. `min` above `max` is read as the other way round; `min` equal to
238
246
  * `max` (or either missing) as no range on that axis.
239
247
  */
240
- declare class PcacRangeBounds<T> {
241
- min: T;
242
- max: T;
248
+ export declare class PcacRangeBounds<T> {
249
+ min: T;
250
+ max: T;
243
251
  }
244
252
  /**
245
253
  * `PcacData.range`. `x` is read the way the point's `key` is, per the chart's `xAxis.format`: a
@@ -247,93 +255,132 @@ declare class PcacRangeBounds<T> {
247
255
  * format a (possibly fractional) index - `{ min: 2.5, max: 3.5 }` is half a slot either side of
248
256
  * the fourth point. `y` is on the value axis.
249
257
  */
250
- declare class PcacDataRange {
251
- x?: PcacRangeBounds<number | string>;
252
- y?: PcacRangeBounds<number>;
258
+ export declare class PcacDataRange {
259
+ x?: PcacRangeBounds<number | string>;
260
+ y?: PcacRangeBounds<number>;
253
261
  }
254
- declare enum PcacFormatEnum {
255
- None = "none",
256
- Decimal = "decimal",
257
- DatasetLength = "datasetLength",
258
- Percentage = "percentage",
259
- Minutes = "minutes",
260
- DateTime = "dateTime",
261
- Fahrenheit = "fahrenheit",
262
- /**
263
- * Hours of the day, 0-24, labelled on a 12 hour clock: 0 = 12am, 1 = 1am, 13 = 1pm, 24 = 12am.
264
- * A value between hours shows its minutes (2.5 = 2:30am).
265
- */
266
- OneDayHours = "oneDayHours"
262
+ export declare enum PcacFormatEnum {
263
+ None = "none",
264
+ Decimal = "decimal",
265
+ DatasetLength = "datasetLength",
266
+ Percentage = "percentage",
267
+ Minutes = "minutes",
268
+ DateTime = "dateTime",
269
+ Fahrenheit = "fahrenheit",
270
+ /**
271
+ * Hours of the day, 0-24, labelled on a 12 hour clock: 0 = 12am, 1 = 1am, 13 = 1pm, 24 = 12am.
272
+ * A value between hours shows its minutes (2.5 = 2:30am).
273
+ */
274
+ OneDayHours = "oneDayHours"
267
275
  }
268
-
269
- declare class PcacBarHorizontalChartConfig extends PcacAxisChartConfig {
270
- isStacked: boolean;
271
- thresholds: PcacData[];
272
- spreadColorsPerGroup: boolean;
273
- /**
274
- * Bar colors, any CSS color, in place of the theme palette - by series, or by group with
275
- * `spreadColorsPerGroup`. Repeated when there are more series (or groups) than colors. Omitted
276
- * or empty, the theme palette is used - optional, as on every chart's config.
277
- */
278
- colorOverride?: string[];
276
+ export declare class PcacColorService {
277
+ private primaryLight;
278
+ private success;
279
+ private danger;
280
+ private warning;
281
+ private orange;
282
+ private blue;
283
+ private alert;
284
+ /**
285
+ * Bumped by every setter, and read by the getters, so anything reading colors inside a reactive
286
+ * context tracks palette changes: the legend's `colorScale` computed recomputes, and every chart
287
+ * (whose build runs in an `effect`) redraws - together, rather than the legend keeping the old
288
+ * swatches while newly built charts took the new palette.
289
+ */
290
+ private readonly version;
291
+ /**
292
+ * Bumps `version` from a setter. `untracked`, because Angular forbids writing a signal inside a
293
+ * `computed` - and a consumer deriving its theme reactively (`computed(() => { setScale(...);
294
+ * ... })`) called these setters there without error before they were reactive.
295
+ */
296
+ private changed;
297
+ /** A consumer's own scale from `setScale()`; replaces the default palette while set. */
298
+ private customScale;
299
+ /**
300
+ * The palette charts cycle through: the `setScale()` one when given, else the default colors
301
+ * built from the current fields - so a setter like `setSuccess()` changes the charts drawn after
302
+ * it, rather than a copy of the colors taken when the service was created.
303
+ */
304
+ private get scale();
305
+ /**
306
+ * Get a scale of colors dynamically
307
+ * @param numberOfNodes Number of items in dynamically build collection of colors
308
+ */
309
+ getColorScale(numberOfNodes: number): string[];
310
+ getAlert(): string;
311
+ /**
312
+ * Set the scale that charts use to set colors of data[x] on the UI, in place of the default
313
+ * palette (and of the individual color setters below, which only shape the default). An empty
314
+ * array goes back to the default palette rather than leaving charts with no colors.
315
+ * @param colors A collection of hex values
316
+ */
317
+ setScale(colors: string[]): void;
318
+ setPrimaryLight(color: string): void;
319
+ setSuccess(color: string): void;
320
+ setDanger(color: string): void;
321
+ setWarning(color: string): void;
322
+ setOrange(color: string): void;
323
+ setBlue(color: string): void;
324
+ setAlert(color: string): void;
325
+ static ɵfac: i0.ɵɵFactoryDeclaration<PcacColorService, never>;
326
+ static ɵprov: i0.ɵɵInjectableDeclaration<any>;
279
327
  }
280
-
281
328
  /**
282
329
  * A datum drawn at the same coordinate as the hovered one (see `PcacTooltipContext.coincident`),
283
330
  * located the same way the context locates `$implicit`: `parent` is the series it belongs to,
284
331
  * `index` its position in `parent.data`, `parentIndex` the series' position in the chart's `data`.
285
332
  */
286
- interface PcacTooltipCoincident {
287
- data: PcacData;
288
- parent: PcacData;
289
- index: number;
290
- parentIndex: number;
333
+ export interface PcacTooltipCoincident {
334
+ data: PcacData;
335
+ parent: PcacData;
336
+ index: number;
337
+ parentIndex: number;
291
338
  }
292
339
  /**
293
340
  * Template context handed to a consumer's `<ng-template pcacTooltip>` each time a tooltip is shown.
294
341
  */
295
- interface PcacTooltipContext {
296
- /**
297
- * The hovered datum: a bar, a line/area/plot point, a pie slice, or a threshold. Bound with a
298
- * bare `let-point` (or any name) in the template.
299
- */
300
- $implicit: PcacData;
301
- /**
302
- * The `PcacData` the hovered datum sits inside - the group a bar belongs to, or the series a
303
- * point belongs to. For a threshold, the data group it's drawn against (a threshold's own
304
- * `PcacData` usually carries only a value, so this is where its label lives). `null` when there
305
- * is no enclosing level (pie slices, a chart-wide threshold).
306
- */
307
- parent: PcacData | null;
308
- /**
309
- * True when the hovered element is a threshold marker on a bar chart rather than a data point.
310
- * In that case `$implicit` is the threshold's own `PcacData`.
311
- */
312
- isThreshold: boolean;
313
- /**
314
- * Position of `$implicit` in the array it was taken from: `parent.data` when there is a parent
315
- * (a bar within its group, a point within its series), or the chart's top-level `data` when
316
- * there isn't (a pie slice). For a threshold it's the position in `config.thresholds`, or in
317
- * `config.thresholds[parentIndex].data` for a per-bar threshold.
318
- *
319
- * Together with `parentIndex` this lets a template reach back into whatever collection the
320
- * `PcacData` was built from, as long as that collection is parallel to `data` (same order, no
321
- * filtering): `items[parentIndex][index]` for a two-level chart, `items[index]` for a pie.
322
- * Charts never reorder `data`, so the correspondence is stable across builds and resizes.
323
- */
324
- index: number;
325
- /**
326
- * Position of `parent` in the chart's top-level `data`; `null` whenever `parent` is.
327
- */
328
- parentIndex: number | null;
329
- /**
330
- * Every *other* datum drawn at exactly the same coordinate as `$implicit`, in data order, so a
331
- * template can list who else is at the hovered point. Set by the line, area and plot charts,
332
- * whether or not the plot chart's `pointFanOut` has spread the points apart (without it, the
333
- * hovered point is the only one of them visible, which makes this list all the more useful).
334
- * Empty on the other charts and whenever nothing shares the point.
335
- */
336
- coincident: PcacTooltipCoincident[];
342
+ export interface PcacTooltipContext {
343
+ /**
344
+ * The hovered datum: a bar, a line/area/plot point, a pie slice, or a threshold. Bound with a
345
+ * bare `let-point` (or any name) in the template.
346
+ */
347
+ $implicit: PcacData;
348
+ /**
349
+ * The `PcacData` the hovered datum sits inside - the group a bar belongs to, or the series a
350
+ * point belongs to. For a threshold, the data group it's drawn against (a threshold's own
351
+ * `PcacData` usually carries only a value, so this is where its label lives). `null` when there
352
+ * is no enclosing level (pie slices, a chart-wide threshold).
353
+ */
354
+ parent: PcacData | null;
355
+ /**
356
+ * True when the hovered element is a threshold marker on a bar chart rather than a data point.
357
+ * In that case `$implicit` is the threshold's own `PcacData`.
358
+ */
359
+ isThreshold: boolean;
360
+ /**
361
+ * Position of `$implicit` in the array it was taken from: `parent.data` when there is a parent
362
+ * (a bar within its group, a point within its series), or the chart's top-level `data` when
363
+ * there isn't (a pie slice). For a threshold it's the position in `config.thresholds`, or in
364
+ * `config.thresholds[parentIndex].data` for a per-bar threshold.
365
+ *
366
+ * Together with `parentIndex` this lets a template reach back into whatever collection the
367
+ * `PcacData` was built from, as long as that collection is parallel to `data` (same order, no
368
+ * filtering): `items[parentIndex][index]` for a two-level chart, `items[index]` for a pie.
369
+ * Charts never reorder `data`, so the correspondence is stable across builds and resizes.
370
+ */
371
+ index: number;
372
+ /**
373
+ * Position of `parent` in the chart's top-level `data`; `null` whenever `parent` is.
374
+ */
375
+ parentIndex: number | null;
376
+ /**
377
+ * Every *other* datum drawn at exactly the same coordinate as `$implicit`, in data order, so a
378
+ * template can list who else is at the hovered point. Set by the line, area and plot charts,
379
+ * whether or not the plot chart's `pointFanOut` has spread the points apart (without it, the
380
+ * hovered point is the only one of them visible, which makes this list all the more useful).
381
+ * Empty on the other charts and whenever nothing shares the point.
382
+ */
383
+ coincident: PcacTooltipCoincident[];
337
384
  }
338
385
  /**
339
386
  * Marks an `<ng-template>` projected into any chart component as that chart's tooltip. When
@@ -371,148 +418,118 @@ interface PcacTooltipContext {
371
418
  * </ng-template>
372
419
  * ```
373
420
  */
374
- declare class PcacTooltipDirective {
375
- readonly templateRef: TemplateRef<PcacTooltipContext>;
376
- /**
377
- * Lets the template type-checker know the shape of `let-` variables declared on the
378
- * `<ng-template>`, so `point.value` etc. are checked against `PcacData` under strictTemplates.
379
- */
380
- static ngTemplateContextGuard(_dir: PcacTooltipDirective, _ctx: unknown): _ctx is PcacTooltipContext;
381
- static ɵfac: _angular_core.ɵɵFactoryDeclaration<PcacTooltipDirective, never>;
382
- static ɵdir: _angular_core.ɵɵDirectiveDeclaration<PcacTooltipDirective, "ng-template[pcacTooltip]", never, {}, {}, never, never, true, never>;
421
+ export declare class PcacTooltipDirective {
422
+ readonly templateRef: TemplateRef<PcacTooltipContext>;
423
+ /**
424
+ * Lets the template type-checker know the shape of `let-` variables declared on the
425
+ * `<ng-template>`, so `point.value` etc. are checked against `PcacData` under strictTemplates.
426
+ */
427
+ static ngTemplateContextGuard(_dir: PcacTooltipDirective, _ctx: unknown): _ctx is PcacTooltipContext;
428
+ static ɵfac: i0.ɵɵFactoryDeclaration<PcacTooltipDirective, never>;
429
+ static ɵdir: i0.ɵɵDirectiveDeclaration<PcacTooltipDirective, "ng-template[pcacTooltip]", never, {}, {}, never, never, true, never>;
383
430
  }
384
-
385
- declare class PcacBarHorizontalChart {
386
- private chartBuilder;
387
- readonly config: _angular_core.InputSignal<PcacBarHorizontalChartConfig>;
388
- private readonly chartElm;
389
- readonly barClicked: _angular_core.OutputRef<_pioneer_code_pioneer_charts.PcacData>;
390
- /**
391
- * Optional consumer `<ng-template pcacTooltip>` projected into this element; replaces the
392
- * default tooltip when present (see PcacTooltipDirective).
393
- */
394
- readonly tooltipTemplate: _angular_core.Signal<PcacTooltipDirective | undefined>;
395
- constructor();
396
- private buildChart;
397
- static ɵfac: _angular_core.ɵɵFactoryDeclaration<PcacBarHorizontalChart, never>;
398
- static ɵcmp: _angular_core.ɵɵComponentDeclaration<PcacBarHorizontalChart, "pcac-bar-horizontal-chart", never, { "config": { "alias": "config"; "required": true; "isSignal": true; }; }, { "barClicked": "barClicked"; }, ["tooltipTemplate"], never, true, never>;
431
+ export declare class PcacBarHorizontalChartConfig extends PcacAxisChartConfig {
432
+ isStacked: boolean;
433
+ thresholds: PcacData[];
434
+ spreadColorsPerGroup: boolean;
435
+ /**
436
+ * Bar colors, any CSS color, in place of the theme palette - by series, or by group with
437
+ * `spreadColorsPerGroup`. Repeated when there are more series (or groups) than colors. Omitted
438
+ * or empty, the theme palette is used - optional, as on every chart's config.
439
+ */
440
+ colorOverride?: string[];
399
441
  }
400
-
401
- declare class PcacBarVerticalChartConfig extends PcacAxisChartConfig {
402
- isStacked: boolean;
403
- thresholds: PcacData[];
404
- spreadColorsPerGroup: boolean;
405
- /**
406
- * Bar colors, any CSS color, in place of the theme palette - by series, or by group with
407
- * `spreadColorsPerGroup`. Repeated when there are more series (or groups) than colors. Omitted
408
- * or empty, the theme palette is used - optional, as on every chart's config.
409
- */
410
- colorOverride?: string[];
442
+ export declare class PcacBarHorizontalChart {
443
+ private chartBuilder;
444
+ readonly config: import("@angular/core").InputSignal<PcacBarHorizontalChartConfig>;
445
+ private readonly chartElm;
446
+ readonly barClicked: import("@angular/core").OutputRef<PcacData>;
447
+ /**
448
+ * Optional consumer `<ng-template pcacTooltip>` projected into this element; replaces the
449
+ * default tooltip when present (see PcacTooltipDirective).
450
+ */
451
+ readonly tooltipTemplate: import("@angular/core").Signal<PcacTooltipDirective | undefined>;
452
+ constructor();
453
+ private buildChart;
454
+ static ɵfac: i0.ɵɵFactoryDeclaration<PcacBarHorizontalChart, never>;
455
+ static ɵcmp: i0.ɵɵComponentDeclaration<PcacBarHorizontalChart, "pcac-bar-horizontal-chart", never, {
456
+ "config": {
457
+ "alias": "config";
458
+ "required": true;
459
+ "isSignal": true;
460
+ };
461
+ }, {
462
+ "barClicked": "barClicked";
463
+ }, ["tooltipTemplate"], never, true, never>;
411
464
  }
412
-
413
- declare class PcacBarVerticalChart {
414
- private chartBuilder;
415
- readonly config: _angular_core.InputSignal<PcacBarVerticalChartConfig>;
416
- private readonly chartElm;
417
- readonly barClicked: _angular_core.OutputRef<_pioneer_code_pioneer_charts.PcacData>;
418
- /**
419
- * Optional consumer `<ng-template pcacTooltip>` projected into this element; replaces the
420
- * default tooltip when present (see PcacTooltipDirective).
421
- */
422
- readonly tooltipTemplate: _angular_core.Signal<PcacTooltipDirective | undefined>;
423
- constructor();
424
- private buildChart;
425
- static ɵfac: _angular_core.ɵɵFactoryDeclaration<PcacBarVerticalChart, never>;
426
- static ɵcmp: _angular_core.ɵɵComponentDeclaration<PcacBarVerticalChart, "pcac-bar-vertical-chart", never, { "config": { "alias": "config"; "required": true; "isSignal": true; }; }, { "barClicked": "barClicked"; }, ["tooltipTemplate"], never, true, never>;
465
+ export declare class PcacBarVerticalChartConfig extends PcacAxisChartConfig {
466
+ isStacked: boolean;
467
+ thresholds: PcacData[];
468
+ spreadColorsPerGroup: boolean;
469
+ /**
470
+ * Bar colors, any CSS color, in place of the theme palette - by series, or by group with
471
+ * `spreadColorsPerGroup`. Repeated when there are more series (or groups) than colors. Omitted
472
+ * or empty, the theme palette is used - optional, as on every chart's config.
473
+ */
474
+ colorOverride?: string[];
427
475
  }
428
-
429
- declare class PcacColorService {
430
- private primaryLight;
431
- private success;
432
- private danger;
433
- private warning;
434
- private orange;
435
- private blue;
436
- private alert;
437
- /**
438
- * Bumped by every setter, and read by the getters, so anything reading colors inside a reactive
439
- * context tracks palette changes: the legend's `colorScale` computed recomputes, and every chart
440
- * (whose build runs in an `effect`) redraws - together, rather than the legend keeping the old
441
- * swatches while newly built charts took the new palette.
442
- */
443
- private readonly version;
444
- /**
445
- * Bumps `version` from a setter. `untracked`, because Angular forbids writing a signal inside a
446
- * `computed` - and a consumer deriving its theme reactively (`computed(() => { setScale(...);
447
- * ... })`) called these setters there without error before they were reactive.
448
- */
449
- private changed;
450
- /** A consumer's own scale from `setScale()`; replaces the default palette while set. */
451
- private customScale;
452
- /**
453
- * The palette charts cycle through: the `setScale()` one when given, else the default colors
454
- * built from the current fields - so a setter like `setSuccess()` changes the charts drawn after
455
- * it, rather than a copy of the colors taken when the service was created.
456
- */
457
- private get scale();
458
- /**
459
- * Get a scale of colors dynamically
460
- * @param numberOfNodes Number of items in dynamically build collection of colors
461
- */
462
- getColorScale(numberOfNodes: number): string[];
463
- getAlert(): string;
464
- /**
465
- * Set the scale that charts use to set colors of data[x] on the UI, in place of the default
466
- * palette (and of the individual color setters below, which only shape the default). An empty
467
- * array goes back to the default palette rather than leaving charts with no colors.
468
- * @param colors A collection of hex values
469
- */
470
- setScale(colors: string[]): void;
471
- setPrimaryLight(color: string): void;
472
- setSuccess(color: string): void;
473
- setDanger(color: string): void;
474
- setWarning(color: string): void;
475
- setOrange(color: string): void;
476
- setBlue(color: string): void;
477
- setAlert(color: string): void;
478
- static ɵfac: _angular_core.ɵɵFactoryDeclaration<PcacColorService, never>;
479
- static ɵprov: _angular_core.ɵɵInjectableDeclaration<any>;
476
+ export declare class PcacBarVerticalChart {
477
+ private chartBuilder;
478
+ readonly config: import("@angular/core").InputSignal<PcacBarVerticalChartConfig>;
479
+ private readonly chartElm;
480
+ readonly barClicked: import("@angular/core").OutputRef<PcacData>;
481
+ /**
482
+ * Optional consumer `<ng-template pcacTooltip>` projected into this element; replaces the
483
+ * default tooltip when present (see PcacTooltipDirective).
484
+ */
485
+ readonly tooltipTemplate: import("@angular/core").Signal<PcacTooltipDirective | undefined>;
486
+ constructor();
487
+ private buildChart;
488
+ static ɵfac: i0.ɵɵFactoryDeclaration<PcacBarVerticalChart, never>;
489
+ static ɵcmp: i0.ɵɵComponentDeclaration<PcacBarVerticalChart, "pcac-bar-vertical-chart", never, {
490
+ "config": {
491
+ "alias": "config";
492
+ "required": true;
493
+ "isSignal": true;
494
+ };
495
+ }, {
496
+ "barClicked": "barClicked";
497
+ }, ["tooltipTemplate"], never, true, never>;
480
498
  }
481
-
482
499
  declare enum PcacLineAreaPlotChartConfigType {
483
- Line = "line",
484
- Area = "area",
485
- Plot = "plot"
500
+ Line = "line",
501
+ Area = "area",
502
+ Plot = "plot"
486
503
  }
487
504
  /**
488
505
  * Sizing for the images drawn in place of a point's dot (see `PcacData.image`). An image is
489
506
  * scaled uniformly (up or down) to fit inside a `maxWidth` x `maxHeight` box, preserving its
490
507
  * aspect ratio, and is centered on the data point exactly where the dot would have been.
491
508
  */
492
- declare class PcacPointImageConfig {
493
- maxWidth: number;
494
- maxHeight: number;
509
+ export declare class PcacPointImageConfig {
510
+ maxWidth: number;
511
+ maxHeight: number;
495
512
  }
496
513
  /** How a point's `range` is drawn (see `PcacPointRangeConfig.style`). */
497
- declare enum PcacPointRangeStyle {
498
- /** Error bars: a line across each range, capped at both ends. */
499
- Whiskers = "whiskers",
500
- /** A rectangle spanning the x range by the y range; a thin strip when only one is set. */
501
- Box = "box",
502
- /**
503
- * A fill strongest at the point's value and fading out to the range's edges: an oval glow
504
- * with both ranges (brightest on the value, even off-center), a fading bar with one.
505
- */
506
- Fade = "fade"
514
+ export declare enum PcacPointRangeStyle {
515
+ /** Error bars: a line across each range, capped at both ends. */
516
+ Whiskers = "whiskers",
517
+ /** A rectangle spanning the x range by the y range; a thin strip when only one is set. */
518
+ Box = "box",
519
+ /**
520
+ * A fill strongest at the point's value and fading out to the range's edges: an oval glow
521
+ * with both ranges (brightest on the value, even off-center), a fading bar with one.
522
+ */
523
+ Fade = "fade"
507
524
  }
508
525
  /** When a point's `range` shows (see `PcacPointRangeConfig.show`). */
509
- declare enum PcacPointRangeShow {
510
- /** Only the hovered point's range. */
511
- Hover = "hover",
512
- /** Every range at `faintOpacity`, the hovered point's at full strength. */
513
- Faint = "faint",
514
- /** Every range at full strength; the others dim while a point is hovered. */
515
- Always = "always"
526
+ export declare enum PcacPointRangeShow {
527
+ /** Only the hovered point's range. */
528
+ Hover = "hover",
529
+ /** Every range at `faintOpacity`, the hovered point's at full strength. */
530
+ Faint = "faint",
531
+ /** Every range at full strength; the others dim while a point is hovered. */
532
+ Always = "always"
516
533
  }
517
534
  /**
518
535
  * Drawing for `PcacData.range` on the line/area/plot charts. Ranges sit above the lines/areas and
@@ -520,17 +537,17 @@ declare enum PcacPointRangeShow {
520
537
  * anchor), clipped to the plot area and following zoom. The chart draws no numbers for them; a
521
538
  * custom tooltip gets the point, `range` included.
522
539
  */
523
- declare class PcacPointRangeConfig {
524
- style: PcacPointRangeStyle;
525
- show: PcacPointRangeShow;
526
- /** Opacity of the ranges at rest under `show: Faint`, 0 - 1. */
527
- faintOpacity: number;
528
- /**
529
- * Any CSS color for every range on the chart. Unset, each takes its series' color. Applied as
530
- * `--pcac-point-range-color` on the chart's `.point-ranges` group, so a stylesheet can set it
531
- * on an ancestor instead (a config value wins).
532
- */
533
- color?: string;
540
+ export declare class PcacPointRangeConfig {
541
+ style: PcacPointRangeStyle;
542
+ show: PcacPointRangeShow;
543
+ /** Opacity of the ranges at rest under `show: Faint`, 0 - 1. */
544
+ faintOpacity: number;
545
+ /**
546
+ * Any CSS color for every range on the chart. Unset, each takes its series' color. Applied as
547
+ * `--pcac-point-range-color` on the chart's `.point-ranges` group, so a stylesheet can set it
548
+ * on an ancestor instead (a config value wins).
549
+ */
550
+ color?: string;
534
551
  }
535
552
  /**
536
553
  * Drawing for `PcacData.gauge` on the line/area/plot charts: a ring around each point's mark (its
@@ -538,61 +555,61 @@ declare class PcacPointRangeConfig {
538
555
  * over a faint full-circle track. Drawn with the mark, so it moves with zoom and fan-out; fan-out
539
556
  * spacing and the chart's edge space grow to fit it. Points without a `gauge` get no ring.
540
557
  */
541
- declare class PcacPointGaugeConfig {
542
- /** The `gauge` value of a full ring. Default 1, for values that are already a fraction. */
543
- max: number;
544
- /** Ring thickness in px. */
545
- width: number;
546
- /** Space between the mark (the image box, or a hovered dot) and the ring, in px. */
547
- gap: number;
548
- /** Draw the unfilled rest of the ring, so an arc reads as a share of a whole. */
549
- showTrack: boolean;
550
- /**
551
- * What the gauge measures, e.g. `'PSA'`. When set, each point's screen reader name ends with it
552
- * and the point's value - "…, PSA 0.018" - since the ring itself is only visual. Unset, the
553
- * ring isn't read at all; say what it means in the chart's `ariaLabel`, or a custom tooltip.
554
- */
555
- name?: string;
556
- /**
557
- * Any CSS color for the filled arc. Unset, each takes its series' color. Applied as
558
- * `--pcac-point-gauge-color` on the chart's `.dots` groups, so a stylesheet can set it on an
559
- * ancestor instead (a config value wins).
560
- */
561
- color?: string;
562
- /** Any CSS color for the track (`--pcac-point-gauge-track-color`). Theme default `$gray-200`. */
563
- trackColor?: string;
558
+ export declare class PcacPointGaugeConfig {
559
+ /** The `gauge` value of a full ring. Default 1, for values that are already a fraction. */
560
+ max: number;
561
+ /** Ring thickness in px. */
562
+ width: number;
563
+ /** Space between the mark (the image box, or a hovered dot) and the ring, in px. */
564
+ gap: number;
565
+ /** Draw the unfilled rest of the ring, so an arc reads as a share of a whole. */
566
+ showTrack: boolean;
567
+ /**
568
+ * What the gauge measures, e.g. `'PSA'`. When set, each point's screen reader name ends with it
569
+ * and the point's value - "…, PSA 0.018" - since the ring itself is only visual. Unset, the
570
+ * ring isn't read at all; say what it means in the chart's `ariaLabel`, or a custom tooltip.
571
+ */
572
+ name?: string;
573
+ /**
574
+ * Any CSS color for the filled arc. Unset, each takes its series' color. Applied as
575
+ * `--pcac-point-gauge-color` on the chart's `.dots` groups, so a stylesheet can set it on an
576
+ * ancestor instead (a config value wins).
577
+ */
578
+ color?: string;
579
+ /** Any CSS color for the track (`--pcac-point-gauge-track-color`). Theme default `$gray-200`. */
580
+ trackColor?: string;
564
581
  }
565
582
  /**
566
583
  * A line across the plot at one value on an axis (see `PcacLineAreaChartConfig.referenceLines`):
567
584
  * a target, a threshold, a median. Drawn dashed, over the grid and under the series, clipped to
568
585
  * the plot area, and moved with zoom like the data.
569
586
  */
570
- declare class PcacReferenceLine {
571
- /** Which axis `value` is on: `'y'` draws a horizontal line, `'x'` a vertical one. */
572
- axis: 'x' | 'y';
573
- /**
574
- * Where the line sits, in the axis's own terms: a number on the y axis; on the x axis, whatever
575
- * a point's `key` would be under `xAxis.format` - a number for `Decimal`, a date (or anything
576
- * `new Date()` reads) for `DateTime`, a series index otherwise.
577
- */
578
- value: number | string;
579
- /**
580
- * A few words drawn at one end of the line, inside the plot (see `labelPosition`). Styled by the
581
- * theme's `.reference-line-label` rule.
582
- */
583
- label?: string;
584
- /**
585
- * Which end of the line `label` sits at. `'end'`, the default, is above the right end of a
586
- * horizontal line and beside the top of a vertical one; `'start'` is above its left end and beside
587
- * its bottom - for when the far end is crowded, say by a corner label.
588
- */
589
- labelPosition: 'start' | 'end';
590
- /**
591
- * Any CSS color for the line and its label. Theme default `$gray-500`. Applied as
592
- * `--pcac-reference-line-color` on the line's group, so a stylesheet can set it on an ancestor
593
- * instead (a config value wins).
594
- */
595
- color?: string;
587
+ export declare class PcacReferenceLine {
588
+ /** Which axis `value` is on: `'y'` draws a horizontal line, `'x'` a vertical one. */
589
+ axis: 'x' | 'y';
590
+ /**
591
+ * Where the line sits, in the axis's own terms: a number on the y axis; on the x axis, whatever
592
+ * a point's `key` would be under `xAxis.format` - a number for `Decimal`, a date (or anything
593
+ * `new Date()` reads) for `DateTime`, a series index otherwise.
594
+ */
595
+ value: number | string;
596
+ /**
597
+ * A few words drawn at one end of the line, inside the plot (see `labelPosition`). Styled by the
598
+ * theme's `.reference-line-label` rule.
599
+ */
600
+ label?: string;
601
+ /**
602
+ * Which end of the line `label` sits at. `'end'`, the default, is above the right end of a
603
+ * horizontal line and beside the top of a vertical one; `'start'` is above its left end and beside
604
+ * its bottom - for when the far end is crowded, say by a corner label.
605
+ */
606
+ labelPosition: 'start' | 'end';
607
+ /**
608
+ * Any CSS color for the line and its label. Theme default `$gray-500`. Applied as
609
+ * `--pcac-reference-line-color` on the line's group, so a stylesheet can set it on an ancestor
610
+ * instead (a config value wins).
611
+ */
612
+ color?: string;
596
613
  }
597
614
  /**
598
615
  * Text pinned to the plot area's corners (see `PcacLineAreaChartConfig.cornerLabels`) - names for
@@ -602,27 +619,27 @@ declare class PcacReferenceLine {
602
619
  * the corner covers its label rather than the other way round, unless the chart sets `labelsOnTop`.
603
620
  * Any corner left unset is left empty.
604
621
  */
605
- declare class PcacCornerLabels {
606
- topLeft?: string;
607
- topRight?: string;
608
- bottomLeft?: string;
609
- bottomRight?: string;
610
- /**
611
- * Where the regions divide, in each axis's own terms (as `PcacReferenceLine.value`): `x` splits
612
- * left from right, `y` bottom from top; leave one out for halves. With it, a label is shown only
613
- * while its region fills its corner of the view with room for it - zoomed into one quadrant, only
614
- * that quadrant's name is left, rather than all four naming points that aren't theirs. Without
615
- * it the labels are always shown.
616
- */
617
- split?: {
618
- x?: number | string;
619
- y?: number | string;
620
- };
621
- /**
622
- * Any CSS color for all four. Theme default `$gray-600`. Applied as `--pcac-corner-label-color`
623
- * on their group, so a stylesheet can set it on an ancestor instead (a config value wins).
624
- */
625
- color?: string;
622
+ export declare class PcacCornerLabels {
623
+ topLeft?: string;
624
+ topRight?: string;
625
+ bottomLeft?: string;
626
+ bottomRight?: string;
627
+ /**
628
+ * Where the regions divide, in each axis's own terms (as `PcacReferenceLine.value`): `x` splits
629
+ * left from right, `y` bottom from top; leave one out for halves. With it, a label is shown only
630
+ * while its region fills its corner of the view with room for it - zoomed into one quadrant, only
631
+ * that quadrant's name is left, rather than all four naming points that aren't theirs. Without
632
+ * it the labels are always shown.
633
+ */
634
+ split?: {
635
+ x?: number | string;
636
+ y?: number | string;
637
+ };
638
+ /**
639
+ * Any CSS color for all four. Theme default `$gray-600`. Applied as `--pcac-corner-label-color`
640
+ * on their group, so a stylesheet can set it on an ancestor instead (a config value wins).
641
+ */
642
+ color?: string;
626
643
  }
627
644
  /**
628
645
  * The axes' `format` and `domainMin`/`domainMax` (`PcacAxisConfig`) do more here than on the bar
@@ -634,70 +651,69 @@ declare class PcacCornerLabels {
634
651
  * length and ignoring the domain fields.
635
652
  */
636
653
  declare class PcacLineAreaChartConfig extends PcacAxisChartConfig {
637
- enableEffects: boolean;
638
- /**
639
- * Zoom and pan along the x / y axis (scroll / pinch to zoom 1x-10x, drag to pan, never leaving
640
- * the original domain). Either, or both, can be on. A gesture is always two-dimensional, so with
641
- * only one enabled the other axis simply stays put. Both off by default. The zoom is kept when
642
- * the chart redraws - a new config, a series toggled in a legend, a resize (which keeps the same
643
- * part of the domain in view) - and dropped when zoom is turned off or the zoomable axes change.
644
- */
645
- enableZoomX: boolean;
646
- enableZoomY: boolean;
647
- /**
648
- * Series colors, any CSS color, in place of the theme palette, one per series in order. Repeats
649
- * from the start when there are more series than colors, as the default palette does. Omitted or
650
- * empty, the theme palette is used - optional, as on every chart's config.
651
- */
652
- colorOverride?: string[];
653
- /**
654
- * Radius of each point's dot at rest, in px. Default 4. A hovered or focused dot grows to 1.5x
655
- * that, and never to less than 4px, so the point being read always shows. 0 draws no dots at
656
- * rest, for a line or area chart where the line carries the data - a sparkline, say: each point
657
- * can still be hovered, focused and clicked (a dot smaller than 4px gets a transparent 4px
658
- * target), and still shows its tooltip. Not for a plot chart, which then draws nothing until
659
- * hovered. Point images are unaffected; they're sized by `pointImage`.
660
- */
661
- pointRadius?: number;
662
- /**
663
- * Bounding box for any point images (`PcacData.image`) on this chart. Optional; each field falls
664
- * back to the `PcacPointImageConfig` default when not given, so a consumer only setting `image`
665
- * on their data still gets a sensibly-sized result.
666
- */
667
- pointImage?: Partial<PcacPointImageConfig>;
668
- /**
669
- * Draw each point's `range` (see `PcacData.range`). Off when not set; `{}` turns it on with
670
- * every `PcacPointRangeConfig` default. Points without a `range` draw nothing extra.
671
- */
672
- pointRange?: Partial<PcacPointRangeConfig>;
673
- /**
674
- * Dashed lines at chosen values on either axis (see `PcacReferenceLine`). None when not set.
675
- * They are decoration for sighted readers - hidden from screen readers like the grid - so when
676
- * one carries meaning, say so in the chart's `ariaLabel`.
677
- */
678
- referenceLines?: Partial<PcacReferenceLine>[];
679
- /**
680
- * Draw each point's `gauge` as a ring around its mark (see `PcacData.gauge`). Off when not set;
681
- * `{}` turns it on with every `PcacPointGaugeConfig` default. Points without a `gauge` draw
682
- * nothing extra.
683
- */
684
- pointGauge?: Partial<PcacPointGaugeConfig>;
685
- /**
686
- * Labels in the plot's four corners (see `PcacCornerLabels`). None when not set. Hidden from
687
- * screen readers like the grid, so when they carry meaning, say so in the chart's `ariaLabel`.
688
- */
689
- cornerLabels?: PcacCornerLabels;
690
- /**
691
- * Draw the corner labels and reference-line labels over the series instead of under it, each
692
- * outlined in a halo so it stays readable on whatever it crosses - for a chart whose points crowd
693
- * the corners or the lines' ends, where they'd otherwise hide the labels. Default false. The halo
694
- * is `--pcac-label-halo-color`, the theme's `$white` by default: set it to the chart's background
695
- * (a dark one, say) on the chart or any ancestor. The labels never take the pointer, so a point
696
- * under one can still be hovered and clicked. The reference lines themselves stay under the series.
697
- */
698
- labelsOnTop?: boolean;
654
+ enableEffects: boolean;
655
+ /**
656
+ * Zoom and pan along the x / y axis (scroll / pinch to zoom 1x-10x, drag to pan, never leaving
657
+ * the original domain). Either, or both, can be on. A gesture is always two-dimensional, so with
658
+ * only one enabled the other axis simply stays put. Both off by default. The zoom is kept when
659
+ * the chart redraws - a new config, a series toggled in a legend, a resize (which keeps the same
660
+ * part of the domain in view) - and dropped when zoom is turned off or the zoomable axes change.
661
+ */
662
+ enableZoomX: boolean;
663
+ enableZoomY: boolean;
664
+ /**
665
+ * Series colors, any CSS color, in place of the theme palette, one per series in order. Repeats
666
+ * from the start when there are more series than colors, as the default palette does. Omitted or
667
+ * empty, the theme palette is used - optional, as on every chart's config.
668
+ */
669
+ colorOverride?: string[];
670
+ /**
671
+ * Radius of each point's dot at rest, in px. Default 4. A hovered or focused dot grows to 1.5x
672
+ * that, and never to less than 4px, so the point being read always shows. 0 draws no dots at
673
+ * rest, for a line or area chart where the line carries the data - a sparkline, say: each point
674
+ * can still be hovered, focused and clicked (a dot smaller than 4px gets a transparent 4px
675
+ * target), and still shows its tooltip. Not for a plot chart, which then draws nothing until
676
+ * hovered. Point images are unaffected; they're sized by `pointImage`.
677
+ */
678
+ pointRadius?: number;
679
+ /**
680
+ * Bounding box for any point images (`PcacData.image`) on this chart. Optional; each field falls
681
+ * back to the `PcacPointImageConfig` default when not given, so a consumer only setting `image`
682
+ * on their data still gets a sensibly-sized result.
683
+ */
684
+ pointImage?: Partial<PcacPointImageConfig>;
685
+ /**
686
+ * Draw each point's `range` (see `PcacData.range`). Off when not set; `{}` turns it on with
687
+ * every `PcacPointRangeConfig` default. Points without a `range` draw nothing extra.
688
+ */
689
+ pointRange?: Partial<PcacPointRangeConfig>;
690
+ /**
691
+ * Dashed lines at chosen values on either axis (see `PcacReferenceLine`). None when not set.
692
+ * They are decoration for sighted readers - hidden from screen readers like the grid - so when
693
+ * one carries meaning, say so in the chart's `ariaLabel`.
694
+ */
695
+ referenceLines?: Partial<PcacReferenceLine>[];
696
+ /**
697
+ * Draw each point's `gauge` as a ring around its mark (see `PcacData.gauge`). Off when not set;
698
+ * `{}` turns it on with every `PcacPointGaugeConfig` default. Points without a `gauge` draw
699
+ * nothing extra.
700
+ */
701
+ pointGauge?: Partial<PcacPointGaugeConfig>;
702
+ /**
703
+ * Labels in the plot's four corners (see `PcacCornerLabels`). None when not set. Hidden from
704
+ * screen readers like the grid, so when they carry meaning, say so in the chart's `ariaLabel`.
705
+ */
706
+ cornerLabels?: PcacCornerLabels;
707
+ /**
708
+ * Draw the corner labels and reference-line labels over the series instead of under it, each
709
+ * outlined in a halo so it stays readable on whatever it crosses - for a chart whose points crowd
710
+ * the corners or the lines' ends, where they'd otherwise hide the labels. Default false. The halo
711
+ * is `--pcac-label-halo-color`, the theme's `$white` by default: set it to the chart's background
712
+ * (a dark one, say) on the chart or any ancestor. The labels never take the pointer, so a point
713
+ * under one can still be hovered and clicked. The reference lines themselves stay under the series.
714
+ */
715
+ labelsOnTop?: boolean;
699
716
  }
700
-
701
717
  /**
702
718
  * A dot plot: every point placed along one value axis (x), and points that share a value - or,
703
719
  * with `binWidth`, fall in the same bin - stacked into a column above it, one mark per point. It
@@ -714,77 +730,92 @@ declare class PcacLineAreaChartConfig extends PcacAxisChartConfig {
714
730
  * and every label, sub label, tick and grid setting applies. There is no y scale - a column's
715
731
  * height is a count of marks, not a value - so the y axis is never drawn; `yAxis` is ignored.
716
732
  */
717
- declare class PcacDotPlotChartConfig extends PcacAxisChartConfig {
718
- /**
719
- * Group values into bins this wide, in the axis's units, and stack each bin at its center: with
720
- * values 7, 7.5 and 8 and a `binWidth` of 1, the 7 and 7.5 share a column. Unset (the default),
721
- * only equal values stack. Bins start at `xAxis.domainMin`, or 0 without one.
722
- */
723
- binWidth?: number;
724
- /**
725
- * Radius of a point's dot, in px; default 6. Points with an `image` are sized by `pointImage`
726
- * instead. Optional, as `colorOverride` is on every chart, so an object literal needn't spell it out.
727
- */
728
- dotRadius?: number;
729
- /** Space between marks stacked in a column, in px; default 2. Optional, likewise. */
730
- gap?: number;
731
- /**
732
- * Bounding box for points' images (`PcacData.image`), drawn in place of their dots, as on the
733
- * plot chart. Each field falls back to its `PcacPointImageConfig` default.
734
- *
735
- * A column too tall for the chart's height shrinks every mark on the chart evenly until it fits,
736
- * so no point is ever cut off; give the chart more `height` to keep marks at full size. The
737
- * chart's `markFit` output reports how far they were shrunk.
738
- */
739
- pointImage?: Partial<PcacPointImageConfig>;
740
- /**
741
- * Series colors, any CSS color, in place of the theme palette, one per series in order. Repeats
742
- * when there are more series than colors. Omitted or empty, the theme palette is used.
743
- */
744
- colorOverride?: string[];
733
+ export declare class PcacDotPlotChartConfig extends PcacAxisChartConfig {
734
+ /**
735
+ * Group values into bins this wide, in the axis's units, and stack each bin at its center: with
736
+ * values 7, 7.5 and 8 and a `binWidth` of 1, the 7 and 7.5 share a column. Unset (the default),
737
+ * only equal values stack. Bins start at `xAxis.domainMin`, or 0 without one.
738
+ */
739
+ binWidth?: number;
740
+ /**
741
+ * Radius of a point's dot, in px; default 6. Points with an `image` are sized by `pointImage`
742
+ * instead. Optional, as `colorOverride` is on every chart, so an object literal needn't spell it out.
743
+ */
744
+ dotRadius?: number;
745
+ /** Space between marks stacked in a column, in px; default 2. Optional, likewise. */
746
+ gap?: number;
747
+ /**
748
+ * Bounding box for points' images (`PcacData.image`), drawn in place of their dots, as on the
749
+ * plot chart. Each field falls back to its `PcacPointImageConfig` default.
750
+ *
751
+ * A column too tall for the chart's height shrinks every mark on the chart evenly until it fits,
752
+ * so no point is ever cut off; give the chart more `height` to keep marks at full size. The
753
+ * chart's `markFit` output reports how far they were shrunk.
754
+ */
755
+ pointImage?: Partial<PcacPointImageConfig>;
756
+ /**
757
+ * Series colors, any CSS color, in place of the theme palette, one per series in order. Repeats
758
+ * when there are more series than colors. Omitted or empty, the theme palette is used.
759
+ */
760
+ colorOverride?: string[];
745
761
  }
746
-
747
762
  /** A dot plot: points along one value axis, stacked into columns where they share a value (see PcacDotPlotChartConfig). */
748
- declare class PcacDotPlotChart {
749
- private chartBuilder;
750
- readonly config: _angular_core.InputSignal<PcacDotPlotChartConfig>;
751
- private readonly chartElm;
752
- readonly dotClicked: _angular_core.OutputRef<_pioneer_code_pioneer_charts.PcacData>;
753
- /**
754
- * How much the marks were scaled to fit the chart's height, after a draw that changed it: 1 at
755
- * full size, below 1 once a column too tall for the chart shrank every mark evenly (see
756
- * `pointImage`). An image is drawn `pointImage.maxWidth * fit` by `maxHeight * fit`, a dot at
757
- * `dotRadius * fit` - so a size control can show what was actually drawn.
758
- */
759
- readonly markFit: _angular_core.OutputRef<number>;
760
- /** Optional consumer `<ng-template pcacTooltip>`, replacing the default tooltip (see PcacTooltipDirective). */
761
- readonly tooltipTemplate: _angular_core.Signal<PcacTooltipDirective | undefined>;
762
- constructor();
763
- private buildChart;
764
- static ɵfac: _angular_core.ɵɵFactoryDeclaration<PcacDotPlotChart, never>;
765
- static ɵcmp: _angular_core.ɵɵComponentDeclaration<PcacDotPlotChart, "pcac-dot-plot-chart", never, { "config": { "alias": "config"; "required": true; "isSignal": true; }; }, { "dotClicked": "dotClicked"; "markFit": "markFit"; }, ["tooltipTemplate"], never, true, never>;
763
+ export declare class PcacDotPlotChart {
764
+ private chartBuilder;
765
+ readonly config: import("@angular/core").InputSignal<PcacDotPlotChartConfig>;
766
+ private readonly chartElm;
767
+ readonly dotClicked: import("@angular/core").OutputRef<PcacData>;
768
+ /**
769
+ * How much the marks were scaled to fit the chart's height, after a draw that changed it: 1 at
770
+ * full size, below 1 once a column too tall for the chart shrank every mark evenly (see
771
+ * `pointImage`). An image is drawn `pointImage.maxWidth * fit` by `maxHeight * fit`, a dot at
772
+ * `dotRadius * fit` - so a size control can show what was actually drawn.
773
+ */
774
+ readonly markFit: import("@angular/core").OutputRef<number>;
775
+ /** Optional consumer `<ng-template pcacTooltip>`, replacing the default tooltip (see PcacTooltipDirective). */
776
+ readonly tooltipTemplate: import("@angular/core").Signal<PcacTooltipDirective | undefined>;
777
+ constructor();
778
+ private buildChart;
779
+ static ɵfac: i0.ɵɵFactoryDeclaration<PcacDotPlotChart, never>;
780
+ static ɵcmp: i0.ɵɵComponentDeclaration<PcacDotPlotChart, "pcac-dot-plot-chart", never, {
781
+ "config": {
782
+ "alias": "config";
783
+ "required": true;
784
+ "isSignal": true;
785
+ };
786
+ }, {
787
+ "dotClicked": "dotClicked";
788
+ "markFit": "markFit";
789
+ }, ["tooltipTemplate"], never, true, never>;
766
790
  }
767
-
768
- declare class PcacLegendConfigItem {
769
- label: string;
770
- checked: boolean;
771
- colorOverride: string | null;
791
+ export declare class PcacLegendConfigItem {
792
+ label: string;
793
+ checked: boolean;
794
+ colorOverride: string | null;
772
795
  }
773
- declare class PcacLegendConfig {
774
- heading: string | null;
775
- items: PcacLegendConfigItem[];
796
+ export declare class PcacLegendConfig {
797
+ heading: string | null;
798
+ items: PcacLegendConfigItem[];
776
799
  }
777
- declare class PcacLegend {
778
- readonly headingId: string;
779
- private readonly colorService;
780
- config: _angular_core.ModelSignal<PcacLegendConfig>;
781
- itemClicked: _angular_core.OutputEmitterRef<PcacLegendConfigItem[]>;
782
- colorScale: _angular_core.Signal<string[]>;
783
- onItemClicked(index: number): void;
784
- static ɵfac: _angular_core.ɵɵFactoryDeclaration<PcacLegend, never>;
785
- static ɵcmp: _angular_core.ɵɵComponentDeclaration<PcacLegend, "pcac-legend", never, { "config": { "alias": "config"; "required": true; "isSignal": true; }; }, { "config": "configChange"; "itemClicked": "itemClicked"; }, never, never, true, never>;
800
+ export declare class PcacLegend {
801
+ readonly headingId: string;
802
+ private readonly colorService;
803
+ config: import("@angular/core").ModelSignal<PcacLegendConfig>;
804
+ itemClicked: import("@angular/core").OutputEmitterRef<PcacLegendConfigItem[]>;
805
+ colorScale: import("@angular/core").Signal<string[]>;
806
+ onItemClicked(index: number): void;
807
+ static ɵfac: i0.ɵɵFactoryDeclaration<PcacLegend, never>;
808
+ static ɵcmp: i0.ɵɵComponentDeclaration<PcacLegend, "pcac-legend", never, {
809
+ "config": {
810
+ "alias": "config";
811
+ "required": true;
812
+ "isSignal": true;
813
+ };
814
+ }, {
815
+ "config": "configChange";
816
+ "itemClicked": "itemClicked";
817
+ }, never, never, true, never>;
786
818
  }
787
-
788
819
  /**
789
820
  * How the plot chart spreads out points that share a coordinate (see
790
821
  * `PcacPlotChartConfig.pointFanOut`). Each group of coincident points is placed evenly around
@@ -793,92 +824,108 @@ declare class PcacLegend {
793
824
  * the edge of the domain is moved back inside the plot area as one, so no member hangs over an
794
825
  * axis by more than half its mark - the same as a lone point there; the anchor stays put.
795
826
  */
796
- declare class PcacPointFanOutConfig {
797
- /**
798
- * Ring radius in px, the same for every group. When not set, each group gets the smallest
799
- * radius at which its neighbors sit `gap` px apart - so a pair barely moves while a group of
800
- * five spreads as far as it has to.
801
- */
802
- radius?: number;
803
- /**
804
- * Space between neighboring points on the ring, in px, when `radius` is not set. Measured
805
- * between their image boxes (or hovered dots), not their centers.
806
- */
807
- gap: number;
808
- /**
809
- * Draw a dot at the shared coordinate - the value the group's points actually have - with a
810
- * spoke out to each of them. Styled by the theme's `.fan-out-anchor` / `.fan-out-spoke` rules,
811
- * whose colors `anchorColor` / `spokeColor` override.
812
- */
813
- showAnchor: boolean;
814
- /**
815
- * Spoke color, any CSS color; theme default `$gray-400`. Applied as `--pcac-fan-out-spoke-color`
816
- * on the chart's `.fan-outs` group, so a stylesheet can set it on an ancestor instead (a config
817
- * value wins). Needs `showAnchor`.
818
- */
819
- spokeColor?: string;
820
- /** Anchor dot color, likewise (`--pcac-fan-out-anchor-color`); theme default `$gray-600`. */
821
- anchorColor?: string;
822
- }
823
- declare class PcacPlotChartConfig extends PcacLineAreaChartConfig {
824
- /**
825
- * Spread points that share a coordinate around it instead of drawing them on top of one
826
- * another (where only the last series' point shows, and only it can be hovered). Off when not
827
- * set; `{}` turns it on with every `PcacPointFanOutConfig` default. The fanned points keep
828
- * their true value in the tooltip, and the hovered point's tooltip context lists the others at
829
- * its coordinate in `coincident` (see `PcacTooltipContext`).
830
- *
831
- * Plot chart only: a line or area chart's points are joined in series order, so moving one
832
- * would kink the line.
833
- */
834
- pointFanOut?: Partial<PcacPointFanOutConfig>;
827
+ export declare class PcacPointFanOutConfig {
828
+ /**
829
+ * Ring radius in px, the same for every group. When not set, each group gets the smallest
830
+ * radius at which its neighbors sit `gap` px apart - so a pair barely moves while a group of
831
+ * five spreads as far as it has to.
832
+ */
833
+ radius?: number;
834
+ /**
835
+ * Space between neighboring points on the ring, in px, when `radius` is not set. Measured
836
+ * between their image boxes (or hovered dots), not their centers.
837
+ */
838
+ gap: number;
839
+ /**
840
+ * Draw a dot at the shared coordinate - the value the group's points actually have - with a
841
+ * spoke out to each of them. Styled by the theme's `.fan-out-anchor` / `.fan-out-spoke` rules,
842
+ * whose colors `anchorColor` / `spokeColor` override.
843
+ */
844
+ showAnchor: boolean;
845
+ /**
846
+ * Spoke color, any CSS color; theme default `$gray-400`. Applied as `--pcac-fan-out-spoke-color`
847
+ * on the chart's `.fan-outs` group, so a stylesheet can set it on an ancestor instead (a config
848
+ * value wins). Needs `showAnchor`.
849
+ */
850
+ spokeColor?: string;
851
+ /** Anchor dot color, likewise (`--pcac-fan-out-anchor-color`); theme default `$gray-600`. */
852
+ anchorColor?: string;
835
853
  }
836
-
837
- declare class PcacPlotChart {
838
- readonly config: _angular_core.InputSignal<PcacPlotChartConfig>;
839
- protected readonly types: typeof PcacLineAreaPlotChartConfigType;
840
- readonly dotClicked: _angular_core.OutputEmitterRef<PcacData>;
841
- /**
842
- * Optional consumer `<ng-template pcacTooltip>` projected into this element, forwarded to the
843
- * inner chart (see PcacLineAreaChartComponent.tooltipTemplate for why it can't query it itself).
844
- */
845
- readonly tooltipTemplate: _angular_core.Signal<PcacTooltipDirective | undefined>;
846
- static ɵfac: _angular_core.ɵɵFactoryDeclaration<PcacPlotChart, never>;
847
- static ɵcmp: _angular_core.ɵɵComponentDeclaration<PcacPlotChart, "pcac-plot-chart", never, { "config": { "alias": "config"; "required": true; "isSignal": true; }; }, { "dotClicked": "dotClicked"; }, ["tooltipTemplate"], never, true, never>;
854
+ export declare class PcacPlotChartConfig extends PcacLineAreaChartConfig {
855
+ /**
856
+ * Spread points that share a coordinate around it instead of drawing them on top of one
857
+ * another (where only the last series' point shows, and only it can be hovered). Off when not
858
+ * set; `{}` turns it on with every `PcacPointFanOutConfig` default. The fanned points keep
859
+ * their true value in the tooltip, and the hovered point's tooltip context lists the others at
860
+ * its coordinate in `coincident` (see `PcacTooltipContext`).
861
+ *
862
+ * Plot chart only: a line or area chart's points are joined in series order, so moving one
863
+ * would kink the line.
864
+ */
865
+ pointFanOut?: Partial<PcacPointFanOutConfig>;
848
866
  }
849
-
850
- declare class PcacLineChartConfig extends PcacLineAreaChartConfig {
851
- }
852
-
853
- declare class PcacLineChart {
854
- readonly config: _angular_core.InputSignal<PcacLineChartConfig>;
855
- protected readonly types: typeof PcacLineAreaPlotChartConfigType;
856
- readonly dotClicked: _angular_core.OutputEmitterRef<PcacData>;
857
- /**
858
- * Optional consumer `<ng-template pcacTooltip>` projected into this element, forwarded to the
859
- * inner chart (see PcacLineAreaChartComponent.tooltipTemplate for why it can't query it itself).
860
- */
861
- readonly tooltipTemplate: _angular_core.Signal<PcacTooltipDirective | undefined>;
862
- static ɵfac: _angular_core.ɵɵFactoryDeclaration<PcacLineChart, never>;
863
- static ɵcmp: _angular_core.ɵɵComponentDeclaration<PcacLineChart, "pcac-line-chart", never, { "config": { "alias": "config"; "required": true; "isSignal": true; }; }, { "dotClicked": "dotClicked"; }, ["tooltipTemplate"], never, true, never>;
867
+ export declare class PcacPlotChart {
868
+ readonly config: import("@angular/core").InputSignal<PcacPlotChartConfig>;
869
+ protected readonly types: typeof PcacLineAreaPlotChartConfigType;
870
+ readonly dotClicked: import("@angular/core").OutputEmitterRef<PcacData>;
871
+ /**
872
+ * Optional consumer `<ng-template pcacTooltip>` projected into this element, forwarded to the
873
+ * inner chart (see PcacLineAreaChartComponent.tooltipTemplate for why it can't query it itself).
874
+ */
875
+ readonly tooltipTemplate: import("@angular/core").Signal<PcacTooltipDirective | undefined>;
876
+ static ɵfac: i0.ɵɵFactoryDeclaration<PcacPlotChart, never>;
877
+ static ɵcmp: i0.ɵɵComponentDeclaration<PcacPlotChart, "pcac-plot-chart", never, {
878
+ "config": {
879
+ "alias": "config";
880
+ "required": true;
881
+ "isSignal": true;
882
+ };
883
+ }, {
884
+ "dotClicked": "dotClicked";
885
+ }, ["tooltipTemplate"], never, true, never>;
864
886
  }
865
-
866
- declare class PcacAreaChartConfig extends PcacLineAreaChartConfig {
887
+ export declare class PcacLineChartConfig extends PcacLineAreaChartConfig {}
888
+ export declare class PcacLineChart {
889
+ readonly config: import("@angular/core").InputSignal<PcacLineChartConfig>;
890
+ protected readonly types: typeof PcacLineAreaPlotChartConfigType;
891
+ readonly dotClicked: import("@angular/core").OutputEmitterRef<PcacData>;
892
+ /**
893
+ * Optional consumer `<ng-template pcacTooltip>` projected into this element, forwarded to the
894
+ * inner chart (see PcacLineAreaChartComponent.tooltipTemplate for why it can't query it itself).
895
+ */
896
+ readonly tooltipTemplate: import("@angular/core").Signal<PcacTooltipDirective | undefined>;
897
+ static ɵfac: i0.ɵɵFactoryDeclaration<PcacLineChart, never>;
898
+ static ɵcmp: i0.ɵɵComponentDeclaration<PcacLineChart, "pcac-line-chart", never, {
899
+ "config": {
900
+ "alias": "config";
901
+ "required": true;
902
+ "isSignal": true;
903
+ };
904
+ }, {
905
+ "dotClicked": "dotClicked";
906
+ }, ["tooltipTemplate"], never, true, never>;
867
907
  }
868
-
869
- declare class PcacAreaChart {
870
- readonly config: _angular_core.InputSignal<PcacAreaChartConfig>;
871
- protected readonly types: typeof PcacLineAreaPlotChartConfigType;
872
- readonly dotClicked: _angular_core.OutputEmitterRef<PcacData>;
873
- /**
874
- * Optional consumer `<ng-template pcacTooltip>` projected into this element, forwarded to the
875
- * inner chart (see PcacLineAreaChartComponent.tooltipTemplate for why it can't query it itself).
876
- */
877
- readonly tooltipTemplate: _angular_core.Signal<PcacTooltipDirective | undefined>;
878
- static ɵfac: _angular_core.ɵɵFactoryDeclaration<PcacAreaChart, never>;
879
- static ɵcmp: _angular_core.ɵɵComponentDeclaration<PcacAreaChart, "pcac-area-chart", never, { "config": { "alias": "config"; "required": true; "isSignal": true; }; }, { "dotClicked": "dotClicked"; }, ["tooltipTemplate"], never, true, never>;
908
+ export declare class PcacAreaChartConfig extends PcacLineAreaChartConfig {}
909
+ export declare class PcacAreaChart {
910
+ readonly config: import("@angular/core").InputSignal<PcacAreaChartConfig>;
911
+ protected readonly types: typeof PcacLineAreaPlotChartConfigType;
912
+ readonly dotClicked: import("@angular/core").OutputEmitterRef<PcacData>;
913
+ /**
914
+ * Optional consumer `<ng-template pcacTooltip>` projected into this element, forwarded to the
915
+ * inner chart (see PcacLineAreaChartComponent.tooltipTemplate for why it can't query it itself).
916
+ */
917
+ readonly tooltipTemplate: import("@angular/core").Signal<PcacTooltipDirective | undefined>;
918
+ static ɵfac: i0.ɵɵFactoryDeclaration<PcacAreaChart, never>;
919
+ static ɵcmp: i0.ɵɵComponentDeclaration<PcacAreaChart, "pcac-area-chart", never, {
920
+ "config": {
921
+ "alias": "config";
922
+ "required": true;
923
+ "isSignal": true;
924
+ };
925
+ }, {
926
+ "dotClicked": "dotClicked";
927
+ }, ["tooltipTemplate"], never, true, never>;
880
928
  }
881
-
882
929
  /**
883
930
  * A proximity chart: one item in the middle (`center`) and others (`data`) around it, each placed
884
931
  * closer in or further out by its `value` - how similar it is to the center, say, or how far from
@@ -892,64 +939,70 @@ declare class PcacAreaChart {
892
939
  * number, or with `hide`, is left out. Best with a handful to a dozen or so items; past that they
893
940
  * crowd one another around the ring.
894
941
  */
895
- declare class PcacProximityChartConfig extends PcacChartConfig {
896
- /** The item the others are measured against, drawn in the middle. Its `value` isn't used. */
897
- center: PcacData;
898
- /**
899
- * The `value` that sits right up against the center, and the one that sits on the outer rim;
900
- * values in between are placed proportionally, and anything beyond either is held at it.
901
- * The defaults suit a similarity from 0 to 1 (1 = identical, closest in). For a distance, swap
902
- * them: `closeValue: 0, farValue: <largest distance>`.
903
- */
904
- closeValue?: number;
905
- farValue?: number;
906
- /**
907
- * Values to draw a faint guide ring at, each labelled in `format` - e.g. `[0.95, 0.9, 0.85]` with
908
- * `Percentage` reads "95%", "90%", "85%". None when not set.
909
- */
910
- rings?: number[];
911
- /** How values read on the ring labels, in the tooltip and to screen readers; see `PcacFormatEnum`. */
912
- format?: PcacFormatEnum;
913
- /**
914
- * Write each item's `key` under it, and the center's under the center. Default false: names are
915
- * in the tooltip either way. Keep it off for long names or a crowded ring.
916
- */
917
- showLabels?: boolean;
918
- /** Draw a faint line from the center to each item. Default true. */
919
- showSpokes?: boolean;
920
- /** Where the first item sits, in degrees clockwise from 12 o'clock. Default 0. */
921
- startAngle?: number;
922
- /** Size of the center item's image (or twice its dot's radius), in px. Default 64. */
923
- centerSize?: number;
924
- /** Size of each surrounding item's image (or twice its dot's radius), in px. Default 40. */
925
- itemSize?: number;
926
- /**
927
- * Item colors, any CSS color, used in data order for the dots of items without an `image` (the
928
- * center takes the first). Repeated when there are more items than colors. Omitted or empty, the
929
- * theme palette is used.
930
- */
931
- colorOverride?: string[];
942
+ export declare class PcacProximityChartConfig extends PcacChartConfig {
943
+ /** The item the others are measured against, drawn in the middle. Its `value` isn't used. */
944
+ center: PcacData;
945
+ /**
946
+ * The `value` that sits right up against the center, and the one that sits on the outer rim;
947
+ * values in between are placed proportionally, and anything beyond either is held at it.
948
+ * The defaults suit a similarity from 0 to 1 (1 = identical, closest in). For a distance, swap
949
+ * them: `closeValue: 0, farValue: <largest distance>`.
950
+ */
951
+ closeValue?: number;
952
+ farValue?: number;
953
+ /**
954
+ * Values to draw a faint guide ring at, each labelled in `format` - e.g. `[0.95, 0.9, 0.85]` with
955
+ * `Percentage` reads "95%", "90%", "85%". None when not set.
956
+ */
957
+ rings?: number[];
958
+ /** How values read on the ring labels, in the tooltip and to screen readers; see `PcacFormatEnum`. */
959
+ format?: PcacFormatEnum;
960
+ /**
961
+ * Write each item's `key` under it, and the center's under the center. Default false: names are
962
+ * in the tooltip either way. Keep it off for long names or a crowded ring.
963
+ */
964
+ showLabels?: boolean;
965
+ /** Draw a faint line from the center to each item. Default true. */
966
+ showSpokes?: boolean;
967
+ /** Where the first item sits, in degrees clockwise from 12 o'clock. Default 0. */
968
+ startAngle?: number;
969
+ /** Size of the center item's image (or twice its dot's radius), in px. Default 64. */
970
+ centerSize?: number;
971
+ /** Size of each surrounding item's image (or twice its dot's radius), in px. Default 40. */
972
+ itemSize?: number;
973
+ /**
974
+ * Item colors, any CSS color, used in data order for the dots of items without an `image` (the
975
+ * center takes the first). Repeated when there are more items than colors. Omitted or empty, the
976
+ * theme palette is used.
977
+ */
978
+ colorOverride?: string[];
932
979
  }
933
-
934
980
  /** A proximity chart: an item in the middle, others around it by closeness (see PcacProximityChartConfig). */
935
- declare class PcacProximityChart {
936
- private chartBuilder;
937
- readonly config: _angular_core.InputSignal<PcacProximityChartConfig>;
938
- private readonly chartElm;
939
- /** An item - or the center - was clicked, or activated with Enter or Space. */
940
- readonly itemClicked: _angular_core.OutputRef<_pioneer_code_pioneer_charts.PcacData>;
941
- /** Optional consumer `<ng-template pcacTooltip>`, replacing the default tooltip (see PcacTooltipDirective). */
942
- readonly tooltipTemplate: _angular_core.Signal<PcacTooltipDirective | undefined>;
943
- constructor();
944
- private buildChart;
945
- static ɵfac: _angular_core.ɵɵFactoryDeclaration<PcacProximityChart, never>;
946
- static ɵcmp: _angular_core.ɵɵComponentDeclaration<PcacProximityChart, "pcac-proximity-chart", never, { "config": { "alias": "config"; "required": true; "isSignal": true; }; }, { "itemClicked": "itemClicked"; }, ["tooltipTemplate"], never, true, never>;
981
+ export declare class PcacProximityChart {
982
+ private chartBuilder;
983
+ readonly config: import("@angular/core").InputSignal<PcacProximityChartConfig>;
984
+ private readonly chartElm;
985
+ /** An item - or the center - was clicked, or activated with Enter or Space. */
986
+ readonly itemClicked: import("@angular/core").OutputRef<PcacData>;
987
+ /** Optional consumer `<ng-template pcacTooltip>`, replacing the default tooltip (see PcacTooltipDirective). */
988
+ readonly tooltipTemplate: import("@angular/core").Signal<PcacTooltipDirective | undefined>;
989
+ constructor();
990
+ private buildChart;
991
+ static ɵfac: i0.ɵɵFactoryDeclaration<PcacProximityChart, never>;
992
+ static ɵcmp: i0.ɵɵComponentDeclaration<PcacProximityChart, "pcac-proximity-chart", never, {
993
+ "config": {
994
+ "alias": "config";
995
+ "required": true;
996
+ "isSignal": true;
997
+ };
998
+ }, {
999
+ "itemClicked": "itemClicked";
1000
+ }, ["tooltipTemplate"], never, true, never>;
947
1001
  }
948
-
949
1002
  /** Which chart the shared `<pcac-pie-donut-chart>` draws; each wrapper binds its own. */
950
1003
  declare enum PcacPieDonutChartType {
951
- Pie = "pie",
952
- Donut = "donut"
1004
+ Pie = "pie",
1005
+ Donut = "donut"
953
1006
  }
954
1007
  /**
955
1008
  * What the pie and donut charts share. Internal: consumers configure `PcacPieChartConfig` or
@@ -957,69 +1010,149 @@ declare enum PcacPieDonutChartType {
957
1010
  * `PcacLineAreaChartConfig`.
958
1011
  */
959
1012
  declare class PcacPieDonutChartConfig extends PcacChartConfig {
960
- /**
961
- * Slice colors, any CSS color, in data order - the first slice takes the first color - in place
962
- * of the theme palette. Repeated when there are more slices than colors. Omitted or empty, the
963
- * theme palette is used. Match a `<pcac-legend>` to it with each item's `colorOverride`.
964
- */
965
- colorOverride?: string[];
1013
+ /**
1014
+ * Slice colors, any CSS color, in data order - the first slice takes the first color - in place
1015
+ * of the theme palette. Repeated when there are more slices than colors. Omitted or empty, the
1016
+ * theme palette is used. Match a `<pcac-legend>` to it with each item's `colorOverride`.
1017
+ */
1018
+ colorOverride?: string[];
966
1019
  }
967
-
968
- declare class PcacPieChartConfig extends PcacPieDonutChartConfig {
969
- }
970
-
971
- declare class PcacPieChart {
972
- readonly config: _angular_core.InputSignal<PcacPieChartConfig>;
973
- protected readonly types: typeof PcacPieDonutChartType;
974
- readonly sliceClicked: _angular_core.OutputEmitterRef<PcacData>;
975
- /**
976
- * Optional consumer `<ng-template pcacTooltip>` projected into this element, forwarded to the
977
- * inner chart (see PcacPieDonutChartComponent.tooltipTemplate).
978
- */
979
- readonly tooltipTemplate: _angular_core.Signal<PcacTooltipDirective | undefined>;
980
- static ɵfac: _angular_core.ɵɵFactoryDeclaration<PcacPieChart, never>;
981
- static ɵcmp: _angular_core.ɵɵComponentDeclaration<PcacPieChart, "pcac-pie-chart", never, { "config": { "alias": "config"; "required": true; "isSignal": true; }; }, { "sliceClicked": "sliceClicked"; }, ["tooltipTemplate"], never, true, never>;
1020
+ export declare class PcacPieChartConfig extends PcacPieDonutChartConfig {}
1021
+ export declare class PcacPieChart {
1022
+ readonly config: import("@angular/core").InputSignal<PcacPieChartConfig>;
1023
+ protected readonly types: typeof PcacPieDonutChartType;
1024
+ readonly sliceClicked: import("@angular/core").OutputEmitterRef<PcacData>;
1025
+ /**
1026
+ * Optional consumer `<ng-template pcacTooltip>` projected into this element, forwarded to the
1027
+ * inner chart (see PcacPieDonutChartComponent.tooltipTemplate).
1028
+ */
1029
+ readonly tooltipTemplate: import("@angular/core").Signal<PcacTooltipDirective | undefined>;
1030
+ static ɵfac: i0.ɵɵFactoryDeclaration<PcacPieChart, never>;
1031
+ static ɵcmp: i0.ɵɵComponentDeclaration<PcacPieChart, "pcac-pie-chart", never, {
1032
+ "config": {
1033
+ "alias": "config";
1034
+ "required": true;
1035
+ "isSignal": true;
1036
+ };
1037
+ }, {
1038
+ "sliceClicked": "sliceClicked";
1039
+ }, ["tooltipTemplate"], never, true, never>;
982
1040
  }
983
-
984
1041
  /**
985
1042
  * A pie with its slices drawn as a ring around an empty center, which can hold a short label -
986
1043
  * typically the total the slices add up to.
987
1044
  */
988
- declare class PcacDonutChartConfig extends PcacPieDonutChartConfig {
989
- /**
990
- * Radius of the hole as a fraction of the chart's radius, from 0 (no hole - a pie) to 0.9.
991
- * Values outside that range are clamped.
992
- */
993
- innerRadius?: number;
994
- /**
995
- * Large text centered in the hole, e.g. `'67'`. Sized to the hole and shrunk to fit across it;
996
- * left out if it would have to go below 8px. Not drawn when not set.
997
- */
998
- label?: string;
999
- /** Smaller line under `label`, e.g. `'balls'`, fitted the same way. Not drawn when not set. */
1000
- subLabel?: string;
1001
- /**
1002
- * `label` color, any CSS color; theme default `$gray-800`. Applied as
1003
- * `--pcac-donut-center-label-color` on the chart's `.pcac-donut-center` group, so a stylesheet
1004
- * can set it on an ancestor instead (a config value wins).
1005
- */
1006
- labelColor?: string;
1007
- /** `subLabel` color, likewise (`--pcac-donut-center-sub-label-color`); theme default `$gray-600`. */
1008
- subLabelColor?: string;
1045
+ export declare class PcacDonutChartConfig extends PcacPieDonutChartConfig {
1046
+ /**
1047
+ * Radius of the hole as a fraction of the chart's radius, from 0 (no hole - a pie) to 0.9.
1048
+ * Values outside that range are clamped.
1049
+ */
1050
+ innerRadius?: number;
1051
+ /**
1052
+ * Large text centered in the hole, e.g. `'67'`. Sized to the hole and shrunk to fit across it;
1053
+ * left out if it would have to go below 8px. Not drawn when not set.
1054
+ */
1055
+ label?: string;
1056
+ /** Smaller line under `label`, e.g. `'balls'`, fitted the same way. Not drawn when not set. */
1057
+ subLabel?: string;
1058
+ /**
1059
+ * `label` color, any CSS color; theme default `$gray-800`. Applied as
1060
+ * `--pcac-donut-center-label-color` on the chart's `.pcac-donut-center` group, so a stylesheet
1061
+ * can set it on an ancestor instead (a config value wins).
1062
+ */
1063
+ labelColor?: string;
1064
+ /** `subLabel` color, likewise (`--pcac-donut-center-sub-label-color`); theme default `$gray-600`. */
1065
+ subLabelColor?: string;
1066
+ }
1067
+ export declare class PcacDonutChart {
1068
+ readonly config: import("@angular/core").InputSignal<PcacDonutChartConfig>;
1069
+ protected readonly types: typeof PcacPieDonutChartType;
1070
+ readonly sliceClicked: import("@angular/core").OutputEmitterRef<PcacData>;
1071
+ /**
1072
+ * Optional consumer `<ng-template pcacTooltip>` projected into this element, forwarded to the
1073
+ * inner chart (see PcacPieDonutChartComponent.tooltipTemplate).
1074
+ */
1075
+ readonly tooltipTemplate: import("@angular/core").Signal<PcacTooltipDirective | undefined>;
1076
+ static ɵfac: i0.ɵɵFactoryDeclaration<PcacDonutChart, never>;
1077
+ static ɵcmp: i0.ɵɵComponentDeclaration<PcacDonutChart, "pcac-donut-chart", never, {
1078
+ "config": {
1079
+ "alias": "config";
1080
+ "required": true;
1081
+ "isSignal": true;
1082
+ };
1083
+ }, {
1084
+ "sliceClicked": "sliceClicked";
1085
+ }, ["tooltipTemplate"], never, true, never>;
1086
+ }
1087
+ /** One state a period can be in, such as OK or Error: its key, its name and its color. */
1088
+ export declare class PcacStateTimelineState {
1089
+ /** The state's key, matching the keys in a period's `data`. */
1090
+ key: string;
1091
+ /** The state's name in the tooltip and for screen readers. Defaults to its `key`. */
1092
+ label?: string;
1093
+ /**
1094
+ * Any CSS color. Defaults to the theme: pale green for the first state, strong red for the last,
1095
+ * and amber for any in between. Choose colors that differ in lightness so people with color
1096
+ * blindness can tell them apart.
1097
+ */
1098
+ color?: string;
1009
1099
  }
1010
-
1011
- declare class PcacDonutChart {
1012
- readonly config: _angular_core.InputSignal<PcacDonutChartConfig>;
1013
- protected readonly types: typeof PcacPieDonutChartType;
1014
- readonly sliceClicked: _angular_core.OutputEmitterRef<PcacData>;
1015
- /**
1016
- * Optional consumer `<ng-template pcacTooltip>` projected into this element, forwarded to the
1017
- * inner chart (see PcacPieDonutChartComponent.tooltipTemplate).
1018
- */
1019
- readonly tooltipTemplate: _angular_core.Signal<PcacTooltipDirective | undefined>;
1020
- static ɵfac: _angular_core.ɵɵFactoryDeclaration<PcacDonutChart, never>;
1021
- static ɵcmp: _angular_core.ɵɵComponentDeclaration<PcacDonutChart, "pcac-donut-chart", never, { "config": { "alias": "config"; "required": true; "isSignal": true; }; }, { "sliceClicked": "sliceClicked"; }, ["tooltipTemplate"], never, true, never>;
1100
+ /**
1101
+ * A state timeline shows how something's status changed over time. Each row is one thing you're
1102
+ * tracking, like a service or a device, split into periods such as days or hours. Each period is
1103
+ * colored by the worst state it reached, so one hour of Error in an otherwise good day still shows.
1104
+ *
1105
+ * `data` is a list of rows. A row's `key` is its name, shown to its left unless `rowLabels` is
1106
+ * false, and its `data` is its periods, oldest first. Each period has:
1107
+ * - `key`: its name, shown in the tooltip and read by screen readers (`'Fri, Nov 20'`).
1108
+ * - `value`: how long it is, in any unit. Leave it out and the length is the total of its states.
1109
+ * - `data`: how much time it spent in each state, in the same unit, keyed by the state's `key`.
1110
+ *
1111
+ * Any time not covered by a state is unknown: a partly unknown period is striped, and an entirely
1112
+ * unknown one is plain gray. The color is lighter when the worst state lasted a short time and
1113
+ * full strength when it lasted all of the period's known time. Every period in a row is the same
1114
+ * width. A row or period with `hide` set is left out.
1115
+ */
1116
+ export declare class PcacStateTimelineConfig extends PcacChartConfig {
1117
+ /**
1118
+ * Height in pixels, split evenly between the rows with 4px between them. Default 24, which fits
1119
+ * one row; set a larger height for more rows.
1120
+ */
1121
+ height: number;
1122
+ /** The states a period can be in, from least to most severe. Each period shows its worst. */
1123
+ states: PcacStateTimelineState[];
1124
+ /**
1125
+ * Space between periods, in px. Default 2. It shrinks to 1px, then to none, when periods get
1126
+ * too narrow.
1127
+ */
1128
+ gap?: number;
1129
+ /** Show each row's name to its left. Default true. */
1130
+ rowLabels?: boolean;
1131
+ }
1132
+ /** A state timeline: rows of periods, each colored by the worst state it was in (see PcacStateTimelineConfig). */
1133
+ export declare class PcacStateTimeline {
1134
+ private chartBuilder;
1135
+ readonly config: import("@angular/core").InputSignal<PcacStateTimelineConfig>;
1136
+ private readonly chartElm;
1137
+ /** A period clicked, or Enter or Space on one focused: the period itself, from its row's `data`. */
1138
+ readonly periodClicked: import("@angular/core").OutputRef<PcacData>;
1139
+ /**
1140
+ * Optional consumer `<ng-template pcacTooltip>`, replacing the default tooltip (see
1141
+ * PcacTooltipDirective): its `$implicit` is the period, `parent` its row, `index` its place in
1142
+ * the row and `parentIndex` the row's among those drawn.
1143
+ */
1144
+ readonly tooltipTemplate: import("@angular/core").Signal<PcacTooltipDirective | undefined>;
1145
+ constructor();
1146
+ private buildChart;
1147
+ static ɵfac: i0.ɵɵFactoryDeclaration<PcacStateTimeline, never>;
1148
+ static ɵcmp: i0.ɵɵComponentDeclaration<PcacStateTimeline, "pcac-state-timeline", never, {
1149
+ "config": {
1150
+ "alias": "config";
1151
+ "required": true;
1152
+ "isSignal": true;
1153
+ };
1154
+ }, {
1155
+ "periodClicked": "periodClicked";
1156
+ }, ["tooltipTemplate"], never, true, never>;
1022
1157
  }
1023
-
1024
- export { PcacAreaChart, PcacAreaChartConfig, PcacAxisChartConfig, PcacAxisConfig, PcacAxisSubLabels, PcacBarHorizontalChart, PcacBarHorizontalChart as PcacBarHorizontalChartComponent, PcacBarHorizontalChartConfig, PcacBarVerticalChart, PcacBarVerticalChart as PcacBarVerticalChartComponent, PcacBarVerticalChartConfig, PcacChartConfig, PcacColorService, PcacCornerLabels, PcacData, PcacDataRange, PcacDonutChart, PcacDonutChartConfig, PcacDotPlotChart, PcacDotPlotChartConfig, PcacFormatEnum, PcacLegend, PcacLegendConfig, PcacLegendConfigItem, PcacLineChart, PcacLineChartConfig, PcacPieChart, PcacPieChartConfig, PcacPlotChart, PcacPlotChartConfig, PcacPointFanOutConfig, PcacPointGaugeConfig, PcacPointImageConfig, PcacPointRangeConfig, PcacPointRangeShow, PcacPointRangeStyle, PcacProximityChart, PcacProximityChartConfig, PcacRangeBounds, PcacReferenceLine, PcacTooltipDirective };
1025
- export type { PcacTooltipCoincident, PcacTooltipContext };
1158
+ export { PcacBarHorizontalChart as PcacBarHorizontalChartComponent, PcacBarVerticalChart as PcacBarVerticalChartComponent };