@lostgradient/cinder 0.22.0 → 0.23.0

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.
Files changed (164) hide show
  1. package/CHANGELOG.md +31 -0
  2. package/components.json +1 -1
  3. package/dist/_internal/chart/chart-bar-model.d.ts +24 -0
  4. package/dist/_internal/chart/chart-cartesian-model.d.ts +16 -0
  5. package/dist/_internal/chart/chart-layout.d.ts +23 -0
  6. package/dist/_internal/chart/chart-model-utilities.d.ts +157 -0
  7. package/dist/_internal/chart/chart-scale.d.ts +37 -0
  8. package/dist/_internal/chart/chart-utilities.d.ts +7 -164
  9. package/dist/_internal/chart/heatmap-utilities.d.ts +5 -4
  10. package/dist/components/_internal/chart-tooltip.css +21 -0
  11. package/dist/components/_internal/chart-tooltip.svelte.d.ts +11 -0
  12. package/dist/components/approval-card/index.js +5 -5
  13. package/dist/components/area-chart/area-chart.css +27 -23
  14. package/dist/components/area-chart/area-chart.schema.js +38 -1
  15. package/dist/components/area-chart/area-chart.types.d.ts +6 -2
  16. package/dist/components/area-chart/index.js +1589 -768
  17. package/dist/components/badge/badge.css +2 -2
  18. package/dist/components/badge/badge.schema.js +2 -2
  19. package/dist/components/badge/badge.types.d.ts +3 -3
  20. package/dist/components/badge/index.js +4 -4
  21. package/dist/components/bar-chart/bar-chart.css +27 -21
  22. package/dist/components/bar-chart/bar-chart.schema.js +38 -1
  23. package/dist/components/bar-chart/bar-chart.types.d.ts +7 -3
  24. package/dist/components/bar-chart/index.js +1544 -740
  25. package/dist/components/chart.types.d.ts +98 -2
  26. package/dist/components/json-schema-editor/index.js +4 -4
  27. package/dist/components/line-chart/index.js +1587 -785
  28. package/dist/components/line-chart/line-chart.css +25 -24
  29. package/dist/components/line-chart/line-chart.schema.js +38 -1
  30. package/dist/components/line-chart/line-chart.types.d.ts +6 -2
  31. package/dist/components/matrix-chart/index.js +1038 -429
  32. package/dist/components/matrix-chart/matrix-chart.css +12 -6
  33. package/dist/components/matrix-chart/matrix-chart.schema.js +26 -1
  34. package/dist/components/matrix-chart/matrix-chart.types.d.ts +5 -1
  35. package/dist/components/payload-inspector/index.js +4 -4
  36. package/dist/components/run-step-timeline/index.js +6 -6
  37. package/dist/components/sparkbar/index.js +1291 -4
  38. package/dist/components/sparkbar/sparkbar.css +5 -4
  39. package/dist/components/sparkbar/sparkbar.schema.js +26 -1
  40. package/dist/components/sparkbar/sparkbar.types.d.ts +5 -0
  41. package/dist/components/spectrogram/index.js +1076 -437
  42. package/dist/components/spectrogram/spectrogram.css +7 -6
  43. package/dist/components/spectrogram/spectrogram.schema.js +26 -1
  44. package/dist/components/spectrogram/spectrogram.types.d.ts +5 -1
  45. package/dist/components/spectrum-chart/index.js +1037 -423
  46. package/dist/components/spectrum-chart/spectrum-chart.css +8 -7
  47. package/dist/components/spectrum-chart/spectrum-chart.schema.js +26 -1
  48. package/dist/components/spectrum-chart/spectrum-chart.types.d.ts +5 -1
  49. package/dist/components/statistic/index.js +1284 -2
  50. package/dist/components/statistic/statistic.css +6 -5
  51. package/dist/components/statistic/statistic.schema.js +26 -1
  52. package/dist/components/statistic/statistic.types.d.ts +5 -0
  53. package/dist/components/statistic-group/index.js +1284 -2
  54. package/dist/components/waveform/index.js +1004 -404
  55. package/dist/components/waveform/waveform.css +8 -7
  56. package/dist/components/waveform/waveform.schema.js +26 -1
  57. package/dist/components/waveform/waveform.types.d.ts +5 -1
  58. package/dist/index.d.ts +1 -1
  59. package/dist/index.js +17730 -16540
  60. package/dist/server/components/approval-card/index.js +3 -3
  61. package/dist/server/components/area-chart/index.js +3 -3
  62. package/dist/server/components/badge/index.js +2 -2
  63. package/dist/server/components/bar-chart/index.js +3 -3
  64. package/dist/server/components/json-schema-editor/index.js +2 -2
  65. package/dist/server/components/line-chart/index.js +3 -3
  66. package/dist/server/components/matrix-chart/index.js +3 -3
  67. package/dist/server/components/payload-inspector/index.js +3 -3
  68. package/dist/server/components/run-step-timeline/index.js +2 -2
  69. package/dist/server/components/sparkbar/index.js +3 -2
  70. package/dist/server/components/spectrogram/index.js +3 -3
  71. package/dist/server/components/spectrum-chart/index.js +2 -2
  72. package/dist/server/components/statistic/index.js +4 -3
  73. package/dist/server/components/statistic-group/index.js +4 -3
  74. package/dist/server/components/waveform/index.js +2 -2
  75. package/dist/server/index.js +21 -21
  76. package/dist/server/{index.server-3dkwzkd3.js → index.server-10r7yf13.js} +110 -27
  77. package/dist/server/{index.server-93943z3e.js → index.server-151dt1tx.js} +1 -1
  78. package/dist/server/{index.server-pp2n6def.js → index.server-2y0xz53g.js} +37 -14
  79. package/dist/server/{index.server-bd8rcgf0.js → index.server-4hvjet4z.js} +1 -1
  80. package/dist/server/{index.server-bsm39gpy.js → index.server-5d83fkyg.js} +75 -21
  81. package/dist/server/{index.server-4wweyb2e.js → index.server-8dh2rtnc.js} +1 -1
  82. package/dist/server/{index.server-abqbstkt.js → index.server-9gj583qs.js} +41 -14
  83. package/dist/server/{index.server-2nmwsacy.js → index.server-9scm7zf9.js} +4 -4
  84. package/dist/server/{index.server-5j6jv7rm.js → index.server-9vwxyy06.js} +108 -29
  85. package/dist/server/{index.server-abjsjsw8.js → index.server-afpjvfz1.js} +111 -35
  86. package/dist/server/{index.server-86sw5ea6.js → index.server-dw9bz17h.js} +4 -4
  87. package/dist/server/{index.server-d26jzn2m.js → index.server-en31rprd.js} +3 -3
  88. package/dist/server/{index.server-dx58qant.js → index.server-f3a0ecqg.js} +72 -9
  89. package/dist/server/{index.server-d63pwytk.js → index.server-kz8aeeq5.js} +18 -10
  90. package/dist/server/index.server-mmmrgvyd.js +1274 -0
  91. package/dist/server/{index.server-1221p7e4.js → index.server-scahngwv.js} +13 -1
  92. package/dist/server/{index.server-nj8kk5bv.js → index.server-t73q59c1.js} +1 -1
  93. package/dist/server/{index.server-5schb2vt.js → index.server-tdrncj5e.js} +16 -6
  94. package/dist/server/{index.server-wm8957be.js → index.server-veqke4sq.js} +10 -1
  95. package/dist/server/{index.server-fphvzcfb.js → index.server-wqajghn9.js} +1 -1
  96. package/dist/server/{index.server-yd9shwqq.js → index.server-zjcjzcv6.js} +1 -1
  97. package/package.json +1 -1
  98. package/src/_internal/chart/chart-bar-model.ts +330 -0
  99. package/src/_internal/chart/chart-cartesian-model.ts +450 -0
  100. package/src/_internal/chart/chart-interaction.svelte.ts +25 -6
  101. package/src/_internal/chart/chart-layout.ts +348 -0
  102. package/src/_internal/chart/chart-model-utilities.ts +357 -0
  103. package/src/_internal/chart/chart-scale.ts +487 -0
  104. package/src/_internal/chart/chart-utilities.ts +22 -1078
  105. package/src/_internal/chart/heatmap-utilities.ts +21 -17
  106. package/src/components/_internal/chart-tooltip.css +21 -0
  107. package/src/components/_internal/chart-tooltip.svelte +44 -0
  108. package/src/components/approval-card/approval-card.svelte +1 -1
  109. package/src/components/area-chart/area-chart.css +27 -23
  110. package/src/components/area-chart/area-chart.examples.json +1 -1
  111. package/src/components/area-chart/area-chart.schema.json +37 -0
  112. package/src/components/area-chart/area-chart.schema.ts +40 -0
  113. package/src/components/area-chart/area-chart.svelte +103 -35
  114. package/src/components/area-chart/area-chart.types.ts +7 -1
  115. package/src/components/badge/badge.css +2 -2
  116. package/src/components/badge/badge.schema.json +1 -1
  117. package/src/components/badge/badge.schema.ts +1 -1
  118. package/src/components/badge/badge.svelte +2 -2
  119. package/src/components/badge/badge.types.ts +3 -3
  120. package/src/components/bar-chart/bar-chart.css +27 -21
  121. package/src/components/bar-chart/bar-chart.schema.json +37 -0
  122. package/src/components/bar-chart/bar-chart.schema.ts +40 -0
  123. package/src/components/bar-chart/bar-chart.svelte +94 -33
  124. package/src/components/bar-chart/bar-chart.types.ts +9 -2
  125. package/src/components/chart.types.ts +112 -2
  126. package/src/components/line-chart/line-chart.css +25 -24
  127. package/src/components/line-chart/line-chart.examples.json +1 -1
  128. package/src/components/line-chart/line-chart.schema.json +37 -0
  129. package/src/components/line-chart/line-chart.schema.ts +40 -0
  130. package/src/components/line-chart/line-chart.svelte +95 -40
  131. package/src/components/line-chart/line-chart.types.ts +7 -1
  132. package/src/components/matrix-chart/matrix-chart.css +12 -6
  133. package/src/components/matrix-chart/matrix-chart.schema.json +25 -0
  134. package/src/components/matrix-chart/matrix-chart.schema.ts +25 -0
  135. package/src/components/matrix-chart/matrix-chart.svelte +30 -12
  136. package/src/components/matrix-chart/matrix-chart.types.ts +5 -1
  137. package/src/components/run-step-timeline/run-step-timeline.svelte +2 -2
  138. package/src/components/sparkbar/sparkbar.css +5 -4
  139. package/src/components/sparkbar/sparkbar.schema.json +25 -0
  140. package/src/components/sparkbar/sparkbar.schema.ts +26 -0
  141. package/src/components/sparkbar/sparkbar.svelte +8 -1
  142. package/src/components/sparkbar/sparkbar.types.ts +5 -0
  143. package/src/components/spectrogram/spectrogram.css +7 -6
  144. package/src/components/spectrogram/spectrogram.schema.json +25 -0
  145. package/src/components/spectrogram/spectrogram.schema.ts +25 -0
  146. package/src/components/spectrogram/spectrogram.svelte +73 -28
  147. package/src/components/spectrogram/spectrogram.types.ts +5 -1
  148. package/src/components/spectrum-chart/spectrum-chart.css +8 -7
  149. package/src/components/spectrum-chart/spectrum-chart.schema.json +25 -0
  150. package/src/components/spectrum-chart/spectrum-chart.schema.ts +26 -0
  151. package/src/components/spectrum-chart/spectrum-chart.svelte +38 -12
  152. package/src/components/spectrum-chart/spectrum-chart.types.ts +5 -1
  153. package/src/components/statistic/statistic.css +6 -5
  154. package/src/components/statistic/statistic.schema.json +25 -0
  155. package/src/components/statistic/statistic.schema.ts +26 -0
  156. package/src/components/statistic/statistic.svelte +6 -1
  157. package/src/components/statistic/statistic.types.ts +5 -0
  158. package/src/components/waveform/waveform.css +8 -7
  159. package/src/components/waveform/waveform.schema.json +25 -0
  160. package/src/components/waveform/waveform.schema.ts +26 -0
  161. package/src/components/waveform/waveform.svelte +16 -3
  162. package/src/components/waveform/waveform.types.ts +5 -1
  163. package/src/index.ts +8 -0
  164. package/dist/server/index.server-6vbpz6dd.js +0 -690
@@ -57,8 +57,207 @@ import"@lostgradient/cinder/spectrogram/styles";
57
57
  // src/components/spectrogram/spectrogram.svelte
58
58
  import"svelte/internal/disclose-version";
59
59
  import * as $2 from "svelte/internal/client";
60
+ import { onMount } from "svelte";
60
61
 
61
- // src/_internal/chart/chart-utilities.ts
62
+ // src/_internal/chart/chart-layout.ts
63
+ var CHART_OUTER_PADDING = 16;
64
+ var CHART_GUIDE_GAP = 8;
65
+ var CHART_AXIS_TITLE_GAP = 12;
66
+ var HORIZONTAL_CATEGORY_LABEL_GAP = 8;
67
+ var HORIZONTAL_CATEGORY_LABEL_OUTER_PADDING = 8;
68
+ var MAXIMUM_HORIZONTAL_CATEGORY_LABEL_FRACTION = 0.4;
69
+ var MAXIMUM_CHART_TEXT_MEASUREMENTS = 1024;
70
+ function createChartGeometry(width, height, options = {}) {
71
+ const xTickRotation = options.xAxis?.tickLabelRotation ?? 0;
72
+ if (!Number.isFinite(xTickRotation)) {
73
+ throw new Error(`[cinder/chart] rule=invalid-tick-label-rotation tickLabelRotation="${xTickRotation}": expected a finite number.`);
74
+ }
75
+ const xTickLabels = options.xTickLabels ?? [];
76
+ const yTickLabels = options.yTickLabels ?? [];
77
+ const measurementContext = createChartTextMeasurementContext(options.measureText ?? false, options.measurementElement, options.measurementVersion ?? 0);
78
+ const textMeasurements = measureChartTexts([
79
+ ...xTickLabels.map((label) => ({ label, rotation: xTickRotation })),
80
+ ...yTickLabels.map((label) => ({ label, rotation: 0 })),
81
+ ...options.xAxis?.label ? [{ label: options.xAxis.label, rotation: 0 }] : [],
82
+ ...options.yAxis?.label ? [{ label: options.yAxis.label, rotation: -90 }] : []
83
+ ], measurementContext);
84
+ const measurementFor = (label, rotation) => textMeasurements.get(chartTextMeasurementKey(label, rotation, measurementContext.cacheKey)) ?? fallbackChartTextMeasurement(label, rotation);
85
+ const xTickHeight = maximumMeasurement(xTickLabels, (label) => measurementFor(label, xTickRotation).height);
86
+ const firstXTickWidth = xTickLabels[0] ? measurementFor(xTickLabels[0], xTickRotation).width : 0;
87
+ const lastXTickLabel = xTickLabels.at(-1);
88
+ const lastXTickWidth = lastXTickLabel ? measurementFor(lastXTickLabel, xTickRotation).width : 0;
89
+ const yTickWidth = maximumMeasurement(yTickLabels, (label) => measurementFor(label, 0).width);
90
+ const xAxisTitleHeight = options.xAxis?.label ? measurementFor(options.xAxis.label, 0).height + CHART_AXIS_TITLE_GAP : 0;
91
+ const yAxisTitleWidth = options.yAxis?.label ? measurementFor(options.yAxis.label, -90).width + CHART_AXIS_TITLE_GAP : 0;
92
+ const derivedMarginLeft = CHART_OUTER_PADDING + yTickWidth + CHART_GUIDE_GAP + yAxisTitleWidth;
93
+ const maximumMarginLeft = Math.max(CHART_OUTER_PADDING, Math.floor(width * 0.4));
94
+ const endpointLeftMargin = Math.max(CHART_OUTER_PADDING, Math.ceil(firstXTickWidth / 2) + CHART_GUIDE_GAP);
95
+ const endpointRightMargin = Math.max(CHART_OUTER_PADDING, Math.ceil(lastXTickWidth / 2) + CHART_GUIDE_GAP);
96
+ const marginLeft = Math.min(maximumMarginLeft, Math.max(derivedMarginLeft, options.marginLeft ?? 0, endpointLeftMargin));
97
+ const marginTop = options.xTickPosition === "top" ? Math.min(Math.max(CHART_OUTER_PADDING, Math.floor(height * 0.45)), CHART_OUTER_PADDING + xTickHeight + CHART_GUIDE_GAP + xAxisTitleHeight) : CHART_OUTER_PADDING;
98
+ const marginRight = endpointRightMargin;
99
+ const marginBottom = options.xTickPosition === "top" ? CHART_OUTER_PADDING : Math.min(Math.max(CHART_OUTER_PADDING, Math.floor(height * 0.45)), CHART_OUTER_PADDING + xTickHeight + CHART_GUIDE_GAP + xAxisTitleHeight);
100
+ return {
101
+ plotWidth: Math.max(1, width - marginLeft - marginRight),
102
+ plotHeight: Math.max(1, height - marginTop - marginBottom),
103
+ marginTop,
104
+ marginRight,
105
+ marginBottom,
106
+ marginLeft
107
+ };
108
+ }
109
+ function createHorizontalCategoryLabelLayout(labels, chartWidth, options = {}) {
110
+ const measurementContext = createChartTextMeasurementContext(options.measureText ?? false, options.measurementElement, options.measurementVersion ?? 0);
111
+ const textMeasurements = measureChartTexts([...labels.map((label) => ({ label, rotation: 0 })), { label: "…", rotation: 0 }], measurementContext);
112
+ const measurementFor = (label) => textMeasurements.get(chartTextMeasurementKey(label, 0, measurementContext.cacheKey)) ?? fallbackChartTextMeasurement(label, 0);
113
+ const maximumMarginLeft = Math.max(CHART_OUTER_PADDING, Math.floor(chartWidth * MAXIMUM_HORIZONTAL_CATEGORY_LABEL_FRACTION));
114
+ let longestLabelWidth = 0;
115
+ for (const label of labels) {
116
+ longestLabelWidth = Math.max(longestLabelWidth, measurementFor(label).width);
117
+ }
118
+ const requestedMarginLeft = longestLabelWidth + HORIZONTAL_CATEGORY_LABEL_GAP + HORIZONTAL_CATEGORY_LABEL_OUTER_PADDING;
119
+ const marginLeft = Math.min(maximumMarginLeft, Math.max(CHART_OUTER_PADDING, requestedMarginLeft));
120
+ const availableLabelWidth = Math.max(0, marginLeft - HORIZONTAL_CATEGORY_LABEL_GAP - HORIZONTAL_CATEGORY_LABEL_OUTER_PADDING);
121
+ return {
122
+ marginLeft,
123
+ labels: labels.map((label) => truncateHorizontalCategoryLabel(label, availableLabelWidth, measurementFor))
124
+ };
125
+ }
126
+ function observeChartFontLoading(onFontsChanged) {
127
+ if (typeof document === "undefined" || !document.fonts)
128
+ return () => {};
129
+ let active = true;
130
+ const handleFontsChanged = () => {
131
+ if (active)
132
+ onFontsChanged();
133
+ };
134
+ document.fonts.addEventListener("loadingdone", handleFontsChanged);
135
+ document.fonts.ready.then(handleFontsChanged);
136
+ return () => {
137
+ active = false;
138
+ document.fonts.removeEventListener("loadingdone", handleFontsChanged);
139
+ };
140
+ }
141
+ function truncateHorizontalCategoryLabel(label, availableWidth, measurementFor) {
142
+ const measuredWidth = measurementFor(label).width;
143
+ if (measuredWidth <= availableWidth)
144
+ return label;
145
+ const fallbackWidth = fallbackChartTextMeasurement(label, 0).width;
146
+ const measurementScale = fallbackWidth > 0 ? measuredWidth / fallbackWidth : 1;
147
+ const estimatedWidth = (candidate) => candidate === "…" ? measurementFor("…").width : fallbackChartTextMeasurement(candidate, 0).width * measurementScale;
148
+ const characters = Array.from(label);
149
+ while (characters.length > 0) {
150
+ const truncated = `${characters.join("")}…`;
151
+ if (estimatedWidth(truncated) <= availableWidth)
152
+ return truncated;
153
+ characters.pop();
154
+ }
155
+ return availableWidth >= estimatedWidth("…") ? "…" : "";
156
+ }
157
+ function maximumMeasurement(labels, select) {
158
+ let maximum = 0;
159
+ for (const label of labels)
160
+ maximum = Math.max(maximum, select(label));
161
+ return maximum;
162
+ }
163
+ var chartTextMeasurementCache = new Map;
164
+ function measureChartTexts(entries, context) {
165
+ if (!context.container || typeof document === "undefined") {
166
+ return new Map(entries.map(({ label, rotation }) => [
167
+ chartTextMeasurementKey(label, rotation, context.cacheKey),
168
+ fallbackChartTextMeasurement(label, rotation)
169
+ ]));
170
+ }
171
+ const uniqueEntries = [
172
+ ...new Map(entries.map((entry) => [
173
+ chartTextMeasurementKey(entry.label, entry.rotation, context.cacheKey),
174
+ entry
175
+ ])).values()
176
+ ];
177
+ const missing = uniqueEntries.filter(({ label, rotation }) => !chartTextMeasurementCache.has(chartTextMeasurementKey(label, rotation, context.cacheKey)));
178
+ if (missing.length > 0) {
179
+ const svg = document.createElementNS("http://www.w3.org/2000/svg", "svg");
180
+ svg.setAttribute("style", "position:absolute;visibility:hidden;pointer-events:none;inline-size:0;block-size:0");
181
+ const texts = missing.map((entry) => {
182
+ const text = document.createElementNS("http://www.w3.org/2000/svg", "text");
183
+ if (context.textStyle)
184
+ text.setAttribute("style", context.textStyle);
185
+ text.textContent = entry.label;
186
+ svg.append(text);
187
+ return { ...entry, text };
188
+ });
189
+ context.container.append(svg);
190
+ for (const { label, rotation, text } of texts) {
191
+ let measurement;
192
+ try {
193
+ const bounds = text.getBBox();
194
+ if (bounds.width > 0 && bounds.height > 0) {
195
+ measurement = { width: bounds.width, height: bounds.height };
196
+ }
197
+ } catch {}
198
+ if (measurement) {
199
+ cacheChartTextMeasurement(chartTextMeasurementKey(label, rotation, context.cacheKey), rotateChartTextMeasurement(measurement, rotation));
200
+ }
201
+ }
202
+ svg.remove();
203
+ }
204
+ return new Map(entries.map(({ label, rotation }) => [
205
+ chartTextMeasurementKey(label, rotation, context.cacheKey),
206
+ chartTextMeasurementCache.get(chartTextMeasurementKey(label, rotation, context.cacheKey)) ?? fallbackChartTextMeasurement(label, rotation)
207
+ ]));
208
+ }
209
+ function cacheChartTextMeasurement(key, measurement) {
210
+ if (!chartTextMeasurementCache.has(key)) {
211
+ while (chartTextMeasurementCache.size >= MAXIMUM_CHART_TEXT_MEASUREMENTS) {
212
+ const oldestKey = chartTextMeasurementCache.keys().next().value;
213
+ if (oldestKey === undefined)
214
+ break;
215
+ chartTextMeasurementCache.delete(oldestKey);
216
+ }
217
+ }
218
+ chartTextMeasurementCache.set(key, measurement);
219
+ }
220
+ function chartTextMeasurementKey(label, rotation, measurementContext) {
221
+ return `${label}\x00${rotation}\x00${measurementContext}`;
222
+ }
223
+ function createChartTextMeasurementContext(allowBrowserMeasurement, measurementElement, measurementVersion) {
224
+ if (!allowBrowserMeasurement || !measurementElement || typeof window === "undefined" || !measurementElement.isConnected) {
225
+ return { cacheKey: "fallback" };
226
+ }
227
+ const style = window.getComputedStyle(measurementElement);
228
+ const fontSize = style.getPropertyValue("--cinder-text-xs").trim() || style.fontSize;
229
+ const textStyle = [
230
+ `font-family:${style.fontFamily}`,
231
+ `font-size:${fontSize}`,
232
+ `font-style:${style.fontStyle}`,
233
+ `font-weight:${style.fontWeight}`,
234
+ `font-stretch:${style.fontStretch}`,
235
+ `font-variant:${style.fontVariant}`,
236
+ `font-feature-settings:${style.fontFeatureSettings}`,
237
+ `font-kerning:${style.fontKerning}`,
238
+ `letter-spacing:${style.letterSpacing}`,
239
+ `text-transform:${style.textTransform}`
240
+ ].join(";");
241
+ return {
242
+ cacheKey: `browser\x00${measurementVersion}\x00${textStyle}`,
243
+ container: measurementElement,
244
+ textStyle
245
+ };
246
+ }
247
+ function fallbackChartTextMeasurement(label, rotation) {
248
+ return rotateChartTextMeasurement({ width: Array.from(label).length * 7, height: 12 }, rotation);
249
+ }
250
+ function rotateChartTextMeasurement(measurement, rotation) {
251
+ if (rotation === 0)
252
+ return measurement;
253
+ const radians = Math.abs(rotation) * Math.PI / 180;
254
+ return {
255
+ width: Math.abs(measurement.width * Math.cos(radians)) + Math.abs(measurement.height * Math.sin(radians)),
256
+ height: Math.abs(measurement.width * Math.sin(radians)) + Math.abs(measurement.height * Math.cos(radians))
257
+ };
258
+ }
259
+
260
+ // src/_internal/chart/chart-model-utilities.ts
62
261
  var chartPalette = [
63
262
  "var(--cinder-chart-series-1)",
64
263
  "var(--cinder-chart-series-2)",
@@ -69,8 +268,26 @@ var chartPalette = [
69
268
  "var(--cinder-chart-series-7)",
70
269
  "var(--cinder-chart-series-8)"
71
270
  ];
72
- function chartPaletteColor(index) {
73
- return chartPalette[index % chartPalette.length] ?? "var(--cinder-chart-series-1)";
271
+ function chartPaletteColor(index, palette = chartPalette) {
272
+ const resolvedPalette = palette.length > 0 ? palette : chartPalette;
273
+ if (index < 0)
274
+ return resolvedPalette[0] ?? chartPalette[0];
275
+ return resolvedPalette[index % resolvedPalette.length] ?? chartPalette[0];
276
+ }
277
+ function resolveChartTheme(theme = undefined) {
278
+ return {
279
+ foreground: theme?.foreground ?? "currentColor",
280
+ muted: theme?.muted ?? "currentColor",
281
+ grid: theme?.grid ?? "currentColor",
282
+ background: theme?.background ?? "transparent",
283
+ palette: theme?.palette?.length ? [...theme.palette] : [...chartPalette]
284
+ };
285
+ }
286
+ function chartResourceSegment(segment) {
287
+ return encodeURIComponent(segment).replace(/[!'()*]/g, (character) => `%${character.charCodeAt(0).toString(16).toUpperCase()}`).replaceAll("_", "_u").replaceAll("-", "_d").replaceAll("%", "_x");
288
+ }
289
+ function chartResourceId(idPrefix, resource, seriesId) {
290
+ return [idPrefix, resource, seriesId].map(chartResourceSegment).join("-");
74
291
  }
75
292
  function assertValidChartNumber(componentId, rule, value, label) {
76
293
  if (!Number.isFinite(value) || value <= 0) {
@@ -92,6 +309,9 @@ function assertValidTickCount(componentId, axis) {
92
309
  function dataTableClass(visibility) {
93
310
  return visibility === "screen-reader-only" ? "cinder-sr-only" : undefined;
94
311
  }
312
+ function formatDataTableCaption(caption, displayedRowCount, totalRowCount) {
313
+ return totalRowCount > displayedRowCount ? `${caption} (showing ${displayedRowCount} of ${totalRowCount} data points)` : caption;
314
+ }
95
315
  function formatXValue(value, axis, context) {
96
316
  return axis?.format ? axis.format(value.raw, context) : value.label;
97
317
  }
@@ -136,194 +356,462 @@ function assertUniqueSeriesIds(componentId, series) {
136
356
  function toggleSeriesId(hiddenSeriesIds, seriesId) {
137
357
  return hiddenSeriesIds.includes(seriesId) ? hiddenSeriesIds.filter((id) => id !== seriesId) : [...hiddenSeriesIds, seriesId];
138
358
  }
139
- function createCartesianModel(options) {
140
- const {
141
- componentId,
142
- series,
143
- hiddenSeriesIds,
144
- width,
145
- height,
146
- xAxis,
147
- yAxis,
148
- stackedArea = false
149
- } = options;
150
- assertUniqueSeriesIds(componentId, series);
151
- assertValidChartNumber(componentId, "invalid-height", height, "height");
152
- assertValidTickCount(componentId, xAxis);
153
- assertValidTickCount(componentId, yAxis);
154
- const geometry = createGeometry(width, height);
155
- const allKinds = new Set;
156
- const xValuesByKey = new Map;
157
- const normalizedSeries = series.map((item, seriesIndex) => {
158
- const seenX = new Set;
159
- const color = item.color ?? chartPaletteColor(seriesIndex);
160
- const points = item.data.map((point, pointIndex) => {
161
- const x = normalizeXValue(point.x);
162
- allKinds.add(x.kind);
163
- if (seenX.has(x.key)) {
164
- throw new Error(`[cinder/${componentId}] rule=duplicate-x series="${item.id}" x="${x.label}": duplicate x values are not supported.`);
359
+ function nearestTarget(targets, x, y, axis = "x") {
360
+ if (targets.length === 0)
361
+ return;
362
+ if (targets.length === 1)
363
+ return targets[0];
364
+ const pointerKey = axis === "x" ? x : y;
365
+ let low = 0;
366
+ let high = targets.length - 1;
367
+ while (low < high) {
368
+ const mid = low + high >> 1;
369
+ const midKey = axis === "x" ? targets[mid]?.x ?? 0 : targets[mid]?.y ?? 0;
370
+ if (midKey < pointerKey)
371
+ low = mid + 1;
372
+ else
373
+ high = mid;
374
+ }
375
+ const candidates = [];
376
+ function addBucket(start) {
377
+ const target = targets[start];
378
+ if (!target)
379
+ return;
380
+ const bucketKey = axis === "x" ? target.x : target.y;
381
+ for (let index = start;index >= 0; index--) {
382
+ const candidate = targets[index];
383
+ if (!candidate)
384
+ continue;
385
+ const candidateKey = axis === "x" ? candidate.x : candidate.y;
386
+ if (candidateKey !== bucketKey)
387
+ break;
388
+ candidates.push(candidate);
389
+ }
390
+ for (let index = start + 1;index < targets.length; index++) {
391
+ const candidate = targets[index];
392
+ if (!candidate)
393
+ continue;
394
+ const candidateKey = axis === "x" ? candidate.x : candidate.y;
395
+ if (candidateKey !== bucketKey)
396
+ break;
397
+ candidates.push(candidate);
398
+ }
399
+ }
400
+ addBucket(low);
401
+ if (low > 0) {
402
+ addBucket(low - 1);
403
+ }
404
+ let nearest;
405
+ let nearestDistance = Number.POSITIVE_INFINITY;
406
+ for (const target of candidates) {
407
+ const targetDistance = Math.hypot(target.x - x, target.y - y);
408
+ if (targetDistance >= nearestDistance)
409
+ continue;
410
+ nearest = target;
411
+ nearestDistance = targetDistance;
412
+ }
413
+ return nearest;
414
+ }
415
+ function legendVisible(legendPosition, seriesCount) {
416
+ return legendPosition !== "none" && seriesCount > 0;
417
+ }
418
+
419
+ // src/_internal/chart/chart-scale.ts
420
+ var MAXIMUM_RENDERED_SERIES_POINTS = 2000;
421
+ function evenlySample(values, count) {
422
+ if (values.length <= count)
423
+ return [...values];
424
+ if (count <= 1)
425
+ return values[0] === undefined ? [] : [values[0]];
426
+ return Array.from({ length: count }, (_, index) => {
427
+ const sourceIndex = Math.round(index * (values.length - 1) / (count - 1));
428
+ return values[sourceIndex];
429
+ });
430
+ }
431
+ function boundedGapHeavyIndices(points, limit) {
432
+ const finiteRuns = [];
433
+ let index = 0;
434
+ while (index < points.length) {
435
+ while (index < points.length && points[index]?.y === null)
436
+ index += 1;
437
+ if (index >= points.length)
438
+ break;
439
+ let representative = index;
440
+ let maximumMagnitude = Math.abs(points[index]?.y ?? 0);
441
+ while (index + 1 < points.length && points[index + 1]?.y !== null) {
442
+ index += 1;
443
+ const magnitude = Math.abs(points[index]?.y ?? 0);
444
+ if (magnitude > maximumMagnitude) {
445
+ maximumMagnitude = magnitude;
446
+ representative = index;
165
447
  }
166
- seenX.add(x.key);
167
- xValuesByKey.set(x.key, x);
168
- const y = normalizeNumericValue(componentId, item.id, x.label, point.y);
169
- return {
170
- seriesId: item.id,
171
- seriesLabel: item.label,
172
- color,
173
- x,
174
- y,
175
- originalY: point.y,
176
- index: pointIndex
177
- };
178
- });
179
- return { id: item.id, label: item.label, color, points };
448
+ }
449
+ finiteRuns.push({ end: index, representative });
450
+ index += 1;
451
+ }
452
+ const maximumFiniteRuns = Math.max(1, Math.floor((limit + 1) / 2));
453
+ const sampledRuns = evenlySample(finiteRuns, maximumFiniteRuns);
454
+ const selected = [];
455
+ sampledRuns.forEach((run, runIndex) => {
456
+ const previousRun = sampledRuns[runIndex - 1];
457
+ if (previousRun)
458
+ selected.push(previousRun.end + 1);
459
+ selected.push(run.representative);
180
460
  });
181
- if (allKinds.size > 1) {
182
- throw new Error(`[cinder/${componentId}] rule=mixed-x-domain-kind: all x values must share one domain kind.`);
461
+ return selected.sort((a, b) => a - b);
462
+ }
463
+ function layerExtremaIndices(layers, startIndex, endIndex) {
464
+ const extrema = new Set;
465
+ for (const layer of layers) {
466
+ let minimumIndex;
467
+ let maximumIndex;
468
+ let minimumValue = Number.POSITIVE_INFINITY;
469
+ let maximumValue = Number.NEGATIVE_INFINITY;
470
+ for (let index = startIndex;index < endIndex; index++) {
471
+ const value = layer[index];
472
+ if (value == null)
473
+ continue;
474
+ if (value < minimumValue) {
475
+ minimumValue = value;
476
+ minimumIndex = index;
477
+ }
478
+ if (value > maximumValue) {
479
+ maximumValue = value;
480
+ maximumIndex = index;
481
+ }
482
+ }
483
+ if (minimumIndex !== undefined)
484
+ extrema.add(minimumIndex);
485
+ if (maximumIndex !== undefined)
486
+ extrema.add(maximumIndex);
183
487
  }
184
- if (stackedArea) {
185
- for (const item of normalizedSeries) {
186
- for (const point of item.points) {
187
- if ((point.y ?? 0) < 0) {
188
- throw new Error(`[cinder/${componentId}] rule=negative-stacked-area series="${item.id}" x="${point.x.label}": stacked areas do not support negative values.`);
189
- }
488
+ return [...extrema];
489
+ }
490
+ function boundedGapHeavyLayerSelections(layers, pointCount, limit) {
491
+ const finiteIndices = [];
492
+ for (let index = 0;index < pointCount; index++) {
493
+ if (layers.some((layer) => layer[index] != null))
494
+ finiteIndices.push(index);
495
+ }
496
+ const maximumFiniteSamples = Math.max(1, Math.floor((limit + 1) / 2));
497
+ const retainedIndices = new Set;
498
+ const priorityIndices = [
499
+ finiteIndices[0],
500
+ finiteIndices.at(-1),
501
+ ...layerExtremaIndices(layers, 0, pointCount)
502
+ ];
503
+ for (const index of priorityIndices) {
504
+ if (index !== undefined && retainedIndices.size < maximumFiniteSamples) {
505
+ retainedIndices.add(index);
506
+ }
507
+ }
508
+ const extremaPerBucket = Math.max(1, layers.length * 2);
509
+ const bucketCount = Math.floor((maximumFiniteSamples - retainedIndices.size) / extremaPerBucket);
510
+ for (let bucketIndex = 0;bucketIndex < bucketCount; bucketIndex++) {
511
+ const startIndex = Math.floor(bucketIndex * pointCount / bucketCount);
512
+ const endIndex = Math.floor((bucketIndex + 1) * pointCount / bucketCount);
513
+ for (const index of layerExtremaIndices(layers, startIndex, endIndex)) {
514
+ if (retainedIndices.size < maximumFiniteSamples)
515
+ retainedIndices.add(index);
516
+ }
517
+ }
518
+ const remainingCapacity = maximumFiniteSamples - retainedIndices.size;
519
+ if (remainingCapacity > 0) {
520
+ const coverageCandidates = finiteIndices.filter((index) => !retainedIndices.has(index));
521
+ for (const index of evenlySample(coverageCandidates, remainingCapacity)) {
522
+ retainedIndices.add(index);
523
+ }
524
+ }
525
+ const sampledIndices = [...retainedIndices].sort((a, b) => a - b);
526
+ const selectedSourceIndices = [];
527
+ sampledIndices.forEach((sourceIndex, selectionIndex) => {
528
+ const previousSourceIndex = sampledIndices[selectionIndex - 1];
529
+ if (previousSourceIndex !== undefined && sourceIndex > previousSourceIndex + 1) {
530
+ if (layers.some((layer) => layerHasOmittedGap(layer, previousSourceIndex, sourceIndex))) {
531
+ selectedSourceIndices.push(previousSourceIndex + Math.floor((sourceIndex - previousSourceIndex) / 2));
190
532
  }
191
533
  }
534
+ selectedSourceIndices.push(sourceIndex);
535
+ });
536
+ return selectedSourceIndices.map((sourceIndex, selectionIndex) => {
537
+ const previousSourceIndex = selectedSourceIndices[selectionIndex - 1];
538
+ const forceGapLayerIndices = [];
539
+ if (previousSourceIndex !== undefined && sourceIndex > previousSourceIndex + 1) {
540
+ layers.forEach((layer, layerIndex) => {
541
+ if (layerHasOmittedGap(layer, previousSourceIndex, sourceIndex)) {
542
+ forceGapLayerIndices.push(layerIndex);
543
+ }
544
+ });
545
+ }
546
+ return { sourceIndex, forceGapLayerIndices };
547
+ });
548
+ }
549
+ function layerHasOmittedGap(layer, startIndex, endIndex) {
550
+ if (layer[startIndex] == null || layer[endIndex] == null)
551
+ return false;
552
+ for (let gapIndex = startIndex + 1;gapIndex < endIndex; gapIndex++) {
553
+ if (layer[gapIndex] == null)
554
+ return true;
192
555
  }
193
- const sortedXValues = sortXValues([...xValuesByKey.values()]);
194
- const orderByKey = new Map(sortedXValues.map((value, index) => [value.key, index]));
195
- const visibleNumericValues = [];
196
- for (const item of normalizedSeries) {
197
- if (hiddenSeriesIds.includes(item.id))
556
+ return false;
557
+ }
558
+ function addGapBoundaryIndices(selected, pointCount, valueAt) {
559
+ for (let index = 1;index < pointCount; index++) {
560
+ const previousIsNull = valueAt(index - 1) == null;
561
+ const currentIsNull = valueAt(index) == null;
562
+ if (previousIsNull === currentIsNull)
198
563
  continue;
199
- for (const point of item.points) {
200
- if (point.y !== null)
201
- visibleNumericValues.push(point.y);
202
- }
564
+ selected.add(index - 1);
565
+ selected.add(index);
203
566
  }
204
- const stackedTotalsByKey = new Map(sortedXValues.map((value) => [value.key, 0]));
205
- if (stackedArea) {
206
- for (const item of normalizedSeries) {
207
- if (hiddenSeriesIds.includes(item.id))
567
+ }
568
+ function decimationIndices(points, maximumPoints = MAXIMUM_RENDERED_SERIES_POINTS) {
569
+ if (points.length <= maximumPoints || maximumPoints < 2) {
570
+ return points.map((_, index) => index);
571
+ }
572
+ const limit = Math.max(2, Math.floor(maximumPoints));
573
+ const interiorLength = points.length - 2;
574
+ const selected = new Set([0, points.length - 1]);
575
+ addGapBoundaryIndices(selected, points.length, (index) => points[index]?.y);
576
+ const remainingExtremaBudget = limit - selected.size;
577
+ const bucketCount = Math.floor(remainingExtremaBudget / 2);
578
+ if (bucketCount < 1)
579
+ return boundedGapHeavyIndices(points, limit);
580
+ for (let bucketIndex = 0;bucketIndex < bucketCount; bucketIndex++) {
581
+ const start = 1 + Math.floor(bucketIndex * interiorLength / bucketCount);
582
+ const end = 1 + Math.floor((bucketIndex + 1) * interiorLength / bucketCount);
583
+ if (end <= start)
584
+ continue;
585
+ let minimumIndex;
586
+ let maximumIndex;
587
+ let minimumValue = Number.POSITIVE_INFINITY;
588
+ let maximumValue = Number.NEGATIVE_INFINITY;
589
+ for (let index = start;index < end; index++) {
590
+ const point = points[index];
591
+ if (!point)
208
592
  continue;
209
- for (const point of item.points) {
210
- if (point.y === null)
211
- continue;
212
- stackedTotalsByKey.set(point.x.key, (stackedTotalsByKey.get(point.x.key) ?? 0) + point.y);
593
+ if (point.y === null)
594
+ continue;
595
+ if (point.y < minimumValue) {
596
+ minimumValue = point.y;
597
+ minimumIndex = index;
598
+ }
599
+ if (point.y > maximumValue) {
600
+ maximumValue = point.y;
601
+ maximumIndex = index;
213
602
  }
214
603
  }
604
+ if (minimumIndex !== undefined)
605
+ selected.add(minimumIndex);
606
+ if (maximumIndex !== undefined)
607
+ selected.add(maximumIndex);
215
608
  }
216
- const domainValues = stackedArea ? [0, ...stackedTotalsByKey.values()] : visibleNumericValues;
217
- const [yMinimum, yMaximum] = createPaddedDomain(domainValues);
218
- const xStringScale = sortedXValues[0]?.kind === "string" ? createPointScale(sortedXValues.map((value) => value.key), [0, geometry.plotWidth], 0.5) : undefined;
219
- const xNumericScale = sortedXValues[0] && sortedXValues[0].kind !== "string" ? createLinearScale(createNumericDomain(sortedXValues), [0, geometry.plotWidth]) : undefined;
220
- const yScale = createLinearScale([yMinimum, yMaximum], [geometry.plotHeight, 0]);
221
- function scaleX(value) {
222
- if (value.kind === "string")
223
- return xStringScale?.(value.key) ?? 0;
224
- return xNumericScale?.(Number(value.comparable)) ?? 0;
225
- }
226
- const tickCount = xAxis?.tickCount ?? sortedXValues.length;
227
- const xTicks = buildXAxisTicks(sortedXValues, tickCount, xAxis, scaleX);
228
- const targets = [];
229
- const tableRows = [];
230
- const stackedOffsetsByKey = new Map(sortedXValues.map((value) => [value.key, 0]));
231
- const renderedSeries = normalizedSeries.map((item) => {
232
- const hidden = hiddenSeriesIds.includes(item.id);
233
- const points = item.points.filter((point) => point.y !== null).toSorted((a, b) => (orderByKey.get(a.x.key) ?? 0) - (orderByKey.get(b.x.key) ?? 0));
234
- const placedPoints = points.map((point) => {
235
- const lowerValue = stackedArea ? stackedOffsetsByKey.get(point.x.key) ?? 0 : 0;
236
- const upperValue = lowerValue + (point.y ?? 0);
237
- return {
238
- ...point,
239
- pixelX: scaleX(point.x),
240
- pixelY: yScale(stackedArea ? upperValue : point.y ?? 0)
241
- };
242
- });
243
- const coordinates = placedPoints.map((placed) => ({
244
- x: placed.pixelX,
245
- y: placed.pixelY,
246
- y0: yScale(stackedArea ? stackedOffsetsByKey.get(placed.x.key) ?? 0 : 0)
609
+ return [...selected].sort((a, b) => a - b);
610
+ }
611
+ function decimationIndicesForLayers(layers, maximumPoints = MAXIMUM_RENDERED_SERIES_POINTS) {
612
+ const pointCount = layers[0]?.length ?? 0;
613
+ if (pointCount <= maximumPoints || maximumPoints < 2) {
614
+ return Array.from({ length: pointCount }, (_, sourceIndex) => ({
615
+ sourceIndex,
616
+ forceGapLayerIndices: []
247
617
  }));
248
- if (!hidden) {
249
- for (const placed of placedPoints) {
250
- const xLabel = formatXValue(placed.x, xAxis, {
251
- seriesId: item.id,
252
- seriesLabel: item.label,
253
- index: placed.index
254
- });
255
- const valueLabel = formatNumericValue(placed.y ?? 0, yAxis, series.find((entry) => entry.id === item.id)?.valueFormatter, { seriesId: item.id, seriesLabel: item.label, index: placed.index });
256
- targets.push({
257
- id: `${item.id}-${placed.x.key}`,
258
- seriesId: item.id,
259
- seriesLabel: item.label,
260
- xLabel,
261
- valueLabel,
262
- x: placed.pixelX,
263
- y: placed.pixelY,
264
- color: item.color
265
- });
266
- tableRows.push({
267
- id: `${item.id}-${placed.x.key}`,
268
- seriesLabel: item.label,
269
- xLabel,
270
- valueLabel
271
- });
272
- }
273
- if (stackedArea) {
274
- for (const placed of placedPoints) {
275
- stackedOffsetsByKey.set(placed.x.key, (stackedOffsetsByKey.get(placed.x.key) ?? 0) + (placed.y ?? 0));
618
+ }
619
+ const limit = Math.max(2, Math.floor(maximumPoints));
620
+ const interiorLength = pointCount - 2;
621
+ const selected = new Set([0, pointCount - 1]);
622
+ for (const layer of layers) {
623
+ addGapBoundaryIndices(selected, pointCount, (index) => layer[index]);
624
+ }
625
+ const candidatesPerBucket = Math.max(1, layers.length * 2);
626
+ const bucketCount = Math.floor((limit - selected.size) / candidatesPerBucket);
627
+ if (bucketCount < 1)
628
+ return boundedGapHeavyLayerSelections(layers, pointCount, limit);
629
+ for (let bucketIndex = 0;bucketIndex < bucketCount; bucketIndex++) {
630
+ const start = 1 + Math.floor(bucketIndex * interiorLength / bucketCount);
631
+ const end = 1 + Math.floor((bucketIndex + 1) * interiorLength / bucketCount);
632
+ if (end <= start)
633
+ continue;
634
+ for (const layer of layers) {
635
+ let minimumIndex;
636
+ let maximumIndex;
637
+ let minimumValue = Number.POSITIVE_INFINITY;
638
+ let maximumValue = Number.NEGATIVE_INFINITY;
639
+ for (let index = start;index < end; index++) {
640
+ const value = layer[index];
641
+ if (value === null || value === undefined)
642
+ continue;
643
+ if (value < minimumValue) {
644
+ minimumValue = value;
645
+ minimumIndex = index;
646
+ }
647
+ if (value > maximumValue) {
648
+ maximumValue = value;
649
+ maximumIndex = index;
276
650
  }
277
651
  }
652
+ if (minimumIndex !== undefined)
653
+ selected.add(minimumIndex);
654
+ if (maximumIndex !== undefined)
655
+ selected.add(maximumIndex);
278
656
  }
279
- return {
280
- ...item,
281
- hidden,
282
- points: hidden ? [] : placedPoints,
283
- path: hidden ? "" : createLinePath(coordinates),
284
- areaPath: hidden ? "" : createAreaPath(coordinates, stackedArea ? undefined : geometry.plotHeight)
285
- };
657
+ }
658
+ return [...selected].sort((a, b) => a - b).map((sourceIndex) => ({ sourceIndex, forceGapLayerIndices: [] }));
659
+ }
660
+ function decimatePlacedPoints(points, maximumPoints = MAXIMUM_RENDERED_SERIES_POINTS) {
661
+ return decimationIndices(points, maximumPoints).map((index) => points[index]);
662
+ }
663
+ function normalizeNumericValue(componentId, seriesId, xLabel, value) {
664
+ if (value === null || value === undefined)
665
+ return null;
666
+ if (!Number.isFinite(value)) {
667
+ throw new Error(`[cinder/${componentId}] rule=non-finite-y series="${seriesId}" x="${xLabel}": y values must be finite numbers.`);
668
+ }
669
+ return value;
670
+ }
671
+ function sortXValues(values) {
672
+ if (values[0]?.kind === "string")
673
+ return values;
674
+ return values.slice().sort((a, b) => Number(a.comparable) - Number(b.comparable));
675
+ }
676
+ function createPaddedDomain(values) {
677
+ if (values.length === 0)
678
+ return [-1, 1];
679
+ let minimum = values[0];
680
+ let maximum = values[0];
681
+ for (let index = 1;index < values.length; index++) {
682
+ const value = values[index];
683
+ if (value < minimum)
684
+ minimum = value;
685
+ if (value > maximum)
686
+ maximum = value;
687
+ }
688
+ if (minimum === maximum)
689
+ return [minimum - 1, maximum + 1];
690
+ return [Math.min(0, minimum), Math.max(0, maximum)];
691
+ }
692
+ function createLinearScale(domain, range) {
693
+ const [domainMinimum, domainMaximum] = domain[0] === domain[1] ? [domain[0] - 1, domain[1] + 1] : domain;
694
+ const [rangeMinimum, rangeMaximum] = range;
695
+ const domainSpan = domainMaximum - domainMinimum;
696
+ const rangeSpan = rangeMaximum - rangeMinimum;
697
+ const scale = Object.assign((value) => rangeMinimum + (value - domainMinimum) / domainSpan * rangeSpan, {
698
+ ticks: (count) => createTicks([domainMinimum, domainMaximum], count)
286
699
  });
287
- targets.sort((a, b) => a.x - b.x);
288
- return {
289
- geometry,
290
- xTicks,
291
- yTicks: yScale.ticks(yAxis?.tickCount ?? 5),
292
- normalizedSeries: renderedSeries,
293
- tableRows,
294
- targets,
295
- empty: targets.length === 0,
296
- yDomain: [yMinimum, yMaximum]
297
- };
700
+ return scale;
298
701
  }
299
- function buildXAxisTicks(sortedXValues, tickCount, xAxis, scaleX) {
300
- if (sortedXValues.length === 0)
301
- return [];
302
- const safeTickCount = Math.max(1, Math.min(tickCount, sortedXValues.length));
303
- if (safeTickCount >= sortedXValues.length) {
304
- return sortedXValues.map((value, index) => ({
305
- label: formatXValue(value, xAxis, { index }),
306
- x: scaleX(value)
307
- }));
702
+ function createPointScale(domain, range, padding) {
703
+ const positions = new Map;
704
+ const [rangeMinimum, rangeMaximum] = range;
705
+ if (domain.length === 1) {
706
+ positions.set(domain[0] ?? "", rangeMinimum + (rangeMaximum - rangeMinimum) / 2);
707
+ } else {
708
+ const step = (rangeMaximum - rangeMinimum) / Math.max(1, domain.length - 1 + padding * 2);
709
+ const start = rangeMinimum + step * padding;
710
+ domain.forEach((value, index) => positions.set(value, start + step * index));
308
711
  }
309
- if (safeTickCount === 1) {
310
- const value = sortedXValues[0];
311
- return value ? [{ label: formatXValue(value, xAxis, { index: 0 }), x: scaleX(value) }] : [];
712
+ return (value) => positions.get(value);
713
+ }
714
+ function createBandScale(domain, range, padding) {
715
+ const positions = new Map;
716
+ const [rangeMinimum, rangeMaximum] = range;
717
+ const availableSize = Math.max(0, rangeMaximum - rangeMinimum);
718
+ const step = domain.length === 0 ? 0 : availableSize / Math.max(1, domain.length + padding * (domain.length - 1));
719
+ const bandWidth = Math.max(0, step * (1 - padding));
720
+ domain.forEach((value, index) => positions.set(value, rangeMinimum + step * index));
721
+ const scale = Object.assign((value) => positions.get(value), {
722
+ bandwidth: () => bandWidth
723
+ });
724
+ return scale;
725
+ }
726
+ function createNumericDomain(values) {
727
+ if (values.length === 0)
728
+ return [0, 1];
729
+ let minimum = Number(values[0].comparable);
730
+ let maximum = minimum;
731
+ for (let index = 1;index < values.length; index++) {
732
+ const numeric = Number(values[index].comparable);
733
+ if (numeric < minimum)
734
+ minimum = numeric;
735
+ if (numeric > maximum)
736
+ maximum = numeric;
312
737
  }
313
- const step = (sortedXValues.length - 1) / (safeTickCount - 1);
314
- const ticks = [];
315
- for (let i = 0;i < safeTickCount; i++) {
316
- const sourceIndex = Math.round(i * step);
317
- const value = sortedXValues[sourceIndex];
318
- if (!value)
738
+ return minimum === maximum ? [minimum - 1, maximum + 1] : [minimum, maximum];
739
+ }
740
+ function createTicks(domain, count) {
741
+ const safeCount = Math.max(1, Math.floor(count));
742
+ if (safeCount === 1)
743
+ return [domain[0]];
744
+ const step = (domain[1] - domain[0]) / (safeCount - 1);
745
+ return Array.from({ length: safeCount }, (_, index) => domain[0] + step * index);
746
+ }
747
+ function createLinePath(points) {
748
+ if (points.length === 0)
749
+ return "";
750
+ const commands = [];
751
+ for (const [index, point] of points.entries()) {
752
+ if (point.y === null)
319
753
  continue;
320
- ticks.push({
321
- label: formatXValue(value, xAxis, { index: i }),
322
- x: scaleX(value)
323
- });
754
+ const previous = points[index - 1];
755
+ commands.push(previous?.y === null || commands.length === 0 ? `M${formatPathNumber(point.x)},${formatPathNumber(point.y)}` : `L${formatPathNumber(point.x)},${formatPathNumber(point.y)}`);
324
756
  }
325
- return ticks;
757
+ return commands.join("");
758
+ }
759
+ function createAreaPath(points, baseline) {
760
+ const segments = [];
761
+ let segment = [];
762
+ for (const point of points) {
763
+ if (point.y === null) {
764
+ if (segment.length > 0)
765
+ segments.push(segment);
766
+ segment = [];
767
+ continue;
768
+ }
769
+ segment.push({ ...point, y: point.y });
770
+ }
771
+ if (segment.length > 0)
772
+ segments.push(segment);
773
+ return segments.map((visiblePoints) => {
774
+ const firstPoint = visiblePoints[0];
775
+ const lowerPoints = [];
776
+ for (let index = visiblePoints.length - 1;index >= 0; index--) {
777
+ const point = visiblePoints[index];
778
+ lowerPoints.push(`L${formatPathNumber(point.x)},${formatPathNumber(point.y0 ?? baseline ?? 0)}`);
779
+ }
780
+ return [
781
+ `M${formatPathNumber(firstPoint.x)},${formatPathNumber(firstPoint.y0 ?? baseline ?? 0)}`,
782
+ `L${formatPathNumber(firstPoint.x)},${formatPathNumber(firstPoint.y)}`,
783
+ ...visiblePoints.slice(1).map((point) => `L${formatPathNumber(point.x)},${formatPathNumber(point.y)}`),
784
+ ...lowerPoints,
785
+ "Z"
786
+ ].join("");
787
+ }).join("");
788
+ }
789
+ function createStackedBarDomainValues(datumByKey, categories, series) {
790
+ const values = [0];
791
+ for (const category of categories) {
792
+ const datum = datumByKey.get(category.key);
793
+ if (!datum)
794
+ continue;
795
+ let positiveTotal = 0;
796
+ let negativeTotal = 0;
797
+ for (const item of series) {
798
+ const value = datum[item.valueKey];
799
+ if (typeof value !== "number")
800
+ continue;
801
+ if (value >= 0)
802
+ positiveTotal += value;
803
+ else
804
+ negativeTotal += value;
805
+ }
806
+ values.push(positiveTotal, negativeTotal);
807
+ }
808
+ return values;
809
+ }
810
+ function formatPathNumber(value) {
811
+ return Number(value.toFixed(3)).toString();
326
812
  }
813
+
814
+ // src/_internal/chart/chart-bar-model.ts
327
815
  function createBarModel(options) {
328
816
  const {
329
817
  data,
@@ -335,12 +823,17 @@ function createBarModel(options) {
335
823
  orientation,
336
824
  mode,
337
825
  xAxis,
338
- yAxis
826
+ yAxis,
827
+ theme,
828
+ measureText = false,
829
+ measurementElement,
830
+ measurementVersion = 0
339
831
  } = options;
340
832
  assertUniqueSeriesIds("bar-chart", series);
341
833
  assertValidChartNumber("bar-chart", "invalid-height", height, "height");
342
834
  assertValidTickCount("bar-chart", xAxis);
343
835
  assertValidTickCount("bar-chart", yAxis);
836
+ const resolvedTheme = resolveChartTheme(theme);
344
837
  const categories = [];
345
838
  const seenCategories = new Set;
346
839
  const categoryKinds = new Set;
@@ -381,21 +874,37 @@ function createBarModel(options) {
381
874
  }
382
875
  const sortedCategories = sortXValues(categories);
383
876
  const categoryLabels = sortedCategories.map((category, index) => formatXValue(category, orientation === "vertical" ? xAxis : yAxis, { index }));
384
- const horizontalCategoryLabelLayout = orientation === "horizontal" ? createHorizontalCategoryLabelLayout(categoryLabels, width) : undefined;
385
- const geometry = createGeometry(width, height, horizontalCategoryLabelLayout?.marginLeft);
877
+ const horizontalCategoryLabelLayout = orientation === "horizontal" ? createHorizontalCategoryLabelLayout(categoryLabels, width, {
878
+ measureText,
879
+ measurementElement,
880
+ measurementVersion
881
+ }) : undefined;
386
882
  const valueDomain = createPaddedDomain(mode === "stacked" ? createStackedBarDomainValues(datumByKey, sortedCategories, visibleSeries) : visibleValues);
883
+ const valueTickAxis = orientation === "vertical" ? yAxis : xAxis;
884
+ const valueTicks = createTicks(valueDomain, valueTickAxis?.tickCount ?? 5);
885
+ const valueTickLabels = valueTicks.map((tick, index) => formatNumericValue(tick, valueTickAxis, undefined, { index }));
886
+ const geometry = createChartGeometry(width, height, {
887
+ xTickLabels: orientation === "vertical" ? categoryLabels : valueTickLabels,
888
+ yTickLabels: orientation === "vertical" ? valueTickLabels : categoryLabels,
889
+ xAxis,
890
+ yAxis,
891
+ measureText,
892
+ measurementElement,
893
+ measurementVersion,
894
+ marginLeft: horizontalCategoryLabelLayout?.marginLeft
895
+ });
387
896
  if (sortedCategories.length === 0) {
388
- const tickAxis = orientation === "vertical" ? yAxis : xAxis;
389
897
  return {
390
898
  geometry,
391
899
  categories: [],
392
- yTicks: createTicks(valueDomain, tickAxis?.tickCount ?? 5),
900
+ yTicks: valueTicks,
393
901
  categoryTicks: [],
394
902
  bars: [],
395
903
  tableRows: [],
396
904
  targets: [],
397
905
  empty: true,
398
- valueDomain
906
+ valueDomain,
907
+ theme: resolvedTheme
399
908
  };
400
909
  }
401
910
  const valueScale = createLinearScale(valueDomain, orientation === "vertical" ? [geometry.plotHeight, 0] : [0, geometry.plotWidth]);
@@ -427,7 +936,7 @@ function createBarModel(options) {
427
936
  return;
428
937
  const value = rawValue;
429
938
  const seriesColorIndex = Math.max(0, series.findIndex((entry) => entry.id === item.id));
430
- const color = item.color ?? chartPaletteColor(seriesColorIndex);
939
+ const color = item.color ?? chartPaletteColor(seriesColorIndex, resolvedTheme.palette);
431
940
  const categoryPosition = categoryScale(category.key) ?? 0;
432
941
  let x = 0;
433
942
  let y = 0;
@@ -498,258 +1007,333 @@ function createBarModel(options) {
498
1007
  values: rowValues
499
1008
  });
500
1009
  }
501
- }
502
- targets.sort((a, b) => orientation === "vertical" ? a.x - b.x : a.y - b.y);
1010
+ }
1011
+ targets.sort((a, b) => orientation === "vertical" ? a.x - b.x : a.y - b.y);
1012
+ return {
1013
+ geometry,
1014
+ categories: sortedCategories,
1015
+ yTicks: valueTicks,
1016
+ categoryTicks,
1017
+ bars,
1018
+ tableRows,
1019
+ targets,
1020
+ empty: targets.length === 0,
1021
+ valueDomain,
1022
+ theme: resolvedTheme
1023
+ };
1024
+ }
1025
+ // src/_internal/chart/chart-cartesian-model.ts
1026
+ var DEFAULT_MAXIMUM_X_TICK_COUNT = 8;
1027
+ function createCartesianModel(options) {
1028
+ const {
1029
+ componentId,
1030
+ series,
1031
+ hiddenSeriesIds,
1032
+ width,
1033
+ height,
1034
+ xAxis,
1035
+ yAxis,
1036
+ stackedArea = false,
1037
+ theme,
1038
+ measureText = false,
1039
+ measurementElement,
1040
+ measurementVersion = 0
1041
+ } = options;
1042
+ assertUniqueSeriesIds(componentId, series);
1043
+ assertValidChartNumber(componentId, "invalid-height", height, "height");
1044
+ assertValidTickCount(componentId, xAxis);
1045
+ assertValidTickCount(componentId, yAxis);
1046
+ const resolvedTheme = resolveChartTheme(theme);
1047
+ let geometry = createChartGeometry(width, height, {
1048
+ measureText,
1049
+ measurementElement,
1050
+ measurementVersion
1051
+ });
1052
+ const allKinds = new Set;
1053
+ const xValuesByKey = new Map;
1054
+ const normalizedSeries = series.map((item, seriesIndex) => {
1055
+ const seenX = new Set;
1056
+ const color = item.color ?? chartPaletteColor(seriesIndex, resolvedTheme.palette);
1057
+ const points = item.data.map((point, pointIndex) => {
1058
+ const x = normalizeXValue(point.x);
1059
+ allKinds.add(x.kind);
1060
+ if (seenX.has(x.key)) {
1061
+ throw new Error(`[cinder/${componentId}] rule=duplicate-x series="${item.id}" x="${x.label}": duplicate x values are not supported.`);
1062
+ }
1063
+ seenX.add(x.key);
1064
+ xValuesByKey.set(x.key, x);
1065
+ const y = normalizeNumericValue(componentId, item.id, x.label, point.y);
1066
+ return {
1067
+ seriesId: item.id,
1068
+ seriesLabel: item.label,
1069
+ color,
1070
+ x,
1071
+ y,
1072
+ originalY: point.y,
1073
+ index: pointIndex
1074
+ };
1075
+ });
1076
+ return { id: item.id, label: item.label, color, points };
1077
+ });
1078
+ if (allKinds.size > 1) {
1079
+ throw new Error(`[cinder/${componentId}] rule=mixed-x-domain-kind: all x values must share one domain kind.`);
1080
+ }
1081
+ if (stackedArea) {
1082
+ for (const item of normalizedSeries) {
1083
+ for (const point of item.points) {
1084
+ if ((point.y ?? 0) < 0) {
1085
+ throw new Error(`[cinder/${componentId}] rule=negative-stacked-area series="${item.id}" x="${point.x.label}": stacked areas do not support negative values.`);
1086
+ }
1087
+ }
1088
+ }
1089
+ }
1090
+ const sortedXValues = sortXValues([...xValuesByKey.values()]);
1091
+ const orderByKey = new Map(sortedXValues.map((value, index) => [value.key, index]));
1092
+ const visibleNumericValues = [];
1093
+ for (const item of normalizedSeries) {
1094
+ if (hiddenSeriesIds.includes(item.id))
1095
+ continue;
1096
+ for (const point of item.points) {
1097
+ if (point.y !== null)
1098
+ visibleNumericValues.push(point.y);
1099
+ }
1100
+ }
1101
+ const stackedTotalsByKey = new Map(sortedXValues.map((value) => [value.key, 0]));
1102
+ if (stackedArea) {
1103
+ for (const item of normalizedSeries) {
1104
+ if (hiddenSeriesIds.includes(item.id))
1105
+ continue;
1106
+ for (const point of item.points) {
1107
+ if (point.y === null)
1108
+ continue;
1109
+ stackedTotalsByKey.set(point.x.key, (stackedTotalsByKey.get(point.x.key) ?? 0) + point.y);
1110
+ }
1111
+ }
1112
+ }
1113
+ const domainValues = stackedArea || componentId === "area-chart" ? [0, ...stackedArea ? stackedTotalsByKey.values() : visibleNumericValues] : visibleNumericValues;
1114
+ const [yMinimum, yMaximum] = createPaddedDomain(domainValues);
1115
+ const tickCount = xAxis?.tickCount ?? Math.min(sortedXValues.length, DEFAULT_MAXIMUM_X_TICK_COUNT);
1116
+ const preliminaryXTicks = buildXAxisTicks(sortedXValues, tickCount, xAxis, () => 0);
1117
+ const yTicks = createTicks([yMinimum, yMaximum], yAxis?.tickCount ?? 5);
1118
+ geometry = createChartGeometry(width, height, {
1119
+ xTickLabels: preliminaryXTicks.map((tick) => tick.label),
1120
+ yTickLabels: yTicks.map((tick, index) => formatNumericValue(tick, yAxis, undefined, { index })),
1121
+ xAxis,
1122
+ yAxis,
1123
+ measureText,
1124
+ measurementElement,
1125
+ measurementVersion
1126
+ });
1127
+ const xStringScale = sortedXValues[0]?.kind === "string" ? createPointScale(sortedXValues.map((value) => value.key), [0, geometry.plotWidth], 0.5) : undefined;
1128
+ const xNumericScale = sortedXValues[0] && sortedXValues[0].kind !== "string" ? createLinearScale(createNumericDomain(sortedXValues), [0, geometry.plotWidth]) : undefined;
1129
+ const yScale = createLinearScale([yMinimum, yMaximum], [geometry.plotHeight, 0]);
1130
+ function scaleX(value) {
1131
+ if (value.kind === "string")
1132
+ return xStringScale?.(value.key) ?? 0;
1133
+ return xNumericScale?.(Number(value.comparable)) ?? 0;
1134
+ }
1135
+ const xTicks = buildXAxisTicks(sortedXValues, tickCount, xAxis, scaleX);
1136
+ const targets = [];
1137
+ const tableRows = [];
1138
+ const stackedOffsetsByKey = new Map(sortedXValues.map((value) => [value.key, 0]));
1139
+ const normalizedPointsBySeriesId = stackedArea ? new Map(normalizedSeries.map((item) => [
1140
+ item.id,
1141
+ new Map(item.points.map((point) => [point.x.key, point]))
1142
+ ])) : undefined;
1143
+ const stackedRenderXValues = stackedArea ? sortedXValues.filter((value) => normalizedSeries.some((item) => !hiddenSeriesIds.includes(item.id) && normalizedPointsBySeriesId?.get(item.id)?.has(value.key))) : undefined;
1144
+ const stackedRenderDomain = stackedRenderXValues ?? [];
1145
+ const stackedVisibleSeries = stackedArea ? normalizedSeries.filter((item) => !hiddenSeriesIds.includes(item.id)) : [];
1146
+ const stackedLayerIndexBySeriesId = new Map(stackedVisibleSeries.map((item, layerIndex) => [item.id, layerIndex]));
1147
+ const stackedBoundaryLayers = stackedArea ? (() => {
1148
+ const cumulativeValuesByKey = new Map(stackedRenderDomain.map((value) => [value.key, 0]));
1149
+ return stackedVisibleSeries.map((item) => stackedRenderDomain.map((value) => {
1150
+ const point = normalizedPointsBySeriesId?.get(item.id)?.get(value.key);
1151
+ if (point?.y === null || point?.y === undefined)
1152
+ return null;
1153
+ const cumulativeValue = (cumulativeValuesByKey.get(value.key) ?? 0) + point.y;
1154
+ cumulativeValuesByKey.set(value.key, cumulativeValue);
1155
+ return cumulativeValue;
1156
+ }));
1157
+ })() : undefined;
1158
+ const stackedRenderSelections = stackedBoundaryLayers ? decimationIndicesForLayers(stackedBoundaryLayers) : undefined;
1159
+ const renderedSeries = normalizedSeries.map((item) => {
1160
+ const hidden = hiddenSeriesIds.includes(item.id);
1161
+ const points = item.points.slice().sort((a, b) => (orderByKey.get(a.x.key) ?? 0) - (orderByKey.get(b.x.key) ?? 0));
1162
+ const placedPoints = points.map((point) => {
1163
+ const lowerValue = stackedArea ? stackedOffsetsByKey.get(point.x.key) ?? 0 : 0;
1164
+ const upperValue = lowerValue + (point.y ?? 0);
1165
+ return {
1166
+ ...point,
1167
+ pixelX: scaleX(point.x),
1168
+ pixelY: yScale(stackedArea ? upperValue : point.y ?? 0),
1169
+ pixelY0: yScale(stackedArea ? lowerValue : 0)
1170
+ };
1171
+ });
1172
+ const placedPointsByKey = stackedRenderSelections ? new Map(placedPoints.map((point) => [point.x.key, point])) : undefined;
1173
+ const renderPoints = stackedRenderSelections ? stackedRenderSelections.map(({ sourceIndex, forceGapLayerIndices }) => {
1174
+ const x = stackedRenderDomain[sourceIndex];
1175
+ const layerIndex = stackedLayerIndexBySeriesId.get(item.id);
1176
+ const forceGap = layerIndex !== undefined && forceGapLayerIndices.includes(layerIndex);
1177
+ if (!forceGap) {
1178
+ const placedPoint = placedPointsByKey?.get(x.key);
1179
+ if (placedPoint)
1180
+ return placedPoint;
1181
+ }
1182
+ return {
1183
+ seriesId: item.id,
1184
+ seriesLabel: item.label,
1185
+ color: item.color,
1186
+ x,
1187
+ y: null,
1188
+ originalY: null,
1189
+ index: -1,
1190
+ pixelX: scaleX(x),
1191
+ pixelY: 0,
1192
+ pixelY0: stackedArea ? yScale(stackedOffsetsByKey.get(x.key) ?? 0) : yScale(0)
1193
+ };
1194
+ }) : decimatePlacedPoints(placedPoints);
1195
+ const coordinates = renderPoints.map((placed) => ({
1196
+ x: placed.pixelX,
1197
+ y: placed.y === null ? null : placed.pixelY,
1198
+ y0: placed.pixelY0
1199
+ }));
1200
+ if (!hidden) {
1201
+ for (const placed of placedPoints) {
1202
+ if (placed.y === null)
1203
+ continue;
1204
+ const xLabel = formatXValue(placed.x, xAxis, {
1205
+ seriesId: item.id,
1206
+ seriesLabel: item.label,
1207
+ index: placed.index
1208
+ });
1209
+ const valueLabel = formatNumericValue(placed.y ?? 0, yAxis, series.find((entry) => entry.id === item.id)?.valueFormatter, { seriesId: item.id, seriesLabel: item.label, index: placed.index });
1210
+ targets.push({
1211
+ id: `${item.id}-${placed.x.key}`,
1212
+ seriesId: item.id,
1213
+ seriesLabel: item.label,
1214
+ xLabel,
1215
+ valueLabel,
1216
+ x: placed.pixelX,
1217
+ y: placed.pixelY,
1218
+ color: item.color
1219
+ });
1220
+ tableRows.push({
1221
+ id: `${item.id}-${placed.x.key}`,
1222
+ seriesId: item.id,
1223
+ seriesLabel: item.label,
1224
+ xLabel,
1225
+ valueLabel
1226
+ });
1227
+ }
1228
+ if (stackedArea) {
1229
+ for (const placed of placedPoints) {
1230
+ stackedOffsetsByKey.set(placed.x.key, (stackedOffsetsByKey.get(placed.x.key) ?? 0) + (placed.y ?? 0));
1231
+ }
1232
+ }
1233
+ }
1234
+ return {
1235
+ ...item,
1236
+ hidden,
1237
+ points: hidden ? [] : renderPoints,
1238
+ path: hidden ? "" : createLinePath(coordinates),
1239
+ areaPath: hidden ? "" : createAreaPath(coordinates, stackedArea ? undefined : geometry.plotHeight)
1240
+ };
1241
+ });
1242
+ targets.sort((a, b) => a.x - b.x);
503
1243
  return {
504
1244
  geometry,
505
- categories: sortedCategories,
506
- yTicks: valueScale.ticks((orientation === "vertical" ? yAxis : xAxis)?.tickCount ?? 5),
507
- categoryTicks,
508
- bars,
509
- tableRows,
1245
+ xTicks,
1246
+ yTicks,
1247
+ normalizedSeries: renderedSeries,
1248
+ tableRows: evenlySampleTableRows(tableRows, MAXIMUM_RENDERED_SERIES_POINTS),
510
1249
  targets,
511
1250
  empty: targets.length === 0,
512
- valueDomain
1251
+ yDomain: [yMinimum, yMaximum],
1252
+ theme: resolvedTheme,
1253
+ marks: series.map((item) => ({
1254
+ seriesId: item.id,
1255
+ descriptors: componentId === "line-chart" ? [
1256
+ { type: "line", data: item.data },
1257
+ { type: "point", data: item.data }
1258
+ ] : [
1259
+ { type: "area", data: item.data },
1260
+ { type: "line", data: item.data }
1261
+ ]
1262
+ }))
513
1263
  };
514
1264
  }
515
- function nearestTarget(targets, x, y, axis = "x") {
516
- if (targets.length === 0)
517
- return;
518
- if (targets.length === 1)
519
- return targets[0];
520
- const pointerKey = axis === "x" ? x : y;
521
- let low = 0;
522
- let high = targets.length - 1;
523
- while (low < high) {
524
- const mid = low + high >> 1;
525
- const midKey = axis === "x" ? targets[mid]?.x ?? 0 : targets[mid]?.y ?? 0;
526
- if (midKey < pointerKey)
527
- low = mid + 1;
1265
+ function evenlySampleTableRows(rows, maximumRows) {
1266
+ if (rows.length <= maximumRows)
1267
+ return rows;
1268
+ if (maximumRows <= 0)
1269
+ return [];
1270
+ const rowsBySeriesId = new Map;
1271
+ for (const row of rows) {
1272
+ const seriesRows = rowsBySeriesId.get(row.seriesId);
1273
+ if (seriesRows)
1274
+ seriesRows.push(row);
528
1275
  else
529
- high = mid;
530
- }
531
- const candidates = [];
532
- function addBucket(start) {
533
- const target = targets[start];
534
- if (!target)
535
- return;
536
- const bucketKey = axis === "x" ? target.x : target.y;
537
- for (let index = start;index >= 0; index--) {
538
- const candidate = targets[index];
539
- if (!candidate)
540
- continue;
541
- const candidateKey = axis === "x" ? candidate.x : candidate.y;
542
- if (candidateKey !== bucketKey)
543
- break;
544
- candidates.push(candidate);
545
- }
546
- for (let index = start + 1;index < targets.length; index++) {
547
- const candidate = targets[index];
548
- if (!candidate)
549
- continue;
550
- const candidateKey = axis === "x" ? candidate.x : candidate.y;
551
- if (candidateKey !== bucketKey)
552
- break;
553
- candidates.push(candidate);
554
- }
1276
+ rowsBySeriesId.set(row.seriesId, [row]);
555
1277
  }
556
- addBucket(low);
557
- if (low > 0) {
558
- addBucket(low - 1);
1278
+ const seriesGroups = [...rowsBySeriesId.values()];
1279
+ if (seriesGroups.length >= maximumRows) {
1280
+ return seriesGroups.slice(0, maximumRows).map((group) => group[0]);
559
1281
  }
560
- let nearest;
561
- let nearestDistance = Number.POSITIVE_INFINITY;
562
- for (const target of candidates) {
563
- const targetDistance = Math.hypot(target.x - x, target.y - y);
564
- if (targetDistance >= nearestDistance)
1282
+ const remainingRows = maximumRows - seriesGroups.length;
1283
+ const capacities = seriesGroups.map((group) => group.length - 1);
1284
+ const totalCapacity = capacities.reduce((total, capacity) => total + capacity, 0);
1285
+ const exactShares = capacities.map((capacity) => remainingRows * capacity / totalCapacity);
1286
+ const allocations = exactShares.map((share) => 1 + Math.floor(share));
1287
+ let undistributedRows = maximumRows - allocations.reduce((total, count) => total + count, 0);
1288
+ const allocationOrder = exactShares.map((share, index) => ({ index, remainder: share - Math.floor(share) })).sort((a, b) => b.remainder - a.remainder || a.index - b.index);
1289
+ for (const { index } of allocationOrder) {
1290
+ if (undistributedRows === 0)
1291
+ break;
1292
+ if (allocations[index] >= seriesGroups[index].length)
565
1293
  continue;
566
- nearest = target;
567
- nearestDistance = targetDistance;
568
- }
569
- return nearest;
570
- }
571
- function legendVisible(legendPosition, seriesCount) {
572
- return legendPosition !== "none" && seriesCount > 0;
573
- }
574
- var DEFAULT_CHART_MARGIN_LEFT = 48;
575
- var HORIZONTAL_CATEGORY_LABEL_CHARACTER_WIDTH = 12;
576
- var HORIZONTAL_CATEGORY_LABEL_GAP = 8;
577
- var HORIZONTAL_CATEGORY_LABEL_OUTER_PADDING = 8;
578
- var MAXIMUM_HORIZONTAL_CATEGORY_LABEL_FRACTION = 0.4;
579
- function createGeometry(width, height, marginLeft = DEFAULT_CHART_MARGIN_LEFT) {
580
- const marginTop = 16;
581
- const marginRight = 16;
582
- const marginBottom = 36;
583
- return {
584
- plotWidth: Math.max(1, width - marginLeft - marginRight),
585
- plotHeight: Math.max(1, height - marginTop - marginBottom),
586
- marginTop,
587
- marginRight,
588
- marginBottom,
589
- marginLeft
590
- };
591
- }
592
- function createHorizontalCategoryLabelLayout(labels, chartWidth) {
593
- const maximumMarginLeft = Math.max(DEFAULT_CHART_MARGIN_LEFT, Math.floor(chartWidth * MAXIMUM_HORIZONTAL_CATEGORY_LABEL_FRACTION));
594
- let longestLabelWidth = 0;
595
- for (const label of labels) {
596
- longestLabelWidth = Math.max(longestLabelWidth, estimateHorizontalCategoryLabelWidth(label));
597
- }
598
- const requestedMarginLeft = longestLabelWidth + HORIZONTAL_CATEGORY_LABEL_GAP + HORIZONTAL_CATEGORY_LABEL_OUTER_PADDING;
599
- const marginLeft = Math.min(maximumMarginLeft, Math.max(DEFAULT_CHART_MARGIN_LEFT, requestedMarginLeft));
600
- const availableLabelWidth = Math.max(0, marginLeft - HORIZONTAL_CATEGORY_LABEL_GAP - HORIZONTAL_CATEGORY_LABEL_OUTER_PADDING);
601
- return {
602
- marginLeft,
603
- labels: labels.map((label) => truncateHorizontalCategoryLabel(label, availableLabelWidth))
604
- };
605
- }
606
- function estimateHorizontalCategoryLabelWidth(label) {
607
- return Array.from(label).length * HORIZONTAL_CATEGORY_LABEL_CHARACTER_WIDTH;
608
- }
609
- function truncateHorizontalCategoryLabel(label, availableWidth) {
610
- if (estimateHorizontalCategoryLabelWidth(label) <= availableWidth)
611
- return label;
612
- const availableCharacterCount = Math.floor(availableWidth / HORIZONTAL_CATEGORY_LABEL_CHARACTER_WIDTH);
613
- if (availableCharacterCount <= 0)
614
- return "";
615
- if (availableCharacterCount === 1)
616
- return "…";
617
- return `${Array.from(label).slice(0, availableCharacterCount - 1).join("")}…`;
618
- }
619
- function normalizeNumericValue(componentId, seriesId, xLabel, value) {
620
- if (value === null || value === undefined)
621
- return null;
622
- if (!Number.isFinite(value)) {
623
- throw new Error(`[cinder/${componentId}] rule=non-finite-y series="${seriesId}" x="${xLabel}": y values must be finite numbers.`);
624
- }
625
- return value;
626
- }
627
- function sortXValues(values) {
628
- if (values[0]?.kind === "string")
629
- return values;
630
- return [...values].toSorted((a, b) => Number(a.comparable) - Number(b.comparable));
631
- }
632
- function createPaddedDomain(values) {
633
- if (values.length === 0)
634
- return [-1, 1];
635
- let minimum = values[0];
636
- let maximum = values[0];
637
- for (let index = 1;index < values.length; index++) {
638
- const value = values[index];
639
- if (value < minimum)
640
- minimum = value;
641
- if (value > maximum)
642
- maximum = value;
1294
+ allocations[index] += 1;
1295
+ undistributedRows -= 1;
643
1296
  }
644
- if (minimum === maximum)
645
- return [minimum - 1, maximum + 1];
646
- return [Math.min(0, minimum), Math.max(0, maximum)];
1297
+ return seriesGroups.flatMap((group, index) => evenlySampleRows(group, allocations[index]));
647
1298
  }
648
- function createLinearScale(domain, range) {
649
- const [domainMinimum, domainMaximum] = domain[0] === domain[1] ? [domain[0] - 1, domain[1] + 1] : domain;
650
- const [rangeMinimum, rangeMaximum] = range;
651
- const domainSpan = domainMaximum - domainMinimum;
652
- const rangeSpan = rangeMaximum - rangeMinimum;
653
- const scale = Object.assign((value) => rangeMinimum + (value - domainMinimum) / domainSpan * rangeSpan, {
654
- ticks: (count) => createTicks([domainMinimum, domainMaximum], count)
1299
+ function evenlySampleRows(rows, requestedRows) {
1300
+ if (rows.length <= requestedRows)
1301
+ return rows;
1302
+ if (requestedRows <= 1)
1303
+ return rows[0] === undefined ? [] : [rows[0]];
1304
+ return Array.from({ length: requestedRows }, (_, index) => {
1305
+ const sourceIndex = Math.round(index * (rows.length - 1) / (requestedRows - 1));
1306
+ return rows[sourceIndex];
655
1307
  });
656
- return scale;
657
1308
  }
658
- function createPointScale(domain, range, padding) {
659
- const positions = new Map;
660
- const [rangeMinimum, rangeMaximum] = range;
661
- if (domain.length === 1) {
662
- positions.set(domain[0] ?? "", rangeMinimum + (rangeMaximum - rangeMinimum) / 2);
663
- } else {
664
- const step = (rangeMaximum - rangeMinimum) / Math.max(1, domain.length - 1 + padding * 2);
665
- const start = rangeMinimum + step * padding;
666
- domain.forEach((value, index) => positions.set(value, start + step * index));
1309
+ function buildXAxisTicks(sortedXValues, tickCount, xAxis, scaleX) {
1310
+ if (sortedXValues.length === 0)
1311
+ return [];
1312
+ const safeTickCount = Math.max(1, Math.min(tickCount, sortedXValues.length));
1313
+ if (safeTickCount >= sortedXValues.length) {
1314
+ return sortedXValues.map((value, index) => ({
1315
+ label: formatXValue(value, xAxis, { index }),
1316
+ x: scaleX(value)
1317
+ }));
667
1318
  }
668
- return (value) => positions.get(value);
669
- }
670
- function createBandScale(domain, range, padding) {
671
- const positions = new Map;
672
- const [rangeMinimum, rangeMaximum] = range;
673
- const availableSize = Math.max(0, rangeMaximum - rangeMinimum);
674
- const step = domain.length === 0 ? 0 : availableSize / Math.max(1, domain.length + padding * (domain.length - 1));
675
- const bandWidth = Math.max(0, step * (1 - padding));
676
- domain.forEach((value, index) => positions.set(value, rangeMinimum + step * index));
677
- const scale = Object.assign((value) => positions.get(value), {
678
- bandwidth: () => bandWidth
679
- });
680
- return scale;
681
- }
682
- function createNumericDomain(values) {
683
- if (values.length === 0)
684
- return [0, 1];
685
- let minimum = Number(values[0].comparable);
686
- let maximum = minimum;
687
- for (let index = 1;index < values.length; index++) {
688
- const numeric = Number(values[index].comparable);
689
- if (numeric < minimum)
690
- minimum = numeric;
691
- if (numeric > maximum)
692
- maximum = numeric;
1319
+ if (safeTickCount === 1) {
1320
+ const value = sortedXValues[0];
1321
+ return value ? [{ label: formatXValue(value, xAxis, { index: 0 }), x: scaleX(value) }] : [];
693
1322
  }
694
- return minimum === maximum ? [minimum - 1, maximum + 1] : [minimum, maximum];
695
- }
696
- function createTicks(domain, count) {
697
- const safeCount = Math.max(1, Math.floor(count));
698
- if (safeCount === 1)
699
- return [domain[0]];
700
- const step = (domain[1] - domain[0]) / (safeCount - 1);
701
- return Array.from({ length: safeCount }, (_, index) => domain[0] + step * index);
702
- }
703
- function createLinePath(points) {
704
- if (points.length === 0)
705
- return "";
706
- const [firstPoint, ...remainingPoints] = points;
707
- return [
708
- `M${formatPathNumber(firstPoint?.x ?? 0)},${formatPathNumber(firstPoint?.y ?? 0)}`,
709
- ...remainingPoints.map((point) => `L${formatPathNumber(point.x)},${formatPathNumber(point.y)}`)
710
- ].join("");
711
- }
712
- function createAreaPath(points, baseline) {
713
- if (points.length === 0)
714
- return "";
715
- const firstPoint = points[0];
716
- const lastPoint = points.at(-1);
717
- if (!firstPoint || !lastPoint)
718
- return "";
719
- const lowerPoints = points.toReversed().map((point) => `L${formatPathNumber(point.x)},${formatPathNumber(point.y0 ?? baseline ?? 0)}`);
720
- return [
721
- `M${formatPathNumber(firstPoint.x)},${formatPathNumber(firstPoint.y0 ?? baseline ?? 0)}`,
722
- `L${formatPathNumber(firstPoint.x)},${formatPathNumber(firstPoint.y)}`,
723
- ...points.slice(1).map((point) => `L${formatPathNumber(point.x)},${formatPathNumber(point.y)}`),
724
- ...lowerPoints,
725
- "Z"
726
- ].join("");
727
- }
728
- function createStackedBarDomainValues(datumByKey, categories, series) {
729
- const values = [0];
730
- for (const category of categories) {
731
- const datum = datumByKey.get(category.key);
732
- if (!datum)
1323
+ const step = (sortedXValues.length - 1) / (safeTickCount - 1);
1324
+ const ticks = [];
1325
+ for (let i = 0;i < safeTickCount; i++) {
1326
+ const sourceIndex = Math.round(i * step);
1327
+ const value = sortedXValues[sourceIndex];
1328
+ if (!value)
733
1329
  continue;
734
- let positiveTotal = 0;
735
- let negativeTotal = 0;
736
- for (const item of series) {
737
- const value = datum[item.valueKey];
738
- if (typeof value !== "number")
739
- continue;
740
- if (value >= 0)
741
- positiveTotal += value;
742
- else
743
- negativeTotal += value;
744
- }
745
- values.push(positiveTotal, negativeTotal);
1330
+ ticks.push({
1331
+ label: formatXValue(value, xAxis, { index: sourceIndex }),
1332
+ x: scaleX(value)
1333
+ });
746
1334
  }
747
- return values;
748
- }
749
- function formatPathNumber(value) {
750
- return Number(value.toFixed(3)).toString();
1335
+ return ticks;
751
1336
  }
752
-
753
1337
  // src/_internal/chart/heatmap-utilities.ts
754
1338
  function toFiniteOrNull(value) {
755
1339
  return typeof value === "number" && Number.isFinite(value) ? value : null;
@@ -811,25 +1395,29 @@ function clamp01(value) {
811
1395
  return 1;
812
1396
  return value;
813
1397
  }
814
- function heatmapCellFill(value, domain, scale = "sequential") {
1398
+ function heatmapCellFill(value, domain, scale = "sequential", palette, background = "var(--cinder-surface-inset)") {
815
1399
  if (value === null)
816
- return "var(--cinder-surface-inset)";
1400
+ return background;
817
1401
  const normalized = normalizeHeatmapValue(value, domain, scale);
818
1402
  if (scale === "diverging") {
1403
+ const coolColor = chartPaletteColor(4, palette);
1404
+ let warmColor = chartPaletteColor(2, palette);
1405
+ if (palette && palette.length >= 2 && warmColor === coolColor) {
1406
+ warmColor = chartPaletteColor(1, palette);
1407
+ }
819
1408
  if (normalized < 0.5) {
820
1409
  const ratio2 = (0.5 - normalized) * 2;
821
- return `color-mix(in oklch, var(--cinder-chart-series-5) ${Math.round(ratio2 * 100)}%, var(--cinder-surface-inset))`;
1410
+ return `color-mix(in oklch, ${coolColor} ${Math.round(ratio2 * 100)}%, ${background})`;
822
1411
  }
823
1412
  const ratio = (normalized - 0.5) * 2;
824
- return `color-mix(in oklch, var(--cinder-chart-series-3) ${Math.round(ratio * 100)}%, var(--cinder-surface-inset))`;
1413
+ return `color-mix(in oklch, ${warmColor} ${Math.round(ratio * 100)}%, ${background})`;
825
1414
  }
826
- return `color-mix(in oklch, var(--cinder-chart-series-1) ${Math.round(normalized * 100)}%, var(--cinder-surface-inset))`;
1415
+ return `color-mix(in oklch, ${chartPaletteColor(0, palette)} ${Math.round(normalized * 100)}%, ${background})`;
827
1416
  }
828
- function heatmapLabelFill(value, domain, scale = "sequential") {
1417
+ function heatmapLabelFill(value, muted = "currentColor") {
829
1418
  if (value === null)
830
- return "var(--cinder-text-muted)";
831
- const intensity = scale === "diverging" ? Math.abs(normalizeHeatmapValue(value, domain, scale) - 0.5) * 2 : normalizeHeatmapValue(value, domain, scale);
832
- return intensity > 0.5 ? "var(--cinder-surface)" : "var(--cinder-text)";
1419
+ return muted;
1420
+ return "var(--cinder-text-inverse)";
833
1421
  }
834
1422
 
835
1423
  // src/utilities/class-names.ts
@@ -886,6 +1474,7 @@ var rest_excludes = new Set([
886
1474
  "height",
887
1475
  "loading",
888
1476
  "dataTableVisibility",
1477
+ "theme",
889
1478
  "dataTableCaption",
890
1479
  "class",
891
1480
  "empty",
@@ -910,29 +1499,44 @@ function Spectrogram($$anchor, $$props) {
910
1499
  let height = $2.prop($$props, "height", 3, 200), loading = $2.prop($$props, "loading", 3, false), dataTableVisibility = $2.prop($$props, "dataTableVisibility", 3, "screen-reader-only"), rest = $2.rest_props($$props, rest_excludes);
911
1500
  const rootId = $2.derived(() => $$props.id ?? generatedId);
912
1501
  const descriptionId = $2.derived(() => $$props.description ? `${$2.get(rootId)}-description` : undefined);
913
- const marginTop = 8;
914
- const marginRight = 16;
915
- const marginBottom = 32;
916
- const marginLeft = 60;
1502
+ const resolvedTheme = $2.derived(() => resolveChartTheme($$props.theme));
1503
+ let rootElement = $2.state(undefined);
1504
+ let measureText = $2.state(false);
1505
+ let measurementVersion = $2.state(0);
1506
+ onMount(() => {
1507
+ $2.set(measureText, true);
1508
+ return observeChartFontLoading(() => {
1509
+ $2.set(measurementVersion, $2.get(measurementVersion) + 1);
1510
+ });
1511
+ });
917
1512
  let measuredWidth = $2.state(400);
918
1513
  const observeResize = useResizeObserver((entries) => {
919
1514
  const entry = entries[0];
920
1515
  if (entry && entry.contentRect.width > 0)
921
1516
  $2.set(measuredWidth, entry.contentRect.width, true);
922
1517
  });
923
- const plotWidth = $2.derived(() => Math.max(1, $2.get(measuredWidth) - marginLeft - marginRight));
924
- const plotHeight = $2.derived(() => Math.max(1, height() - marginTop - marginBottom));
925
1518
  const binCount = $2.derived(() => $$props.frames.reduce((max, frame) => Math.max(max, frame.bins.length), 0));
926
- const binIndices = $2.derived(() => Array.from({ length: $2.get(binCount) }, (_, index2) => index2));
927
1519
  const isEmpty = $2.derived(() => $$props.frames.length === 0 || $2.get(binCount) === 0);
928
- const cellWidth = $2.derived(() => $$props.frames.length > 0 ? $2.get(plotWidth) / $$props.frames.length : 0);
929
- const cellHeight = $2.derived(() => $2.get(binCount) > 0 ? $2.get(plotHeight) / $2.get(binCount) : 0);
930
1520
  function binValueAt(frameIndex, binIndex) {
931
1521
  return toFiniteOrNull($$props.frames[frameIndex]?.bins[binIndex]);
932
1522
  }
1523
+ function plotBucketValue(frameIndex, frameSpan, binIndex, binSpan) {
1524
+ let maximum = null;
1525
+ for (let frameOffset = 0;frameOffset < frameSpan; frameOffset += 1) {
1526
+ const frame = $$props.frames[frameIndex + frameOffset];
1527
+ if (!frame)
1528
+ continue;
1529
+ for (let binOffset = 0;binOffset < binSpan; binOffset += 1) {
1530
+ const value = toFiniteOrNull(frame.bins[binIndex + binOffset]);
1531
+ if (value !== null && (maximum === null || value > maximum))
1532
+ maximum = value;
1533
+ }
1534
+ }
1535
+ return maximum;
1536
+ }
933
1537
  const domain = $2.derived(() => heatmapDomainOfRows($$props.frames.map((frame) => frame.bins)));
934
1538
  function cellFill(value) {
935
- return heatmapCellFill(value, $2.get(domain), "sequential");
1539
+ return heatmapCellFill(value, $2.get(domain), "sequential", $2.get(resolvedTheme).palette, $$props.theme?.background ?? "var(--cinder-surface-inset)");
936
1540
  }
937
1541
  function binY(binIndex) {
938
1542
  return $2.get(plotHeight) - (binIndex + 1) * $2.get(cellHeight);
@@ -940,15 +1544,43 @@ function Spectrogram($$anchor, $$props) {
940
1544
  const yLabels = $2.derived(() => Array.from({ length: $2.get(binCount) }, (_, index2) => $$props.frequencyLabels?.[index2] ?? String(index2)));
941
1545
  const maxYLabels = 8;
942
1546
  const yLabelStep = $2.derived(() => Math.max(1, Math.ceil($2.get(binCount) / maxYLabels)));
1547
+ const renderedYLabels = $2.derived(() => $2.get(yLabels).filter((_, index2) => index2 % $2.get(yLabelStep) === 0));
943
1548
  const maxXLabels = 10;
944
1549
  const xLabelStep = $2.derived(() => Math.max(1, Math.ceil($$props.frames.length / maxXLabels)));
1550
+ const renderedXLabels = $2.derived(() => $$props.frames.filter((_, index2) => index2 % $2.get(xLabelStep) === 0).map((frame) => frame.label));
1551
+ const geometry = $2.derived(() => createChartGeometry($2.get(measuredWidth), height(), {
1552
+ xTickLabels: $2.get(renderedXLabels),
1553
+ yTickLabels: $2.get(renderedYLabels),
1554
+ measureText: $2.get(measureText),
1555
+ measurementElement: $2.get(rootElement),
1556
+ measurementVersion: $2.get(measurementVersion)
1557
+ }));
1558
+ const plotWidth = $2.derived(() => $2.get(geometry).plotWidth), plotHeight = $2.derived(() => $2.get(geometry).plotHeight), marginTop = $2.derived(() => $2.get(geometry).marginTop), marginLeft = $2.derived(() => $2.get(geometry).marginLeft);
1559
+ const cellWidth = $2.derived(() => $$props.frames.length > 0 ? $2.get(plotWidth) / $$props.frames.length : 0);
1560
+ const cellHeight = $2.derived(() => $2.get(binCount) > 0 ? $2.get(plotHeight) / $2.get(binCount) : 0);
945
1561
  const hasDataTable = $2.derived(() => dataTableVisibility() !== "hidden");
946
1562
  const maxPlotFrames = 400;
947
1563
  const maxPlotBins = 256;
948
1564
  const plotFrameStep = $2.derived(() => Math.max(1, Math.ceil($$props.frames.length / maxPlotFrames)));
949
1565
  const plotBinStep = $2.derived(() => Math.max(1, Math.ceil($2.get(binCount) / maxPlotBins)));
950
- const plotFrames = $2.derived(() => $$props.frames.map((frame, frameIndex) => ({ frame, frameIndex })).filter((_, index2) => index2 % $2.get(plotFrameStep) === 0).slice(0, maxPlotFrames));
951
- const plotBinIndices = $2.derived(() => $2.get(binIndices).filter((index2) => index2 % $2.get(plotBinStep) === 0).slice(0, maxPlotBins));
1566
+ const plotFrames = $2.derived(() => Array.from({
1567
+ length: Math.min(maxPlotFrames, Math.ceil($$props.frames.length / $2.get(plotFrameStep)))
1568
+ }, (_, bucketIndex) => {
1569
+ const frameIndex = bucketIndex * $2.get(plotFrameStep);
1570
+ return {
1571
+ frameIndex,
1572
+ span: Math.min($2.get(plotFrameStep), $$props.frames.length - frameIndex)
1573
+ };
1574
+ }));
1575
+ const plotBins = $2.derived(() => Array.from({
1576
+ length: Math.min(maxPlotBins, Math.ceil($2.get(binCount) / $2.get(plotBinStep)))
1577
+ }, (_, bucketIndex) => {
1578
+ const binIndex = bucketIndex * $2.get(plotBinStep);
1579
+ return {
1580
+ binIndex,
1581
+ span: Math.min($2.get(plotBinStep), $2.get(binCount) - binIndex)
1582
+ };
1583
+ }));
952
1584
  const maxTableFrames = 10;
953
1585
  const maxTableBins = 10;
954
1586
  const tableFrameStep = $2.derived(() => Math.max(1, Math.ceil($$props.frames.length / maxTableFrames)));
@@ -968,7 +1600,13 @@ function Spectrogram($$anchor, $$props) {
968
1600
  id: $2.get(rootId),
969
1601
  class: $0,
970
1602
  "aria-label": $$props.label,
971
- "aria-describedby": $2.get(descriptionId)
1603
+ "aria-describedby": $2.get(descriptionId),
1604
+ [$2.STYLE]: {
1605
+ "--_cinder-chart-foreground": $2.get(resolvedTheme).foreground,
1606
+ "--_cinder-chart-muted": $2.get(resolvedTheme).muted,
1607
+ "--_cinder-chart-grid": $2.get(resolvedTheme).grid,
1608
+ "--_cinder-chart-background": $2.get(resolvedTheme).background
1609
+ }
972
1610
  }), [() => classNames("cinder-spectrogram", $$props.class)]);
973
1611
  var node = $2.child(figure);
974
1612
  {
@@ -1068,22 +1706,21 @@ function Spectrogram($$anchor, $$props) {
1068
1706
  {
1069
1707
  var consequent_8 = ($$anchor2) => {
1070
1708
  var g = root_6();
1071
- $2.set_attribute(g, "transform", `translate(${marginLeft}, ${marginTop})`);
1072
1709
  var node_8 = $2.child(g);
1073
1710
  $2.each(node_8, 17, () => $2.get(plotFrames), (entry) => entry.frameIndex, ($$anchor3, entry) => {
1074
1711
  var fragment_2 = $2.comment();
1075
1712
  var node_9 = $2.first_child(fragment_2);
1076
- $2.each(node_9, 16, () => $2.get(plotBinIndices), (binIndex) => binIndex, ($$anchor4, binIndex) => {
1713
+ $2.each(node_9, 17, () => $2.get(plotBins), (bin) => bin.binIndex, ($$anchor4, bin) => {
1077
1714
  var rect = root_3();
1078
1715
  $2.template_effect(($0, $1) => {
1079
1716
  $2.set_attribute(rect, "x", $2.get(entry).frameIndex * $2.get(cellWidth));
1080
1717
  $2.set_attribute(rect, "y", $0);
1081
- $2.set_attribute(rect, "width", $2.get(cellWidth));
1082
- $2.set_attribute(rect, "height", $2.get(cellHeight));
1718
+ $2.set_attribute(rect, "width", $2.get(entry).span * $2.get(cellWidth));
1719
+ $2.set_attribute(rect, "height", $2.get(bin).span * $2.get(cellHeight));
1083
1720
  $2.set_attribute(rect, "fill", $1);
1084
1721
  }, [
1085
- () => binY(binIndex),
1086
- () => cellFill(binValueAt($2.get(entry).frameIndex, binIndex))
1722
+ () => binY($2.get(bin).binIndex + $2.get(bin).span - 1),
1723
+ () => cellFill(plotBucketValue($2.get(entry).frameIndex, $2.get(entry).span, $2.get(bin).binIndex, $2.get(bin).span))
1087
1724
  ]);
1088
1725
  $2.append($$anchor4, rect);
1089
1726
  });
@@ -1136,6 +1773,7 @@ function Spectrogram($$anchor, $$props) {
1136
1773
  $2.append($$anchor3, fragment_4);
1137
1774
  });
1138
1775
  $2.reset(g);
1776
+ $2.template_effect(() => $2.set_attribute(g, "transform", `translate(${$2.get(marginLeft)}, ${$2.get(marginTop)})`));
1139
1777
  $2.append($$anchor2, g);
1140
1778
  };
1141
1779
  $2.if(node_7, ($$render) => {
@@ -1199,6 +1837,7 @@ function Spectrogram($$anchor, $$props) {
1199
1837
  }
1200
1838
  $2.reset(figure);
1201
1839
  $2.attach(figure, () => observeResize);
1840
+ $2.bind_this(figure, ($$value) => $2.set(rootElement, $$value), () => $2.get(rootElement));
1202
1841
  $2.template_effect(() => {
1203
1842
  $2.set_attribute(div, "data-cinder-loading", loading() || undefined);
1204
1843
  styles = $2.set_style(div, "", styles, { height: `${height() ?? ""}px` });
@@ -1217,4 +1856,4 @@ export {
1217
1856
  Spectrogram
1218
1857
  };
1219
1858
 
1220
- //# debugId=1CF3BFDCAB900DFD64756E2164756E21
1859
+ //# debugId=1B78147CC54ADA4F64756E2164756E21