expressive-charts 0.3.0 → 0.5.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +73 -1
- package/README.md +7 -7
- package/dist/define-DeZLs1h7.js +95 -0
- package/dist/define-DeZLs1h7.js.map +1 -0
- package/dist/drawing-Ypmq-2h6.d.cts +214 -0
- package/dist/drawing-Ypmq-2h6.d.ts +214 -0
- package/dist/effect-C786hGyJ.d.cts +232 -0
- package/dist/effect-CMo-2gPf.d.ts +232 -0
- package/dist/expressive-charts.css +5 -2
- package/dist/expressive-charts.css.d.cts +1 -2
- package/dist/expressive-charts.css.d.ts +1 -2
- package/dist/expressive-charts.global.js +47 -48
- package/dist/expressive-charts.global.js.map +1 -1
- package/dist/icons/sport.cjs +211 -156
- package/dist/icons/sport.cjs.map +1 -1
- package/dist/icons/sport.d.cts +5 -7
- package/dist/icons/sport.d.ts +5 -7
- package/dist/icons/sport.js +122 -71
- package/dist/icons/sport.js.map +1 -1
- package/dist/index.cjs +13203 -9982
- package/dist/index.cjs.map +1 -1
- package/dist/index.d.cts +953 -871
- package/dist/index.d.ts +953 -871
- package/dist/index.js +11000 -8234
- package/dist/index.js.map +1 -1
- package/dist/path-data-DnEckjY8.js +123 -0
- package/dist/path-data-DnEckjY8.js.map +1 -0
- package/dist/testing.cjs +2047 -1255
- package/dist/testing.cjs.map +1 -1
- package/dist/testing.d.cts +135 -139
- package/dist/testing.d.ts +135 -139
- package/dist/testing.js +696 -499
- package/dist/testing.js.map +1 -1
- package/dist/transition-Bu1NsQor.js +2067 -0
- package/dist/transition-Bu1NsQor.js.map +1 -0
- package/package.json +6 -6
- package/dist/chunk-7A7LXXT4.js +0 -70
- package/dist/chunk-7A7LXXT4.js.map +0 -1
- package/dist/chunk-CJUQHEX6.js +0 -618
- package/dist/chunk-CJUQHEX6.js.map +0 -1
- package/dist/chunk-N2BLUETM.js +0 -1194
- package/dist/chunk-N2BLUETM.js.map +0 -1
- package/dist/drawing-CdTgixMY.d.cts +0 -206
- package/dist/drawing-CdTgixMY.d.ts +0 -206
- package/dist/effect-Bu3MHHeg.d.ts +0 -247
- package/dist/effect-D4vmdYP4.d.cts +0 -247
package/dist/chunk-CJUQHEX6.js
DELETED
|
@@ -1,618 +0,0 @@
|
|
|
1
|
-
// src/core/geometry/segment.ts
|
|
2
|
-
var TAU = 2 * Math.PI;
|
|
3
|
-
function line(from, to, fallbackAngle = 0) {
|
|
4
|
-
const dx = to.x - from.x;
|
|
5
|
-
const dy = to.y - from.y;
|
|
6
|
-
const length = Math.hypot(dx, dy);
|
|
7
|
-
return { kind: "line", from, to, length, angle: length > 0 ? Math.atan2(dy, dx) : normalizeAngle(fallbackAngle) };
|
|
8
|
-
}
|
|
9
|
-
function arc(center, radius, start, sweep) {
|
|
10
|
-
return { kind: "arc", center, radius, start, sweep, length: radius * Math.abs(sweep) };
|
|
11
|
-
}
|
|
12
|
-
function pointOn(segment, u) {
|
|
13
|
-
if (segment.kind === "line") {
|
|
14
|
-
const { from, to } = segment;
|
|
15
|
-
return { x: from.x * (1 - u) + to.x * u, y: from.y * (1 - u) + to.y * u };
|
|
16
|
-
}
|
|
17
|
-
return polar(segment.center, segment.radius, segment.start + segment.sweep * u);
|
|
18
|
-
}
|
|
19
|
-
function angleOn(segment, u) {
|
|
20
|
-
if (segment.kind === "line") return segment.angle;
|
|
21
|
-
const quarter = segment.sweep < 0 ? -Math.PI / 2 : Math.PI / 2;
|
|
22
|
-
return normalizeAngle(segment.start + segment.sweep * u + quarter);
|
|
23
|
-
}
|
|
24
|
-
function polar(center, radius, angle) {
|
|
25
|
-
return { x: center.x + radius * Math.cos(angle), y: center.y + radius * Math.sin(angle) };
|
|
26
|
-
}
|
|
27
|
-
function normalizeAngle(angle) {
|
|
28
|
-
return angle - TAU * Math.ceil((angle - Math.PI) / TAU);
|
|
29
|
-
}
|
|
30
|
-
function extremes(segment) {
|
|
31
|
-
if (segment.kind === "line") return [segment.from, segment.to];
|
|
32
|
-
const points = [pointOn(segment, 0), pointOn(segment, 1)];
|
|
33
|
-
for (let k = 0; k < 4; k++) {
|
|
34
|
-
const angle = k * Math.PI / 2;
|
|
35
|
-
if (sweeps(segment, angle)) points.push(polar(segment.center, segment.radius, angle));
|
|
36
|
-
}
|
|
37
|
-
return points;
|
|
38
|
-
}
|
|
39
|
-
function boundsOf(points) {
|
|
40
|
-
let minX = Infinity;
|
|
41
|
-
let minY = Infinity;
|
|
42
|
-
let maxX = -Infinity;
|
|
43
|
-
let maxY = -Infinity;
|
|
44
|
-
for (const { x, y } of points) {
|
|
45
|
-
if (x < minX) minX = x;
|
|
46
|
-
if (x > maxX) maxX = x;
|
|
47
|
-
if (y < minY) minY = y;
|
|
48
|
-
if (y > maxY) maxY = y;
|
|
49
|
-
}
|
|
50
|
-
return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };
|
|
51
|
-
}
|
|
52
|
-
function sweeps(segment, angle) {
|
|
53
|
-
const extent = Math.abs(segment.sweep);
|
|
54
|
-
if (extent >= TAU) return true;
|
|
55
|
-
const turned = segment.sweep >= 0 ? angle - segment.start : segment.start - angle;
|
|
56
|
-
return (turned % TAU + TAU) % TAU <= extent;
|
|
57
|
-
}
|
|
58
|
-
|
|
59
|
-
// src/core/geometry/path-data.ts
|
|
60
|
-
function formatNumber(value) {
|
|
61
|
-
const rounded = Math.round(value * 1e3) / 1e3;
|
|
62
|
-
return rounded === 0 ? "0" : String(rounded);
|
|
63
|
-
}
|
|
64
|
-
function moveTo(point) {
|
|
65
|
-
return `M${formatNumber(point.x)},${formatNumber(point.y)}`;
|
|
66
|
-
}
|
|
67
|
-
function drawTo(segment, u0 = 0, u1 = 1) {
|
|
68
|
-
if (segment.kind === "line") {
|
|
69
|
-
const p = u1 === 1 ? segment.to : pointOn(segment, u1);
|
|
70
|
-
return `L${formatNumber(p.x)},${formatNumber(p.y)}`;
|
|
71
|
-
}
|
|
72
|
-
const from = segment.start + segment.sweep * u0;
|
|
73
|
-
const turn = segment.sweep * (u1 - u0);
|
|
74
|
-
const pieces = Math.max(1, Math.ceil(Math.abs(turn) / Math.PI - 1e-9));
|
|
75
|
-
const r = formatNumber(segment.radius);
|
|
76
|
-
const clockwise = turn >= 0 ? 1 : 0;
|
|
77
|
-
let d = "";
|
|
78
|
-
for (let i = 1; i <= pieces; i++) {
|
|
79
|
-
const p = polar(segment.center, segment.radius, from + turn * i / pieces);
|
|
80
|
-
d += `A${r},${r} 0 0 ${clockwise} ${formatNumber(p.x)},${formatNumber(p.y)}`;
|
|
81
|
-
}
|
|
82
|
-
return d;
|
|
83
|
-
}
|
|
84
|
-
function pathData(segments, closed = false) {
|
|
85
|
-
const first = segments[0];
|
|
86
|
-
if (!first) return "";
|
|
87
|
-
let count = segments.length;
|
|
88
|
-
if (closed) {
|
|
89
|
-
while (count > 0 && segments[count - 1].length <= 0) count--;
|
|
90
|
-
if (count > 0 && segments[count - 1].kind === "line") count--;
|
|
91
|
-
}
|
|
92
|
-
let d = moveTo(pointOn(first, 0));
|
|
93
|
-
for (let i = 0; i < count; i++) {
|
|
94
|
-
const segment = segments[i];
|
|
95
|
-
if (segment.length > 0) d += drawTo(segment);
|
|
96
|
-
}
|
|
97
|
-
return closed ? `${d}Z` : d;
|
|
98
|
-
}
|
|
99
|
-
|
|
100
|
-
// src/core/geometry/walk.ts
|
|
101
|
-
var clamp01 = (t) => t > 0 ? t < 1 ? t : 1 : 0;
|
|
102
|
-
var NONE = Object.freeze([]);
|
|
103
|
-
function createWalk(segments, gaps = NONE) {
|
|
104
|
-
const first = segments[0];
|
|
105
|
-
const last = segments[segments.length - 1];
|
|
106
|
-
if (!first || !last) throw new RangeError("A walk needs at least one segment.");
|
|
107
|
-
const cumulative = [0];
|
|
108
|
-
for (const segment of segments) cumulative.push(cumulative[cumulative.length - 1] + segment.length);
|
|
109
|
-
const length = cumulative[segments.length];
|
|
110
|
-
const start = pointOn(first, 0);
|
|
111
|
-
const end = pointOn(last, 1);
|
|
112
|
-
const locate = (d) => {
|
|
113
|
-
if (!(length > 0)) return { index: 0, u: 0 };
|
|
114
|
-
if (d >= length) {
|
|
115
|
-
let index = segments.length - 1;
|
|
116
|
-
while (index > 0 && !(segments[index].length > 0)) index--;
|
|
117
|
-
return { index, u: 1 };
|
|
118
|
-
}
|
|
119
|
-
let lo = 0;
|
|
120
|
-
let hi = segments.length - 1;
|
|
121
|
-
while (lo < hi) {
|
|
122
|
-
const mid = lo + hi >> 1;
|
|
123
|
-
if (cumulative[mid + 1] > d) hi = mid;
|
|
124
|
-
else lo = mid + 1;
|
|
125
|
-
}
|
|
126
|
-
return { index: lo, u: Math.min(1, (d - cumulative[lo]) / segments[lo].length) };
|
|
127
|
-
};
|
|
128
|
-
const point = (t) => {
|
|
129
|
-
const at = clamp01(t);
|
|
130
|
-
if (at === 0) return start;
|
|
131
|
-
if (at === 1) return end;
|
|
132
|
-
const { index, u } = locate(at * length);
|
|
133
|
-
return pointOn(segments[index], u);
|
|
134
|
-
};
|
|
135
|
-
const draw = (from, to) => {
|
|
136
|
-
let d = moveTo(point(from));
|
|
137
|
-
const a = from * length;
|
|
138
|
-
const b = to * length;
|
|
139
|
-
if (!(b > a)) return d;
|
|
140
|
-
const first2 = locate(a);
|
|
141
|
-
for (let i = first2.index; i < segments.length && cumulative[i] < b; i++) {
|
|
142
|
-
const segment = segments[i];
|
|
143
|
-
if (!(segment.length > 0)) continue;
|
|
144
|
-
const u0 = i === first2.index ? first2.u : 0;
|
|
145
|
-
const u1 = cumulative[i + 1] > b ? Math.min(1, (b - cumulative[i]) / segment.length) : 1;
|
|
146
|
-
if (u1 > u0) d += drawTo(segment, u0, u1);
|
|
147
|
-
}
|
|
148
|
-
return d;
|
|
149
|
-
};
|
|
150
|
-
const slice = (t0, t1) => {
|
|
151
|
-
const from = clamp01(Math.min(t0, t1));
|
|
152
|
-
const to = clamp01(Math.max(t0, t1));
|
|
153
|
-
if (gaps.length === 0) return draw(from, to);
|
|
154
|
-
let d = "";
|
|
155
|
-
let at = from;
|
|
156
|
-
for (const [a, b] of gaps) {
|
|
157
|
-
if (a >= to) break;
|
|
158
|
-
if (a > at) d += draw(at, a);
|
|
159
|
-
if (b > at) at = b;
|
|
160
|
-
}
|
|
161
|
-
if (to > at) d += draw(at, to);
|
|
162
|
-
return d === "" ? moveTo(point(from)) : d;
|
|
163
|
-
};
|
|
164
|
-
return {
|
|
165
|
-
segments,
|
|
166
|
-
length,
|
|
167
|
-
start,
|
|
168
|
-
end,
|
|
169
|
-
gaps,
|
|
170
|
-
point,
|
|
171
|
-
angle(t) {
|
|
172
|
-
const { index, u } = locate(clamp01(t) * length);
|
|
173
|
-
return angleOn(segments[index], u);
|
|
174
|
-
},
|
|
175
|
-
slice,
|
|
176
|
-
d: gaps.length === 0 ? pathData(segments) : slice(0, 1)
|
|
177
|
-
};
|
|
178
|
-
}
|
|
179
|
-
|
|
180
|
-
// src/core/geometry/outline.ts
|
|
181
|
-
function closedOutline(sides) {
|
|
182
|
-
const walks = sides.map((side) => createWalk(side));
|
|
183
|
-
return {
|
|
184
|
-
d: pathData(sides.flat(), true),
|
|
185
|
-
closed: true,
|
|
186
|
-
sample(n) {
|
|
187
|
-
checkCount(n, 4);
|
|
188
|
-
const perSide = n / 4;
|
|
189
|
-
const points = [];
|
|
190
|
-
for (const walk of walks) {
|
|
191
|
-
for (let j = 0; j < perSide; j++) points.push(walk.point(j / perSide));
|
|
192
|
-
}
|
|
193
|
-
return points;
|
|
194
|
-
}
|
|
195
|
-
};
|
|
196
|
-
}
|
|
197
|
-
function openOutline(walk) {
|
|
198
|
-
return {
|
|
199
|
-
d: walk.d,
|
|
200
|
-
closed: false,
|
|
201
|
-
sample(n) {
|
|
202
|
-
checkCount(n, 1);
|
|
203
|
-
if (n === 1) return [walk.start];
|
|
204
|
-
const points = [];
|
|
205
|
-
for (let j = 0; j < n; j++) points.push(walk.point(j / (n - 1)));
|
|
206
|
-
return points;
|
|
207
|
-
}
|
|
208
|
-
};
|
|
209
|
-
}
|
|
210
|
-
function checkCount(n, multiple) {
|
|
211
|
-
if (!Number.isInteger(n) || n < 0 || n % multiple !== 0) {
|
|
212
|
-
const what = multiple === 1 ? "a whole number \u2265 0" : `a whole multiple of ${multiple}`;
|
|
213
|
-
throw new RangeError(`outline.sample(n): n must be ${what}, got ${n}.`);
|
|
214
|
-
}
|
|
215
|
-
}
|
|
216
|
-
|
|
217
|
-
// src/core/geometry/describe/mark.ts
|
|
218
|
-
function assemble({ key, series, walk, thickness, outline, bounds, center, pivot, labelBounds, segments }) {
|
|
219
|
-
return {
|
|
220
|
-
key,
|
|
221
|
-
...series === void 0 ? {} : { series },
|
|
222
|
-
start: walk.start,
|
|
223
|
-
end: walk.end,
|
|
224
|
-
length: walk.length,
|
|
225
|
-
path: (t) => walk.point(t),
|
|
226
|
-
angle: (t) => walk.angle(t),
|
|
227
|
-
slice: (t0, t1) => walk.slice(t0, t1),
|
|
228
|
-
...walk.gaps.length === 0 ? {} : { gaps: walk.gaps },
|
|
229
|
-
thickness,
|
|
230
|
-
outline,
|
|
231
|
-
bounds,
|
|
232
|
-
center,
|
|
233
|
-
pivot,
|
|
234
|
-
...labelBounds === void 0 ? {} : { labelBounds },
|
|
235
|
-
...segments === void 0 ? {} : { segments }
|
|
236
|
-
};
|
|
237
|
-
}
|
|
238
|
-
function finite(builder, field, value) {
|
|
239
|
-
if (!Number.isFinite(value)) throw new RangeError(`describe.${builder}: ${field} must be a finite number, got ${value}.`);
|
|
240
|
-
return value;
|
|
241
|
-
}
|
|
242
|
-
function labelBoxes(builder, boxes) {
|
|
243
|
-
if (!boxes) return boxes;
|
|
244
|
-
for (let i = 0; i < boxes.length; i++) {
|
|
245
|
-
const { x, y, width, height } = boxes[i];
|
|
246
|
-
if (Number.isFinite(x) && Number.isFinite(y) && Number.isFinite(width) && width >= 0 && Number.isFinite(height) && height >= 0) continue;
|
|
247
|
-
finite(builder, `labelBounds[${i}].x`, x);
|
|
248
|
-
finite(builder, `labelBounds[${i}].y`, y);
|
|
249
|
-
size(builder, `labelBounds[${i}].width`, width);
|
|
250
|
-
size(builder, `labelBounds[${i}].height`, height);
|
|
251
|
-
}
|
|
252
|
-
return boxes;
|
|
253
|
-
}
|
|
254
|
-
function size(builder, field, value) {
|
|
255
|
-
if (!(Number.isFinite(value) && value >= 0)) {
|
|
256
|
-
throw new RangeError(`describe.${builder}: ${field} must be a finite number \u2265 0, got ${value}.`);
|
|
257
|
-
}
|
|
258
|
-
return value;
|
|
259
|
-
}
|
|
260
|
-
|
|
261
|
-
// src/core/geometry/describe/arc.ts
|
|
262
|
-
function describeArc(spec) {
|
|
263
|
-
const { key, series } = spec;
|
|
264
|
-
const center = { x: finite("arc", "cx", spec.cx), y: finite("arc", "cy", spec.cy) };
|
|
265
|
-
const r0 = Math.min(size("arc", "inner", spec.inner), size("arc", "outer", spec.outer));
|
|
266
|
-
const r1 = Math.max(spec.inner, spec.outer);
|
|
267
|
-
finite("arc", "start", spec.start);
|
|
268
|
-
finite("arc", "end", spec.end);
|
|
269
|
-
const sweep = Math.max(-TAU, Math.min(TAU, spec.end - spec.start));
|
|
270
|
-
const from = spec.start - Math.PI / 2;
|
|
271
|
-
const to = from + sweep;
|
|
272
|
-
const [left, right] = sweep >= 0 ? [r1, r0] : [r0, r1];
|
|
273
|
-
const sides = [
|
|
274
|
-
[arc(center, left, from, sweep)],
|
|
275
|
-
[line(polar(center, left, to), polar(center, right, to), to + (left > right ? Math.PI : 0))],
|
|
276
|
-
[arc(center, right, to, -sweep)],
|
|
277
|
-
[line(polar(center, right, from), polar(center, left, from), from + (left > right ? 0 : Math.PI))]
|
|
278
|
-
];
|
|
279
|
-
const walk = createWalk([arc(center, (r0 + r1) / 2, from, sweep)]);
|
|
280
|
-
return assemble({
|
|
281
|
-
key,
|
|
282
|
-
series,
|
|
283
|
-
walk,
|
|
284
|
-
thickness: r1 - r0,
|
|
285
|
-
outline: closedOutline(sides),
|
|
286
|
-
bounds: boundsOf(sides.flat().flatMap(extremes)),
|
|
287
|
-
center: walk.point(0.5),
|
|
288
|
-
pivot: center,
|
|
289
|
-
labelBounds: labelBoxes("arc", spec.labelBounds)
|
|
290
|
-
});
|
|
291
|
-
}
|
|
292
|
-
|
|
293
|
-
// src/core/geometry/describe/bar.ts
|
|
294
|
-
var ANGLE = { left: 0, right: Math.PI, top: Math.PI / 2, bottom: -Math.PI / 2 };
|
|
295
|
-
function describeBar(spec) {
|
|
296
|
-
const { key, series, baseline, x, y, width, height } = spec;
|
|
297
|
-
if (!Object.prototype.hasOwnProperty.call(ANGLE, baseline)) {
|
|
298
|
-
throw new RangeError(`describe.bar: baseline must be left, right, top or bottom, got ${String(baseline)}.`);
|
|
299
|
-
}
|
|
300
|
-
finite("bar", "x", x);
|
|
301
|
-
finite("bar", "y", y);
|
|
302
|
-
size("bar", "width", width);
|
|
303
|
-
size("bar", "height", height);
|
|
304
|
-
const radius = size("bar", "radius", spec.radius ?? 0);
|
|
305
|
-
const gap = size("bar", "gap", spec.gap ?? 0);
|
|
306
|
-
const labelBounds = labelBoxes("bar", spec.labelBounds);
|
|
307
|
-
const horizontal = baseline === "left" || baseline === "right";
|
|
308
|
-
const length = horizontal ? width : height;
|
|
309
|
-
const thickness = horizontal ? height : width;
|
|
310
|
-
const T = thickness;
|
|
311
|
-
const angle = ANGLE[baseline];
|
|
312
|
-
const at = frame(spec);
|
|
313
|
-
const part = (p0, p1, tip, rest) => {
|
|
314
|
-
const rr = Math.max(0, Math.min(tip, p1 - p0, T / 2));
|
|
315
|
-
const outline = closedOutline([
|
|
316
|
-
[line(at(p0, 0), at(p1 - rr, 0), angle)],
|
|
317
|
-
rr > 0 ? [
|
|
318
|
-
arc(at(p1 - rr, rr), rr, angle - Math.PI / 2, Math.PI / 2),
|
|
319
|
-
line(at(p1, rr), at(p1, T - rr), angle + Math.PI / 2),
|
|
320
|
-
arc(at(p1 - rr, T - rr), rr, angle, Math.PI / 2)
|
|
321
|
-
] : [line(at(p1, 0), at(p1, T), angle + Math.PI / 2)],
|
|
322
|
-
[line(at(p1 - rr, T), at(p0, T), angle + Math.PI)],
|
|
323
|
-
[line(at(p0, T), at(p0, 0), angle - Math.PI / 2)]
|
|
324
|
-
]);
|
|
325
|
-
const walk = createWalk([line(at(p0, T / 2), at(p1, T / 2), angle)]);
|
|
326
|
-
return assemble({
|
|
327
|
-
...rest,
|
|
328
|
-
walk,
|
|
329
|
-
thickness,
|
|
330
|
-
outline,
|
|
331
|
-
bounds: rest.bounds ?? boundsOf([at(p0, 0), at(p1, T)]),
|
|
332
|
-
center: at((p0 + p1) / 2, T / 2),
|
|
333
|
-
pivot: walk.start
|
|
334
|
-
});
|
|
335
|
-
};
|
|
336
|
-
const specs = spec.segments ?? [{ series, size: length }];
|
|
337
|
-
const seen = /* @__PURE__ */ new Set();
|
|
338
|
-
let cursor = 0;
|
|
339
|
-
const spans = specs.map((segment, index) => {
|
|
340
|
-
size("bar", `segments[${index}].size`, segment.size);
|
|
341
|
-
if (segment.series !== void 0) {
|
|
342
|
-
if (seen.has(segment.series)) throw new Error(`describe.bar: series "${segment.series}" appears twice in the segments of "${key}".`);
|
|
343
|
-
seen.add(segment.series);
|
|
344
|
-
}
|
|
345
|
-
const from = Math.min(cursor, length);
|
|
346
|
-
cursor += segment.size;
|
|
347
|
-
const to = Math.min(cursor, length);
|
|
348
|
-
return { segment, index, p0: Math.min(from + Math.min(gap, from), to), p1: to };
|
|
349
|
-
});
|
|
350
|
-
const segments = spans.map(
|
|
351
|
-
({ segment, index, p0, p1 }) => (
|
|
352
|
-
// The rounding fades in as a segment nears the tip, so a growing stack never pops.
|
|
353
|
-
part(p0, p1, radius - (length - p1), {
|
|
354
|
-
key: segment.series === void 0 ? `${key}/${index}` : `${key}/${segment.series}`,
|
|
355
|
-
series: segment.series
|
|
356
|
-
})
|
|
357
|
-
)
|
|
358
|
-
);
|
|
359
|
-
return part(0, length, radius, { key, series, bounds: { x, y, width, height }, labelBounds, segments });
|
|
360
|
-
}
|
|
361
|
-
function frame({ x, y, width: w, height: h, baseline }) {
|
|
362
|
-
switch (baseline) {
|
|
363
|
-
case "left":
|
|
364
|
-
return (p, s) => ({ x: x + p, y: y + s });
|
|
365
|
-
case "right":
|
|
366
|
-
return (p, s) => ({ x: x + w - p, y: y + h - s });
|
|
367
|
-
case "top":
|
|
368
|
-
return (p, s) => ({ x: x + w - s, y: y + p });
|
|
369
|
-
case "bottom":
|
|
370
|
-
return (p, s) => ({ x: x + s, y: y + h - p });
|
|
371
|
-
}
|
|
372
|
-
}
|
|
373
|
-
|
|
374
|
-
// src/core/geometry/describe/line.ts
|
|
375
|
-
function describeLine(spec) {
|
|
376
|
-
const { key, series, points } = spec;
|
|
377
|
-
const width = size("line", "width", spec.width ?? 1);
|
|
378
|
-
const first = points[0];
|
|
379
|
-
if (!first) throw new RangeError(`describe.line: "${key}" needs at least one point.`);
|
|
380
|
-
points.forEach((p, i) => {
|
|
381
|
-
finite("line", `points[${i}].x`, p.x);
|
|
382
|
-
finite("line", `points[${i}].y`, p.y);
|
|
383
|
-
});
|
|
384
|
-
const breaks = checkBreaks(spec.breaks, points.length);
|
|
385
|
-
const segments = [];
|
|
386
|
-
for (let i = 1; i < points.length; i++) {
|
|
387
|
-
segments.push(line(points[i - 1], points[i], segments[segments.length - 1]?.angle ?? 0));
|
|
388
|
-
}
|
|
389
|
-
if (segments.length === 0) segments.push(line(first, first));
|
|
390
|
-
const walk = createWalk(segments, gapsAt(breaks, segments));
|
|
391
|
-
const box = boundsOf(points);
|
|
392
|
-
const pad = width / 2;
|
|
393
|
-
return assemble({
|
|
394
|
-
key,
|
|
395
|
-
series,
|
|
396
|
-
walk,
|
|
397
|
-
thickness: width,
|
|
398
|
-
outline: openOutline(walk),
|
|
399
|
-
bounds: { x: box.x - pad, y: box.y - pad, width: box.width + width, height: box.height + width },
|
|
400
|
-
center: walk.point(0.5),
|
|
401
|
-
pivot: first,
|
|
402
|
-
labelBounds: labelBoxes("line", spec.labelBounds)
|
|
403
|
-
});
|
|
404
|
-
}
|
|
405
|
-
function gapsAt(breaks, segments) {
|
|
406
|
-
const along = [0];
|
|
407
|
-
for (const segment of segments) along.push(along[along.length - 1] + segment.length);
|
|
408
|
-
const length = along[along.length - 1];
|
|
409
|
-
return breaks.filter((i) => along[i] > along[i - 1]).map((i) => [along[i - 1] / length, along[i] / length]);
|
|
410
|
-
}
|
|
411
|
-
function checkBreaks(breaks, count) {
|
|
412
|
-
if (breaks === void 0) return [];
|
|
413
|
-
if (!Array.isArray(breaks)) throw new RangeError(`describe.line: breaks must be an array of point indices, got ${show(breaks)}.`);
|
|
414
|
-
let after = 0;
|
|
415
|
-
breaks.forEach((index, i) => {
|
|
416
|
-
if (!(Number.isInteger(index) && index > after && index < count)) {
|
|
417
|
-
throw new RangeError(`describe.line: breaks[${i}] must be a whole number more than ${after} and less than ${count}, the number of points, got ${show(index)}.`);
|
|
418
|
-
}
|
|
419
|
-
after = index;
|
|
420
|
-
});
|
|
421
|
-
return breaks;
|
|
422
|
-
}
|
|
423
|
-
var show = (value) => typeof value === "string" ? JSON.stringify(value) : String(value);
|
|
424
|
-
|
|
425
|
-
// src/core/geometry/describe/point.ts
|
|
426
|
-
function describePoint(spec) {
|
|
427
|
-
const { key, series } = spec;
|
|
428
|
-
const center = { x: finite("point", "x", spec.x), y: finite("point", "y", spec.y) };
|
|
429
|
-
const r = size("point", "r", spec.r);
|
|
430
|
-
const quarter = Math.PI / 2;
|
|
431
|
-
return assemble({
|
|
432
|
-
key,
|
|
433
|
-
series,
|
|
434
|
-
walk: createWalk([line(center, center)]),
|
|
435
|
-
thickness: 2 * r,
|
|
436
|
-
outline: closedOutline([
|
|
437
|
-
[arc(center, r, -3 * quarter / 2, quarter)],
|
|
438
|
-
[arc(center, r, -quarter / 2, quarter)],
|
|
439
|
-
[arc(center, r, quarter / 2, quarter)],
|
|
440
|
-
[arc(center, r, 3 * quarter / 2, quarter)]
|
|
441
|
-
]),
|
|
442
|
-
bounds: { x: center.x - r, y: center.y - r, width: 2 * r, height: 2 * r },
|
|
443
|
-
center,
|
|
444
|
-
pivot: center,
|
|
445
|
-
labelBounds: labelBoxes("point", spec.labelBounds)
|
|
446
|
-
});
|
|
447
|
-
}
|
|
448
|
-
|
|
449
|
-
// src/core/geometry/describe/index.ts
|
|
450
|
-
var describe = {
|
|
451
|
-
bar: describeBar,
|
|
452
|
-
arc: describeArc,
|
|
453
|
-
line: describeLine,
|
|
454
|
-
point: describePoint
|
|
455
|
-
};
|
|
456
|
-
|
|
457
|
-
// src/core/geometry/matrix.ts
|
|
458
|
-
function translate(x, y) {
|
|
459
|
-
return [1, 0, 0, 1, x, y];
|
|
460
|
-
}
|
|
461
|
-
function rotate(radians, about) {
|
|
462
|
-
const cos = Math.cos(radians);
|
|
463
|
-
const sin = Math.sin(radians);
|
|
464
|
-
return around([cos, sin, -sin, cos, 0, 0], about);
|
|
465
|
-
}
|
|
466
|
-
function scale(sx, sy = sx, about) {
|
|
467
|
-
return around([sx, 0, 0, sy, 0, 0], about);
|
|
468
|
-
}
|
|
469
|
-
function multiply(...matrices) {
|
|
470
|
-
let result = [1, 0, 0, 1, 0, 0];
|
|
471
|
-
for (const m of matrices) result = product(result, m);
|
|
472
|
-
return result;
|
|
473
|
-
}
|
|
474
|
-
function apply(m, point) {
|
|
475
|
-
const [a, b, c, d, e, f] = m;
|
|
476
|
-
return { x: a * point.x + c * point.y + e, y: b * point.x + d * point.y + f };
|
|
477
|
-
}
|
|
478
|
-
function product(l, r) {
|
|
479
|
-
const [a1, b1, c1, d1, e1, f1] = l;
|
|
480
|
-
const [a2, b2, c2, d2, e2, f2] = r;
|
|
481
|
-
return [
|
|
482
|
-
a1 * a2 + c1 * b2,
|
|
483
|
-
b1 * a2 + d1 * b2,
|
|
484
|
-
a1 * c2 + c1 * d2,
|
|
485
|
-
b1 * c2 + d1 * d2,
|
|
486
|
-
a1 * e2 + c1 * f2 + e1,
|
|
487
|
-
b1 * e2 + d1 * f2 + f1
|
|
488
|
-
];
|
|
489
|
-
}
|
|
490
|
-
function around(m, about) {
|
|
491
|
-
if (!about) return m;
|
|
492
|
-
const [a, b, c, d] = m;
|
|
493
|
-
return [a, b, c, d, about.x - a * about.x - c * about.y, about.y - b * about.x - d * about.y];
|
|
494
|
-
}
|
|
495
|
-
var matrix = { translate, rotate, scale, multiply, apply };
|
|
496
|
-
function invert(m) {
|
|
497
|
-
const [a, b, c, d, e, f] = m;
|
|
498
|
-
const det = a * d - b * c;
|
|
499
|
-
if (!Number.isFinite(det) || Math.abs(det) < 1e-12) throw new RangeError("This transform can't be inverted: it has no area.");
|
|
500
|
-
return [d / det, -b / det, -c / det, a / det, (c * f - d * e) / det, (b * e - a * f) / det];
|
|
501
|
-
}
|
|
502
|
-
function parseTransform(source) {
|
|
503
|
-
const parts = [];
|
|
504
|
-
for (const [, name, rawArgs = ""] of source.matchAll(/(matrix|translate|scale|rotate|skewX|skewY)\s*\(([^)]*)\)/g)) {
|
|
505
|
-
const args = rawArgs.trim().split(/[\s,]+/).filter(Boolean).map(Number);
|
|
506
|
-
if (!args.every(Number.isFinite)) continue;
|
|
507
|
-
const [a = 0, b, c, d = 0, e = 0, f = 0] = args;
|
|
508
|
-
const radians = (degrees) => degrees * Math.PI / 180;
|
|
509
|
-
switch (name) {
|
|
510
|
-
case "matrix":
|
|
511
|
-
if (args.length === 6) parts.push([a, b, c, d, e, f]);
|
|
512
|
-
break;
|
|
513
|
-
case "translate":
|
|
514
|
-
parts.push(translate(a, b ?? 0));
|
|
515
|
-
break;
|
|
516
|
-
case "scale":
|
|
517
|
-
parts.push(scale(a, b ?? a));
|
|
518
|
-
break;
|
|
519
|
-
case "rotate":
|
|
520
|
-
parts.push(rotate(radians(a), b !== void 0 && c !== void 0 ? { x: b, y: c } : void 0));
|
|
521
|
-
break;
|
|
522
|
-
case "skewX":
|
|
523
|
-
parts.push([1, 0, Math.tan(radians(a)), 1, 0, 0]);
|
|
524
|
-
break;
|
|
525
|
-
case "skewY":
|
|
526
|
-
parts.push([1, Math.tan(radians(a)), 0, 1, 0, 0]);
|
|
527
|
-
break;
|
|
528
|
-
}
|
|
529
|
-
}
|
|
530
|
-
return multiply(...parts);
|
|
531
|
-
}
|
|
532
|
-
function offset(point, angle, distance) {
|
|
533
|
-
return { x: point.x + distance * Math.cos(angle), y: point.y + distance * Math.sin(angle) };
|
|
534
|
-
}
|
|
535
|
-
|
|
536
|
-
// src/core/geometry/samples.ts
|
|
537
|
-
var MAX_GRID = 4096;
|
|
538
|
-
var REFINE = 48;
|
|
539
|
-
var GOLDEN = (Math.sqrt(5) - 1) / 2;
|
|
540
|
-
function samplesAlong(mark, points) {
|
|
541
|
-
if (typeof mark !== "object" || mark === null || typeof mark.path !== "function" || !Number.isFinite(mark.length)) {
|
|
542
|
-
throw new TypeError("samplesAlong needs a MarkGeometry, as describe builds it.");
|
|
543
|
-
}
|
|
544
|
-
if (!Array.isArray(points)) throw new TypeError("samplesAlong needs an array of points { x, y, value, at? }.");
|
|
545
|
-
points.forEach((p, i) => {
|
|
546
|
-
for (const field of ["x", "y", "value"]) {
|
|
547
|
-
const value = p?.[field];
|
|
548
|
-
if (typeof value !== "number" || !Number.isFinite(value)) throw new RangeError(`samplesAlong: points[${i}].${field} must be a finite number, got ${String(value)}.`);
|
|
549
|
-
}
|
|
550
|
-
});
|
|
551
|
-
const n = mark.length > 0 ? Math.min(MAX_GRID, Math.ceil(mark.length) + 1) : 1;
|
|
552
|
-
const grid = Array.from({ length: n }, (_, i) => mark.path(n === 1 ? 0 : i / (n - 1)));
|
|
553
|
-
const samples = points.map((p, index) => ({ index, sample: { t: nearest(mark, grid, p), value: p.value, ...p.at === void 0 ? {} : { at: p.at } } })).sort((a, b) => a.sample.t - b.sample.t || a.index - b.index).map(({ sample }) => sample);
|
|
554
|
-
return mark.gaps && mark.gaps.length > 0 ? gapped(samples, mark.gaps) : samples;
|
|
555
|
-
}
|
|
556
|
-
function gapped(samples, gaps) {
|
|
557
|
-
const middles = gaps.map(([from, to]) => (from + to) / 2).sort((a, b) => a - b);
|
|
558
|
-
let next = 0;
|
|
559
|
-
return samples.map((sample, k) => {
|
|
560
|
-
if (k === 0) return sample;
|
|
561
|
-
const before = samples[k - 1].t;
|
|
562
|
-
while (next < middles.length && middles[next] <= before) next++;
|
|
563
|
-
return next < middles.length && middles[next] <= sample.t ? { ...sample, gapBefore: true } : sample;
|
|
564
|
-
});
|
|
565
|
-
}
|
|
566
|
-
function nearest(mark, grid, p) {
|
|
567
|
-
const n = grid.length;
|
|
568
|
-
if (n === 1) return 0;
|
|
569
|
-
let best = 0;
|
|
570
|
-
let bestDistance = Infinity;
|
|
571
|
-
grid.forEach((q, i) => {
|
|
572
|
-
const d = squared(q, p);
|
|
573
|
-
if (d < bestDistance) {
|
|
574
|
-
best = i;
|
|
575
|
-
bestDistance = d;
|
|
576
|
-
}
|
|
577
|
-
});
|
|
578
|
-
const f = (t2) => squared(mark.path(t2), p);
|
|
579
|
-
let lo = Math.max(0, best - 1) / (n - 1);
|
|
580
|
-
let hi = Math.min(n - 1, best + 1) / (n - 1);
|
|
581
|
-
let a = hi - GOLDEN * (hi - lo);
|
|
582
|
-
let b = lo + GOLDEN * (hi - lo);
|
|
583
|
-
let fa = f(a);
|
|
584
|
-
let fb = f(b);
|
|
585
|
-
for (let step = 0; step < REFINE; step++) {
|
|
586
|
-
if (fa <= fb) {
|
|
587
|
-
hi = b;
|
|
588
|
-
b = a;
|
|
589
|
-
fb = fa;
|
|
590
|
-
a = hi - GOLDEN * (hi - lo);
|
|
591
|
-
fa = f(a);
|
|
592
|
-
} else {
|
|
593
|
-
lo = a;
|
|
594
|
-
a = b;
|
|
595
|
-
fa = fb;
|
|
596
|
-
b = lo + GOLDEN * (hi - lo);
|
|
597
|
-
fb = f(b);
|
|
598
|
-
}
|
|
599
|
-
}
|
|
600
|
-
const t = (lo + hi) / 2;
|
|
601
|
-
const found = f(t) < bestDistance ? t : best / (n - 1);
|
|
602
|
-
return found > 0 ? found < 1 ? found : 1 : 0;
|
|
603
|
-
}
|
|
604
|
-
function squared(a, b) {
|
|
605
|
-
return (a.x - b.x) ** 2 + (a.y - b.y) ** 2;
|
|
606
|
-
}
|
|
607
|
-
|
|
608
|
-
export {
|
|
609
|
-
normalizeAngle,
|
|
610
|
-
formatNumber,
|
|
611
|
-
describe,
|
|
612
|
-
matrix,
|
|
613
|
-
invert,
|
|
614
|
-
parseTransform,
|
|
615
|
-
offset,
|
|
616
|
-
samplesAlong
|
|
617
|
-
};
|
|
618
|
-
//# sourceMappingURL=chunk-CJUQHEX6.js.map
|