expressive-charts 0.2.0 → 0.4.0

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