@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/spectrum-chart/styles";
|
|
|
57
57
|
// src/components/spectrum-chart/spectrum-chart.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/utilities/class-names.ts
|
|
754
1338
|
function classNames(...parts) {
|
|
755
1339
|
return parts.filter((part) => typeof part === "string" && part.length > 0).join(" ");
|
|
@@ -804,6 +1388,7 @@ var rest_excludes = new Set([
|
|
|
804
1388
|
"loading",
|
|
805
1389
|
"dataTableVisibility",
|
|
806
1390
|
"dataTableCaption",
|
|
1391
|
+
"theme",
|
|
807
1392
|
"class",
|
|
808
1393
|
"empty",
|
|
809
1394
|
"loadingContent",
|
|
@@ -825,19 +1410,23 @@ function Spectrum_chart($$anchor, $$props) {
|
|
|
825
1410
|
let height = $2.prop($$props, "height", 3, 160), loading = $2.prop($$props, "loading", 3, false), dataTableVisibility = $2.prop($$props, "dataTableVisibility", 3, "screen-reader-only"), rest = $2.rest_props($$props, rest_excludes);
|
|
826
1411
|
const rootId = $2.derived(() => $$props.id ?? generatedId);
|
|
827
1412
|
const descriptionId = $2.derived(() => $$props.description ? `${$2.get(rootId)}-description` : undefined);
|
|
828
|
-
const marginTop = 8;
|
|
829
|
-
const marginRight = 8;
|
|
830
|
-
const marginBottom = 32;
|
|
831
|
-
const marginLeft = 40;
|
|
832
1413
|
let measuredWidth = $2.state(400);
|
|
833
1414
|
const observeResize = useResizeObserver((entries) => {
|
|
834
1415
|
const entry = entries[0];
|
|
835
1416
|
if (entry && entry.contentRect.width > 0)
|
|
836
1417
|
$2.set(measuredWidth, entry.contentRect.width, true);
|
|
837
1418
|
});
|
|
838
|
-
const plotWidth = $2.derived(() => Math.max(1, $2.get(measuredWidth) - marginLeft - marginRight));
|
|
839
|
-
const plotHeight = $2.derived(() => Math.max(1, height() - marginTop - marginBottom));
|
|
840
1419
|
const isEmpty = $2.derived(() => $$props.bins.length === 0);
|
|
1420
|
+
const resolvedTheme = $2.derived(() => resolveChartTheme($$props.theme));
|
|
1421
|
+
let rootElement = $2.state(undefined);
|
|
1422
|
+
let measureText = $2.state(false);
|
|
1423
|
+
let measurementVersion = $2.state(0);
|
|
1424
|
+
onMount(() => {
|
|
1425
|
+
$2.set(measureText, true);
|
|
1426
|
+
return observeChartFontLoading(() => {
|
|
1427
|
+
$2.set(measurementVersion, $2.get(measurementVersion) + 1);
|
|
1428
|
+
});
|
|
1429
|
+
});
|
|
841
1430
|
function sanitizeMagnitude(value) {
|
|
842
1431
|
return Number.isFinite(value) && value > 0 ? value : 0;
|
|
843
1432
|
}
|
|
@@ -856,6 +1445,19 @@ function Spectrum_chart($$anchor, $$props) {
|
|
|
856
1445
|
return [0];
|
|
857
1446
|
return Array.from({ length: tickCount }, (_, index2) => $2.get(maxValue) * index2 / (tickCount - 1));
|
|
858
1447
|
});
|
|
1448
|
+
const maxXLabels = 8;
|
|
1449
|
+
const xLabelStep = $2.derived(() => Math.max(1, Math.ceil($$props.bins.length / maxXLabels)));
|
|
1450
|
+
const xTickLabels = $2.derived(() => $$props.bins.filter((_, index2) => index2 % $2.get(xLabelStep) === 0).map((bin) => bin.label));
|
|
1451
|
+
const yTickLabels = $2.derived(() => $2.get(yTicks).map((tick, index2) => formatNumericValue(tick, undefined, undefined, { index: index2 })));
|
|
1452
|
+
const geometry = $2.derived(() => createChartGeometry($2.get(measuredWidth), height(), {
|
|
1453
|
+
xTickLabels: $2.get(xTickLabels),
|
|
1454
|
+
yTickLabels: $2.get(yTickLabels),
|
|
1455
|
+
measureText: $2.get(measureText),
|
|
1456
|
+
measurementElement: $2.get(rootElement),
|
|
1457
|
+
measurementVersion: $2.get(measurementVersion)
|
|
1458
|
+
}));
|
|
1459
|
+
const plotWidth = $2.derived(() => $2.get(geometry).plotWidth);
|
|
1460
|
+
const plotHeight = $2.derived(() => $2.get(geometry).plotHeight);
|
|
859
1461
|
function scaleY(value) {
|
|
860
1462
|
if ($2.get(maxValue) <= 0)
|
|
861
1463
|
return $2.get(plotHeight);
|
|
@@ -876,17 +1478,25 @@ function Spectrum_chart($$anchor, $$props) {
|
|
|
876
1478
|
};
|
|
877
1479
|
});
|
|
878
1480
|
});
|
|
879
|
-
const maxXLabels = 8;
|
|
880
|
-
const xLabelStep = $2.derived(() => Math.max(1, Math.ceil($$props.bins.length / maxXLabels)));
|
|
881
1481
|
const hasDataTable = $2.derived(() => dataTableVisibility() !== "hidden");
|
|
882
1482
|
var figure = root_9();
|
|
883
|
-
$2.attribute_effect(figure, ($0) => ({
|
|
1483
|
+
$2.attribute_effect(figure, ($0, $1) => ({
|
|
884
1484
|
...rest,
|
|
885
1485
|
id: $2.get(rootId),
|
|
886
1486
|
class: $0,
|
|
887
1487
|
"aria-label": $$props.label,
|
|
888
|
-
"aria-describedby": $2.get(descriptionId)
|
|
889
|
-
|
|
1488
|
+
"aria-describedby": $2.get(descriptionId),
|
|
1489
|
+
[$2.STYLE]: $1
|
|
1490
|
+
}), [
|
|
1491
|
+
() => classNames("cinder-spectrum-chart", $$props.class),
|
|
1492
|
+
() => ({
|
|
1493
|
+
"--_cinder-chart-foreground": $2.get(resolvedTheme).foreground,
|
|
1494
|
+
"--_cinder-chart-muted": $2.get(resolvedTheme).muted,
|
|
1495
|
+
"--_cinder-chart-grid": $2.get(resolvedTheme).grid,
|
|
1496
|
+
"--_cinder-chart-background": $2.get(resolvedTheme).background,
|
|
1497
|
+
"--_cinder-chart-series-color": chartPaletteColor(0, $2.get(resolvedTheme).palette)
|
|
1498
|
+
})
|
|
1499
|
+
]);
|
|
890
1500
|
var node = $2.child(figure);
|
|
891
1501
|
{
|
|
892
1502
|
var consequent = ($$anchor2) => {
|
|
@@ -985,7 +1595,6 @@ function Spectrum_chart($$anchor, $$props) {
|
|
|
985
1595
|
{
|
|
986
1596
|
var consequent_7 = ($$anchor2) => {
|
|
987
1597
|
var g = root_6();
|
|
988
|
-
$2.set_attribute(g, "transform", `translate(${marginLeft}, ${marginTop})`);
|
|
989
1598
|
var node_8 = $2.child(g);
|
|
990
1599
|
$2.each(node_8, 17, () => $2.get(yTicks), $2.index, ($$anchor3, tick, index2) => {
|
|
991
1600
|
var fragment_2 = root_3();
|
|
@@ -996,10 +1605,12 @@ function Spectrum_chart($$anchor, $$props) {
|
|
|
996
1605
|
var line = $2.sibling(text_4);
|
|
997
1606
|
$2.template_effect(($0, $1, $22, $3) => {
|
|
998
1607
|
$2.set_attribute(text_4, "y", $0);
|
|
1608
|
+
$2.set_attribute(text_4, "fill", $2.get(resolvedTheme).muted);
|
|
999
1609
|
$2.set_text(text_5, $1);
|
|
1000
1610
|
$2.set_attribute(line, "x2", $2.get(plotWidth));
|
|
1001
1611
|
$2.set_attribute(line, "y1", $22);
|
|
1002
1612
|
$2.set_attribute(line, "y2", $3);
|
|
1613
|
+
$2.set_attribute(line, "stroke", $2.get(resolvedTheme).grid);
|
|
1003
1614
|
}, [
|
|
1004
1615
|
() => scaleY($2.get(tick)),
|
|
1005
1616
|
() => formatNumericValue($2.get(tick), undefined, undefined, { index: index2 }),
|
|
@@ -1011,13 +1622,14 @@ function Spectrum_chart($$anchor, $$props) {
|
|
|
1011
1622
|
var node_9 = $2.sibling(node_8);
|
|
1012
1623
|
$2.each(node_9, 17, () => $2.get(spectrumBars), $2.index, ($$anchor3, bar) => {
|
|
1013
1624
|
var rect = root_4();
|
|
1014
|
-
$2.template_effect(() => {
|
|
1625
|
+
$2.template_effect(($0) => {
|
|
1015
1626
|
$2.set_attribute(rect, "x", $2.get(bar).x);
|
|
1016
1627
|
$2.set_attribute(rect, "y", $2.get(bar).y);
|
|
1017
1628
|
$2.set_attribute(rect, "width", $2.get(bar).barWidth);
|
|
1018
1629
|
$2.set_attribute(rect, "height", $2.get(bar).barHeight);
|
|
1019
1630
|
$2.set_attribute(rect, "data-cinder-bin", $2.get(bar).label);
|
|
1020
|
-
|
|
1631
|
+
$2.set_attribute(rect, "fill", $0);
|
|
1632
|
+
}, [() => chartPaletteColor(0, $2.get(resolvedTheme).palette)]);
|
|
1021
1633
|
$2.append($$anchor3, rect);
|
|
1022
1634
|
});
|
|
1023
1635
|
var node_10 = $2.sibling(node_9);
|
|
@@ -1044,6 +1656,7 @@ function Spectrum_chart($$anchor, $$props) {
|
|
|
1044
1656
|
$2.append($$anchor3, fragment_3);
|
|
1045
1657
|
});
|
|
1046
1658
|
$2.reset(g);
|
|
1659
|
+
$2.template_effect(() => $2.set_attribute(g, "transform", `translate(${$2.get(geometry).marginLeft}, ${$2.get(geometry).marginTop})`));
|
|
1047
1660
|
$2.append($$anchor2, g);
|
|
1048
1661
|
};
|
|
1049
1662
|
$2.if(node_7, ($$render) => {
|
|
@@ -1093,6 +1706,7 @@ function Spectrum_chart($$anchor, $$props) {
|
|
|
1093
1706
|
}
|
|
1094
1707
|
$2.reset(figure);
|
|
1095
1708
|
$2.attach(figure, () => observeResize);
|
|
1709
|
+
$2.bind_this(figure, ($$value) => $2.set(rootElement, $$value), () => $2.get(rootElement));
|
|
1096
1710
|
$2.template_effect(() => {
|
|
1097
1711
|
$2.set_attribute(div, "data-cinder-loading", loading() || undefined);
|
|
1098
1712
|
styles = $2.set_style(div, "", styles, { height: `${height() ?? ""}px` });
|
|
@@ -1111,4 +1725,4 @@ export {
|
|
|
1111
1725
|
Spectrum_chart as SpectrumChart
|
|
1112
1726
|
};
|
|
1113
1727
|
|
|
1114
|
-
//# debugId=
|
|
1728
|
+
//# debugId=15045B68B5FB0E9764756E2164756E21
|