@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/matrix-chart/styles";
57
57
  // src/components/matrix-chart/matrix-chart.svelte
58
58
  import"svelte/internal/disclose-version";
59
59
  import * as $9 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("");
326
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();
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/components/_internal/chart-data-table.svelte
754
1338
  import"svelte/internal/disclose-version";
755
1339
  import * as $8 from "svelte/internal/client";
@@ -1685,25 +2269,29 @@ function clamp01(value) {
1685
2269
  return 1;
1686
2270
  return value;
1687
2271
  }
1688
- function heatmapCellFill(value, domain, scale = "sequential") {
2272
+ function heatmapCellFill(value, domain, scale = "sequential", palette, background = "var(--cinder-surface-inset)") {
1689
2273
  if (value === null)
1690
- return "var(--cinder-surface-inset)";
2274
+ return background;
1691
2275
  const normalized = normalizeHeatmapValue(value, domain, scale);
1692
2276
  if (scale === "diverging") {
2277
+ const coolColor = chartPaletteColor(4, palette);
2278
+ let warmColor = chartPaletteColor(2, palette);
2279
+ if (palette && palette.length >= 2 && warmColor === coolColor) {
2280
+ warmColor = chartPaletteColor(1, palette);
2281
+ }
1693
2282
  if (normalized < 0.5) {
1694
2283
  const ratio2 = (0.5 - normalized) * 2;
1695
- return `color-mix(in oklch, var(--cinder-chart-series-5) ${Math.round(ratio2 * 100)}%, var(--cinder-surface-inset))`;
2284
+ return `color-mix(in oklch, ${coolColor} ${Math.round(ratio2 * 100)}%, ${background})`;
1696
2285
  }
1697
2286
  const ratio = (normalized - 0.5) * 2;
1698
- return `color-mix(in oklch, var(--cinder-chart-series-3) ${Math.round(ratio * 100)}%, var(--cinder-surface-inset))`;
2287
+ return `color-mix(in oklch, ${warmColor} ${Math.round(ratio * 100)}%, ${background})`;
1699
2288
  }
1700
- return `color-mix(in oklch, var(--cinder-chart-series-1) ${Math.round(normalized * 100)}%, var(--cinder-surface-inset))`;
2289
+ return `color-mix(in oklch, ${chartPaletteColor(0, palette)} ${Math.round(normalized * 100)}%, ${background})`;
1701
2290
  }
1702
- function heatmapLabelFill(value, domain, scale = "sequential") {
2291
+ function heatmapLabelFill(value, muted = "currentColor") {
1703
2292
  if (value === null)
1704
- return "var(--cinder-text-muted)";
1705
- const intensity = scale === "diverging" ? Math.abs(normalizeHeatmapValue(value, domain, scale) - 0.5) * 2 : normalizeHeatmapValue(value, domain, scale);
1706
- return intensity > 0.5 ? "var(--cinder-surface)" : "var(--cinder-text)";
2293
+ return muted;
2294
+ return "var(--cinder-text-inverse)";
1707
2295
  }
1708
2296
 
1709
2297
  // src/components/matrix-chart/matrix-chart.svelte
@@ -1723,6 +2311,7 @@ var rest_excludes7 = new Set([
1723
2311
  "loading",
1724
2312
  "dataTableCaption",
1725
2313
  "dataTableVisibility",
2314
+ "theme",
1726
2315
  "class",
1727
2316
  "empty",
1728
2317
  "loadingContent",
@@ -1734,7 +2323,7 @@ var root_23 = $9.from_svg(`<title> </title>`);
1734
2323
  var root_32 = $9.from_svg(`<text class="cinder-matrix-chart__tick-label" text-anchor="middle" dominant-baseline="auto"> </text>`);
1735
2324
  var root_4 = $9.from_svg(`<text class="cinder-matrix-chart__tick-label" text-anchor="end" dominant-baseline="middle"> </text>`);
1736
2325
  var root_5 = $9.from_svg(`<text class="cinder-matrix-chart__cell-label" text-anchor="middle" dominant-baseline="middle" aria-hidden="true"> </text>`);
1737
- var root_6 = $9.from_svg(`<g><rect class="cinder-matrix-chart__cell" aria-hidden="true"><title> </title></rect><!></g>`);
2326
+ var root_6 = $9.from_svg(`<g class="cinder-matrix-chart__cell-group"><rect class="cinder-matrix-chart__cell" aria-hidden="true"><title> </title></rect><!></g>`);
1738
2327
  var root_7 = $9.from_svg(`<g role="presentation"><!><!><!></g>`);
1739
2328
  var root_8 = $9.from_html(`<figure><!> <div class="cinder-matrix-chart__viewport"><!> <svg role="img"><!><!></svg></div> <!></figure>`);
1740
2329
  function Matrix_chart($$anchor, $$props) {
@@ -1743,18 +2332,22 @@ function Matrix_chart($$anchor, $$props) {
1743
2332
  let colorScale = $9.prop($$props, "colorScale", 3, "sequential"), cellLabelsVisible = $9.prop($$props, "cellLabelsVisible", 3, true), height = $9.prop($$props, "height", 3, 280), loading = $9.prop($$props, "loading", 3, false), dataTableVisibility = $9.prop($$props, "dataTableVisibility", 3, "screen-reader-only"), rest = $9.rest_props($$props, rest_excludes7);
1744
2333
  const rootId = $9.derived(() => $$props.id ?? generatedId);
1745
2334
  const descriptionId = $9.derived(() => $$props.description ? `${$9.get(rootId)}-description` : undefined);
1746
- const marginTop = 40;
1747
- const marginRight = 16;
1748
- const marginBottom = 16;
1749
- const marginLeft = 80;
2335
+ const resolvedTheme = $9.derived(() => resolveChartTheme($$props.theme));
2336
+ let rootElement = $9.state(undefined);
2337
+ let measureText = $9.state(false);
2338
+ let measurementVersion = $9.state(0);
2339
+ onMount(() => {
2340
+ $9.set(measureText, true);
2341
+ return observeChartFontLoading(() => {
2342
+ $9.set(measurementVersion, $9.get(measurementVersion) + 1);
2343
+ });
2344
+ });
1750
2345
  let measuredWidth = $9.state(400);
1751
2346
  const observeResize = useResizeObserver((entries) => {
1752
2347
  const entry = entries[0];
1753
2348
  if (entry && entry.contentRect.width > 0)
1754
2349
  $9.set(measuredWidth, entry.contentRect.width, true);
1755
2350
  });
1756
- const plotWidth = $9.derived(() => Math.max(1, $9.get(measuredWidth) - marginLeft - marginRight));
1757
- const plotHeight = $9.derived(() => Math.max(1, height() - marginTop - marginBottom));
1758
2351
  const xLabels = $9.derived(() => {
1759
2352
  const seen = new Set;
1760
2353
  const result = [];
@@ -1785,6 +2378,15 @@ function Matrix_chart($$anchor, $$props) {
1785
2378
  }
1786
2379
  return result;
1787
2380
  });
2381
+ const geometry = $9.derived(() => createChartGeometry($9.get(measuredWidth), height(), {
2382
+ xTickLabels: $9.get(xLabels),
2383
+ yTickLabels: $9.get(yLabels),
2384
+ xTickPosition: "top",
2385
+ measureText: $9.get(measureText),
2386
+ measurementElement: $9.get(rootElement),
2387
+ measurementVersion: $9.get(measurementVersion)
2388
+ }));
2389
+ const plotWidth = $9.derived(() => $9.get(geometry).plotWidth), plotHeight = $9.derived(() => $9.get(geometry).plotHeight), marginTop = $9.derived(() => $9.get(geometry).marginTop), marginLeft = $9.derived(() => $9.get(geometry).marginLeft);
1788
2390
  const isEmpty = $9.derived(() => $9.get(xLabels).length === 0 || $9.get(yLabels).length === 0);
1789
2391
  const cellWidth = $9.derived(() => $9.get(xLabels).length > 0 ? $9.get(plotWidth) / $9.get(xLabels).length : 0);
1790
2392
  const cellHeight = $9.derived(() => $9.get(yLabels).length > 0 ? $9.get(plotHeight) / $9.get(yLabels).length : 0);
@@ -1831,7 +2433,7 @@ function Matrix_chart($$anchor, $$props) {
1831
2433
  });
1832
2434
  const domain = $9.derived(() => heatmapDomain($9.get(cells).map((cell) => cell.value)));
1833
2435
  function cellFill(value) {
1834
- return heatmapCellFill(value, $9.get(domain), colorScale());
2436
+ return heatmapCellFill(value, $9.get(domain), colorScale(), $9.get(resolvedTheme).palette, $$props.theme?.background ?? "var(--cinder-surface-inset)");
1835
2437
  }
1836
2438
  const numberFormatter = new Intl.NumberFormat(undefined, { maximumFractionDigits: 2 });
1837
2439
  function formatValue(value) {
@@ -1840,7 +2442,7 @@ function Matrix_chart($$anchor, $$props) {
1840
2442
  return numberFormatter.format(value);
1841
2443
  }
1842
2444
  function cellLabelFill(value) {
1843
- return heatmapLabelFill(value, $9.get(domain), colorScale());
2445
+ return heatmapLabelFill(value, $9.get(resolvedTheme).muted);
1844
2446
  }
1845
2447
  const hasDataTable = $9.derived(() => dataTableVisibility() !== "hidden");
1846
2448
  let hoveredCellKey = $9.state(null);
@@ -1863,7 +2465,13 @@ function Matrix_chart($$anchor, $$props) {
1863
2465
  class: $0,
1864
2466
  "aria-label": $$props.label,
1865
2467
  "aria-describedby": $9.get(descriptionId),
1866
- "data-cinder-color-scale": colorScale()
2468
+ "data-cinder-color-scale": colorScale(),
2469
+ [$9.STYLE]: {
2470
+ "--_cinder-chart-foreground": $9.get(resolvedTheme).foreground,
2471
+ "--_cinder-chart-muted": $9.get(resolvedTheme).muted,
2472
+ "--_cinder-chart-grid": $9.get(resolvedTheme).grid,
2473
+ "--_cinder-chart-background": $9.get(resolvedTheme).background
2474
+ }
1867
2475
  }), [() => classNames("cinder-matrix-chart", $$props.class)]);
1868
2476
  var node = $9.child(figure);
1869
2477
  {
@@ -1963,7 +2571,6 @@ function Matrix_chart($$anchor, $$props) {
1963
2571
  {
1964
2572
  var consequent_7 = ($$anchor2) => {
1965
2573
  var g = root_7();
1966
- $9.set_attribute(g, "transform", `translate(${marginLeft}, ${marginTop})`);
1967
2574
  var node_8 = $9.child(g);
1968
2575
  $9.each(node_8, 18, () => $9.get(xLabels), (xLabel) => xLabel, ($$anchor3, xLabel, index2) => {
1969
2576
  var text_4 = root_32();
@@ -2037,6 +2644,7 @@ function Matrix_chart($$anchor, $$props) {
2037
2644
  $9.append($$anchor3, g_1);
2038
2645
  });
2039
2646
  $9.reset(g);
2647
+ $9.template_effect(() => $9.set_attribute(g, "transform", `translate(${$9.get(marginLeft)}, ${$9.get(marginTop)})`));
2040
2648
  $9.event("pointerleave", g, handlePlotPointerLeave);
2041
2649
  $9.append($$anchor2, g);
2042
2650
  };
@@ -2082,6 +2690,7 @@ function Matrix_chart($$anchor, $$props) {
2082
2690
  }
2083
2691
  $9.reset(figure);
2084
2692
  $9.attach(figure, () => observeResize);
2693
+ $9.bind_this(figure, ($$value) => $9.set(rootElement, $$value), () => $9.get(rootElement));
2085
2694
  $9.template_effect(() => {
2086
2695
  $9.set_attribute(div, "data-cinder-loading", loading() || undefined);
2087
2696
  styles = $9.set_style(div, "", styles, { height: `${height() ?? ""}px` });
@@ -2100,4 +2709,4 @@ export {
2100
2709
  Matrix_chart as MatrixChart
2101
2710
  };
2102
2711
 
2103
- //# debugId=8211706671DB73FE64756E2164756E21
2712
+ //# debugId=C4368F8505F78E0164756E2164756E21