@lostgradient/cinder 0.22.0 → 0.23.1
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.
- package/CHANGELOG.md +63 -0
- package/components.json +1 -1
- package/dist/_internal/chart/chart-bar-model.d.ts +24 -0
- package/dist/_internal/chart/chart-cartesian-model.d.ts +16 -0
- package/dist/_internal/chart/chart-layout.d.ts +23 -0
- package/dist/_internal/chart/chart-model-utilities.d.ts +157 -0
- package/dist/_internal/chart/chart-scale.d.ts +37 -0
- package/dist/_internal/chart/chart-utilities.d.ts +7 -164
- package/dist/_internal/chart/heatmap-utilities.d.ts +5 -4
- package/dist/components/_internal/chart-tooltip.css +21 -0
- package/dist/components/_internal/chart-tooltip.svelte.d.ts +11 -0
- package/dist/components/approval-card/index.js +5 -5
- package/dist/components/area-chart/area-chart.css +27 -23
- package/dist/components/area-chart/area-chart.schema.js +38 -1
- package/dist/components/area-chart/area-chart.types.d.ts +6 -2
- package/dist/components/area-chart/index.js +1589 -768
- package/dist/components/badge/badge.css +2 -2
- package/dist/components/badge/badge.schema.js +2 -2
- package/dist/components/badge/badge.types.d.ts +3 -3
- package/dist/components/badge/index.js +4 -4
- package/dist/components/bar-chart/bar-chart.css +27 -21
- package/dist/components/bar-chart/bar-chart.schema.js +38 -1
- package/dist/components/bar-chart/bar-chart.types.d.ts +7 -3
- package/dist/components/bar-chart/index.js +1544 -740
- package/dist/components/chart.types.d.ts +98 -2
- package/dist/components/json-schema-editor/index.js +4 -4
- package/dist/components/line-chart/index.js +1587 -785
- package/dist/components/line-chart/line-chart.css +25 -24
- package/dist/components/line-chart/line-chart.schema.js +38 -1
- package/dist/components/line-chart/line-chart.types.d.ts +6 -2
- package/dist/components/matrix-chart/index.js +1038 -429
- package/dist/components/matrix-chart/matrix-chart.css +12 -6
- package/dist/components/matrix-chart/matrix-chart.schema.js +26 -1
- package/dist/components/matrix-chart/matrix-chart.types.d.ts +5 -1
- package/dist/components/payload-inspector/index.js +4 -4
- package/dist/components/run-step-timeline/index.js +6 -6
- package/dist/components/sparkbar/index.js +1291 -4
- package/dist/components/sparkbar/sparkbar.css +5 -4
- package/dist/components/sparkbar/sparkbar.schema.js +26 -1
- package/dist/components/sparkbar/sparkbar.types.d.ts +5 -0
- package/dist/components/spectrogram/index.js +1076 -437
- package/dist/components/spectrogram/spectrogram.css +7 -6
- package/dist/components/spectrogram/spectrogram.schema.js +26 -1
- package/dist/components/spectrogram/spectrogram.types.d.ts +5 -1
- package/dist/components/spectrum-chart/index.js +1037 -423
- package/dist/components/spectrum-chart/spectrum-chart.css +8 -7
- package/dist/components/spectrum-chart/spectrum-chart.schema.js +26 -1
- package/dist/components/spectrum-chart/spectrum-chart.types.d.ts +5 -1
- package/dist/components/statistic/index.js +1288 -2
- package/dist/components/statistic/statistic.css +6 -5
- package/dist/components/statistic/statistic.schema.js +26 -1
- package/dist/components/statistic/statistic.types.d.ts +5 -0
- package/dist/components/statistic-group/index.js +1288 -2
- package/dist/components/waveform/index.js +1004 -404
- package/dist/components/waveform/waveform.css +8 -7
- package/dist/components/waveform/waveform.schema.js +26 -1
- package/dist/components/waveform/waveform.types.d.ts +5 -1
- package/dist/index.d.ts +1 -1
- package/dist/index.js +17734 -16540
- package/dist/server/components/approval-card/index.js +3 -3
- package/dist/server/components/area-chart/index.js +3 -3
- package/dist/server/components/badge/index.js +2 -2
- package/dist/server/components/bar-chart/index.js +3 -3
- package/dist/server/components/json-schema-editor/index.js +2 -2
- package/dist/server/components/line-chart/index.js +3 -3
- package/dist/server/components/matrix-chart/index.js +3 -3
- package/dist/server/components/payload-inspector/index.js +3 -3
- package/dist/server/components/run-step-timeline/index.js +2 -2
- package/dist/server/components/sparkbar/index.js +3 -2
- package/dist/server/components/spectrogram/index.js +3 -3
- package/dist/server/components/spectrum-chart/index.js +2 -2
- package/dist/server/components/statistic/index.js +4 -3
- package/dist/server/components/statistic-group/index.js +4 -3
- package/dist/server/components/waveform/index.js +2 -2
- package/dist/server/index.js +21 -21
- package/dist/server/{index.server-3dkwzkd3.js → index.server-10r7yf13.js} +110 -27
- package/dist/server/{index.server-pp2n6def.js → index.server-2y0xz53g.js} +37 -14
- package/dist/server/{index.server-bd8rcgf0.js → index.server-4hvjet4z.js} +1 -1
- package/dist/server/{index.server-bsm39gpy.js → index.server-5d83fkyg.js} +75 -21
- package/dist/server/{index.server-abqbstkt.js → index.server-9gj583qs.js} +41 -14
- package/dist/server/{index.server-2nmwsacy.js → index.server-9scm7zf9.js} +4 -4
- package/dist/server/{index.server-5j6jv7rm.js → index.server-9vwxyy06.js} +108 -29
- package/dist/server/{index.server-abjsjsw8.js → index.server-afpjvfz1.js} +111 -35
- package/dist/server/{index.server-wm8957be.js → index.server-bp0vzxby.js} +14 -1
- package/dist/server/{index.server-86sw5ea6.js → index.server-dw9bz17h.js} +4 -4
- package/dist/server/{index.server-d26jzn2m.js → index.server-en31rprd.js} +3 -3
- package/dist/server/{index.server-dx58qant.js → index.server-f3a0ecqg.js} +72 -9
- package/dist/server/{index.server-d63pwytk.js → index.server-kz8aeeq5.js} +18 -10
- package/dist/server/index.server-mmmrgvyd.js +1274 -0
- package/dist/server/{index.server-93943z3e.js → index.server-rx9aszk6.js} +1 -1
- package/dist/server/{index.server-1221p7e4.js → index.server-scahngwv.js} +13 -1
- package/dist/server/{index.server-nj8kk5bv.js → index.server-t73q59c1.js} +1 -1
- package/dist/server/{index.server-5schb2vt.js → index.server-tdrncj5e.js} +16 -6
- package/dist/server/{index.server-4wweyb2e.js → index.server-vnr1h5g5.js} +1 -1
- package/dist/server/{index.server-fphvzcfb.js → index.server-wqajghn9.js} +1 -1
- package/dist/server/{index.server-yd9shwqq.js → index.server-zjcjzcv6.js} +1 -1
- package/package.json +1 -1
- package/src/_internal/chart/chart-bar-model.ts +330 -0
- package/src/_internal/chart/chart-cartesian-model.ts +450 -0
- package/src/_internal/chart/chart-interaction.svelte.ts +25 -6
- package/src/_internal/chart/chart-layout.ts +348 -0
- package/src/_internal/chart/chart-model-utilities.ts +357 -0
- package/src/_internal/chart/chart-scale.ts +487 -0
- package/src/_internal/chart/chart-utilities.ts +22 -1078
- package/src/_internal/chart/heatmap-utilities.ts +21 -17
- package/src/components/_internal/chart-tooltip.css +21 -0
- package/src/components/_internal/chart-tooltip.svelte +44 -0
- package/src/components/approval-card/approval-card.svelte +1 -1
- package/src/components/area-chart/area-chart.css +27 -23
- package/src/components/area-chart/area-chart.examples.json +1 -1
- package/src/components/area-chart/area-chart.schema.json +37 -0
- package/src/components/area-chart/area-chart.schema.ts +40 -0
- package/src/components/area-chart/area-chart.svelte +103 -35
- package/src/components/area-chart/area-chart.types.ts +7 -1
- package/src/components/badge/badge.css +2 -2
- package/src/components/badge/badge.schema.json +1 -1
- package/src/components/badge/badge.schema.ts +1 -1
- package/src/components/badge/badge.svelte +2 -2
- package/src/components/badge/badge.types.ts +3 -3
- package/src/components/bar-chart/bar-chart.css +27 -21
- package/src/components/bar-chart/bar-chart.schema.json +37 -0
- package/src/components/bar-chart/bar-chart.schema.ts +40 -0
- package/src/components/bar-chart/bar-chart.svelte +94 -33
- package/src/components/bar-chart/bar-chart.types.ts +9 -2
- package/src/components/chart.types.ts +112 -2
- package/src/components/line-chart/line-chart.css +25 -24
- package/src/components/line-chart/line-chart.examples.json +1 -1
- package/src/components/line-chart/line-chart.schema.json +37 -0
- package/src/components/line-chart/line-chart.schema.ts +40 -0
- package/src/components/line-chart/line-chart.svelte +95 -40
- package/src/components/line-chart/line-chart.types.ts +7 -1
- package/src/components/matrix-chart/matrix-chart.css +12 -6
- package/src/components/matrix-chart/matrix-chart.schema.json +25 -0
- package/src/components/matrix-chart/matrix-chart.schema.ts +25 -0
- package/src/components/matrix-chart/matrix-chart.svelte +30 -12
- package/src/components/matrix-chart/matrix-chart.types.ts +5 -1
- package/src/components/run-step-timeline/run-step-timeline.svelte +2 -2
- package/src/components/sparkbar/sparkbar.css +5 -4
- package/src/components/sparkbar/sparkbar.schema.json +25 -0
- package/src/components/sparkbar/sparkbar.schema.ts +26 -0
- package/src/components/sparkbar/sparkbar.svelte +8 -1
- package/src/components/sparkbar/sparkbar.types.ts +5 -0
- package/src/components/spectrogram/spectrogram.css +7 -6
- package/src/components/spectrogram/spectrogram.schema.json +25 -0
- package/src/components/spectrogram/spectrogram.schema.ts +25 -0
- package/src/components/spectrogram/spectrogram.svelte +73 -28
- package/src/components/spectrogram/spectrogram.types.ts +5 -1
- package/src/components/spectrum-chart/spectrum-chart.css +8 -7
- package/src/components/spectrum-chart/spectrum-chart.schema.json +25 -0
- package/src/components/spectrum-chart/spectrum-chart.schema.ts +26 -0
- package/src/components/spectrum-chart/spectrum-chart.svelte +38 -12
- package/src/components/spectrum-chart/spectrum-chart.types.ts +5 -1
- package/src/components/statistic/statistic.css +6 -5
- package/src/components/statistic/statistic.schema.json +25 -0
- package/src/components/statistic/statistic.schema.ts +26 -0
- package/src/components/statistic/statistic.svelte +42 -1
- package/src/components/statistic/statistic.types.ts +5 -0
- package/src/components/waveform/waveform.css +8 -7
- package/src/components/waveform/waveform.schema.json +25 -0
- package/src/components/waveform/waveform.schema.ts +26 -0
- package/src/components/waveform/waveform.svelte +16 -3
- package/src/components/waveform/waveform.types.ts +5 -1
- package/src/index.ts +8 -0
- 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-
|
|
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
|
-
|
|
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
|
|
140
|
-
|
|
141
|
-
|
|
142
|
-
|
|
143
|
-
|
|
144
|
-
|
|
145
|
-
|
|
146
|
-
|
|
147
|
-
|
|
148
|
-
|
|
149
|
-
|
|
150
|
-
|
|
151
|
-
|
|
152
|
-
|
|
153
|
-
|
|
154
|
-
|
|
155
|
-
const
|
|
156
|
-
|
|
157
|
-
|
|
158
|
-
|
|
159
|
-
|
|
160
|
-
const
|
|
161
|
-
|
|
162
|
-
|
|
163
|
-
if (
|
|
164
|
-
|
|
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
|
-
|
|
167
|
-
|
|
168
|
-
|
|
169
|
-
|
|
170
|
-
|
|
171
|
-
|
|
172
|
-
|
|
173
|
-
|
|
174
|
-
|
|
175
|
-
|
|
176
|
-
|
|
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
|
-
|
|
182
|
-
|
|
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
|
-
|
|
185
|
-
|
|
186
|
-
|
|
187
|
-
|
|
188
|
-
|
|
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
|
-
|
|
194
|
-
|
|
195
|
-
|
|
196
|
-
for (
|
|
197
|
-
|
|
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
|
-
|
|
200
|
-
|
|
201
|
-
visibleNumericValues.push(point.y);
|
|
202
|
-
}
|
|
564
|
+
selected.add(index - 1);
|
|
565
|
+
selected.add(index);
|
|
203
566
|
}
|
|
204
|
-
|
|
205
|
-
|
|
206
|
-
|
|
207
|
-
|
|
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
|
-
|
|
210
|
-
|
|
211
|
-
|
|
212
|
-
|
|
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
|
-
|
|
217
|
-
|
|
218
|
-
|
|
219
|
-
const
|
|
220
|
-
|
|
221
|
-
|
|
222
|
-
|
|
223
|
-
|
|
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
|
-
|
|
249
|
-
|
|
250
|
-
|
|
251
|
-
|
|
252
|
-
|
|
253
|
-
|
|
254
|
-
|
|
255
|
-
|
|
256
|
-
|
|
257
|
-
|
|
258
|
-
|
|
259
|
-
|
|
260
|
-
|
|
261
|
-
|
|
262
|
-
|
|
263
|
-
|
|
264
|
-
|
|
265
|
-
|
|
266
|
-
|
|
267
|
-
|
|
268
|
-
|
|
269
|
-
|
|
270
|
-
|
|
271
|
-
|
|
272
|
-
|
|
273
|
-
|
|
274
|
-
|
|
275
|
-
|
|
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
|
-
|
|
280
|
-
|
|
281
|
-
|
|
282
|
-
|
|
283
|
-
|
|
284
|
-
|
|
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
|
-
|
|
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
|
|
300
|
-
|
|
301
|
-
|
|
302
|
-
|
|
303
|
-
|
|
304
|
-
|
|
305
|
-
|
|
306
|
-
|
|
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
|
-
|
|
310
|
-
|
|
311
|
-
|
|
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
|
-
|
|
314
|
-
|
|
315
|
-
|
|
316
|
-
|
|
317
|
-
|
|
318
|
-
|
|
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
|
-
|
|
321
|
-
|
|
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
|
|
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
|
|
385
|
-
|
|
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:
|
|
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
|
-
|
|
506
|
-
yTicks
|
|
507
|
-
|
|
508
|
-
|
|
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
|
-
|
|
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
|
|
516
|
-
if (
|
|
517
|
-
return;
|
|
518
|
-
if (
|
|
519
|
-
return
|
|
520
|
-
const
|
|
521
|
-
|
|
522
|
-
|
|
523
|
-
|
|
524
|
-
|
|
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
|
-
|
|
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
|
-
|
|
557
|
-
if (
|
|
558
|
-
|
|
1278
|
+
const seriesGroups = [...rowsBySeriesId.values()];
|
|
1279
|
+
if (seriesGroups.length >= maximumRows) {
|
|
1280
|
+
return seriesGroups.slice(0, maximumRows).map((group) => group[0]);
|
|
559
1281
|
}
|
|
560
|
-
|
|
561
|
-
|
|
562
|
-
|
|
563
|
-
|
|
564
|
-
|
|
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
|
-
|
|
567
|
-
|
|
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
|
-
|
|
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
|
|
649
|
-
|
|
650
|
-
|
|
651
|
-
|
|
652
|
-
|
|
653
|
-
|
|
654
|
-
|
|
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
|
|
659
|
-
|
|
660
|
-
|
|
661
|
-
|
|
662
|
-
|
|
663
|
-
|
|
664
|
-
|
|
665
|
-
|
|
666
|
-
|
|
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
|
-
|
|
669
|
-
|
|
670
|
-
|
|
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
|
-
|
|
695
|
-
|
|
696
|
-
|
|
697
|
-
|
|
698
|
-
|
|
699
|
-
|
|
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
|
-
|
|
735
|
-
|
|
736
|
-
|
|
737
|
-
|
|
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
|
|
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
|
|
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,
|
|
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,
|
|
1413
|
+
return `color-mix(in oklch, ${warmColor} ${Math.round(ratio * 100)}%, ${background})`;
|
|
825
1414
|
}
|
|
826
|
-
return `color-mix(in oklch,
|
|
1415
|
+
return `color-mix(in oklch, ${chartPaletteColor(0, palette)} ${Math.round(normalized * 100)}%, ${background})`;
|
|
827
1416
|
}
|
|
828
|
-
function heatmapLabelFill(value,
|
|
1417
|
+
function heatmapLabelFill(value, muted = "currentColor") {
|
|
829
1418
|
if (value === null)
|
|
830
|
-
return
|
|
831
|
-
|
|
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
|
|
914
|
-
|
|
915
|
-
|
|
916
|
-
|
|
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(() =>
|
|
951
|
-
|
|
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,
|
|
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(
|
|
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=
|
|
1859
|
+
//# debugId=1B78147CC54ADA4F64756E2164756E21
|