@delacour/react-native-charts 0.1.0-alpha.4

package/src/core/scale/scale.types.ts

@@ -0,0 +1,30 @@
+/**
+ * The scale kinds a chart axis can take.
+ *
+ * `band` and `point` are deliberately absent: a line over categorical x uses
+ * the datum's index against a linear scale, which is what `transformInputData`
+ * substitutes when a field is not numeric. Band arrives with bars, where a
+ * category genuinely needs a width rather than a position.
+ */
+export type ScaleType = "linear" | "time" | "log";
+
+export type DomainTuple = readonly [number, number];
+export type RangeTuple = readonly [number, number];
+
+/**
+ * A scale as plain, serialisable data.
+ *
+ * d3's scales are closures, and a closure cannot be read on the UI thread — a
+ * shared value carries data, not functions. So every scale exists in two
+ * forms: the d3 object, which stays on the JS thread and does the nicing and
+ * the ticking, and this descriptor, which is what crosses into a worklet so
+ * the scrub gesture can invert a touch x with no bridge hop.
+ *
+ * Keep it numbers only. The moment a field here is a function or a class
+ * instance, `invertValue` stops working on the UI thread and the failure shows
+ * up as a scrub dot that never moves.
+ */
+export type ScaleDescriptor =
+	| { readonly kind: "linear"; readonly domain: DomainTuple; readonly range: RangeTuple }
+	| { readonly kind: "time"; readonly domain: DomainTuple; readonly range: RangeTuple }
+	| { readonly kind: "log"; readonly domain: DomainTuple; readonly range: RangeTuple; readonly base: number };

package/src/core/shape/build-bars.test.ts

@@ -0,0 +1,203 @@
+import { describe, expect, test } from "bun:test";
+import type { ChartPoint, ChartSegment } from "../chart.types";
+import type { ScaleDescriptor } from "../scale/scale.types";
+import { barRects, barsPathFromRects, buildBarsPath, resolveBaseline } from "./build-bars";
+
+const at = (x: number, y: number | null): ChartPoint => ({ x, y, xValue: x, yValue: y });
+const seg = (x: number, y: number | null, y0: number | null): ChartSegment => ({
+	x,
+	y,
+	xValue: x,
+	yValue: y,
+	y0,
+	y0Value: y0,
+});
+
+function commands(path: string): string {
+	return (path.match(/[A-Za-z]/g) ?? []).join("");
+}
+
+const bounds = { left: 0, right: 100, top: 0, bottom: 100 };
+
+describe("barRects", () => {
+	test("centres each bar on its x, from the baseline to its y", () => {
+		const [rect] = barRects([at(50, 30)], { bandwidth: 20, baseline: 100 });
+		expect(rect).toEqual({ left: 40, top: 30, right: 60, bottom: 100, negative: false, index: 0 });
+	});
+
+	test("an offset shifts every bar, which is how a group interleaves", () => {
+		const [rect] = barRects([at(50, 30)], { bandwidth: 20, baseline: 100, offset: -15 });
+		expect(rect?.left).toBe(25);
+		expect(rect?.right).toBe(45);
+	});
+
+	test("a bar below the baseline is flagged negative, with top still above bottom", () => {
+		const [rect] = barRects([at(50, 120)], { bandwidth: 20, baseline: 100 });
+		expect(rect).toMatchObject({ top: 100, bottom: 120, negative: true });
+	});
+
+	test("a gap is a zero-height bar at the baseline, never a dropped bar", () => {
+		// Dropping it would shift every later bar's index, and a stacked chart
+		// would pair the wrong segments.
+		const rects = barRects([at(10, 30), at(50, null), at(90, 60)], { bandwidth: 20, baseline: 100 });
+		expect(rects).toHaveLength(3);
+		expect(rects[1]).toMatchObject({ top: 100, bottom: 100, negative: false, index: 1 });
+	});
+
+	test("a segment bases on its own y0 rather than the baseline", () => {
+		const [rect] = barRects([seg(50, 30, 60)], { bandwidth: 20, baseline: 100 });
+		expect(rect).toMatchObject({ top: 30, bottom: 60, negative: false });
+	});
+
+	test("a negative segment is one whose top is below its base", () => {
+		const [rect] = barRects([seg(50, 80, 60)], { bandwidth: 20, baseline: 100 });
+		expect(rect).toMatchObject({ top: 60, bottom: 80, negative: true });
+	});
+
+	test("a segment with a null base is a gap at the baseline", () => {
+		const [rect] = barRects([seg(50, null, null)], { bandwidth: 20, baseline: 100 });
+		expect(rect).toMatchObject({ top: 100, bottom: 100 });
+	});
+});
+
+describe("buildBarsPath", () => {
+	test("one rect's worth of verbs per bar", () => {
+		expect(commands(buildBarsPath([at(10, 30), at(50, 60)], { bandwidth: 20, baseline: 100 }))).toBe(
+			"MCLCLCLCZMCLCLCLCZ"
+		);
+	});
+
+	test("the verbs never depend on the values", () => {
+		// Positive, gap and negative all animate into one another.
+		const options = { bandwidth: 20, baseline: 100, roundedCorners: { topLeft: 4, topRight: 4 } };
+		const before = buildBarsPath([at(10, 50), at(50, 70), at(90, 20)], options);
+		const after = buildBarsPath([at(10, 90), at(50, null), at(90, 120)], options);
+		expect(commands(after)).toBe(commands(before));
+	});
+
+	test("rounds the value end of a positive bar", () => {
+		const path = buildBarsPath([at(50, 30)], { bandwidth: 20, baseline: 100, roundedCorners: { topLeft: 4 } });
+		// Starts on the left edge 4 below the top: the top-left corner is rounded.
+		expect(path.startsWith("M40,34")).toBe(true);
+	});
+
+	test("a negative bar rounds the same corner at its value end, which is its canvas bottom", () => {
+		const path = buildBarsPath([at(50, 120)], { bandwidth: 20, baseline: 100, roundedCorners: { topLeft: 4 } });
+		// The rect's top-left is now square, so the path starts at the very corner.
+		expect(path.startsWith("M40,100")).toBe(true);
+		// ...and the bottom-left carries the radius.
+		expect(path).toContain("L44,120");
+	});
+
+	test("is empty for no points", () => {
+		expect(buildBarsPath([], { bandwidth: 20, baseline: 100 })).toBe("");
+	});
+});
+
+describe("barsPathFromRects", () => {
+	test("takes per-rect corners, for a stack that rounds only its top segment", () => {
+		const rects = barRects([at(10, 30), at(50, 30)], { bandwidth: 20, baseline: 100 });
+		const path = barsPathFromRects(rects, [undefined, { topLeft: 4 }]);
+		expect(path.startsWith("M0,30")).toBe(true);
+		expect(path).toContain("M40,34");
+	});
+});
+
+describe("resolveBaseline", () => {
+	const linear = (domain: readonly [number, number]): ScaleDescriptor => ({
+		kind: "linear",
+		domain,
+		range: [100, 0],
+	});
+
+	test("is the position of zero", () => {
+		expect(resolveBaseline(linear([-50, 50]), bounds)).toBe(50);
+	});
+
+	test("clamps into the plot when zero is outside the domain", () => {
+		expect(resolveBaseline(linear([40, 90]), bounds)).toBe(100);
+		expect(resolveBaseline(linear([-90, -40]), bounds)).toBe(0);
+	});
+
+	test("a log scale bases at the plot bottom, where zero cannot be drawn", () => {
+		expect(resolveBaseline({ kind: "log", domain: [1, 1000], range: [100, 0], base: 10 }, bounds)).toBe(100);
+	});
+});
+
+describe("horizontal bars", () => {
+	// Category on y, value on x. A horizontal point is `{ x: value, y: category }`.
+	const h = (y: number, x: number | null): ChartPoint => ({ x: x ?? Number.NaN, y, xValue: y, yValue: x });
+	const hseg = (y: number, x: number | null, x0: number | null): ChartSegment => ({
+		x: x ?? Number.NaN,
+		y,
+		xValue: y,
+		yValue: x,
+		y0: x0,
+		y0Value: x0,
+	});
+
+	test("spans from the baseline x to the value x, a bandwidth tall around y", () => {
+		const [rect] = barRects([h(50, 80)], { bandwidth: 20, baseline: 0, orientation: "horizontal" });
+		expect(rect).toEqual({ left: 0, top: 40, right: 80, bottom: 60, negative: false, index: 0 });
+	});
+
+	test("a bar left of the baseline is negative", () => {
+		const [rect] = barRects([h(50, 20)], { bandwidth: 20, baseline: 60, orientation: "horizontal" });
+		expect(rect).toMatchObject({ left: 20, right: 60, negative: true });
+	});
+
+	test("a gap is a zero-width bar at the baseline", () => {
+		const [rect] = barRects([h(50, null)], { bandwidth: 20, baseline: 30, orientation: "horizontal" });
+		expect(rect).toMatchObject({ left: 30, right: 30, top: 40, bottom: 60 });
+	});
+
+	test("a segment bases on its y0, which lies along the value axis", () => {
+		const [rect] = barRects([hseg(50, 80, 30)], { bandwidth: 20, baseline: 0, orientation: "horizontal" });
+		expect(rect).toMatchObject({ left: 30, right: 80, negative: false });
+	});
+
+	test("an offset shifts the bar along y", () => {
+		const [rect] = barRects([h(50, 80)], { bandwidth: 20, baseline: 0, offset: 5, orientation: "horizontal" });
+		expect(rect).toMatchObject({ top: 45, bottom: 65 });
+	});
+
+	test("the value-end corners land on the right of a positive bar", () => {
+		const path = buildBarsPath([h(50, 80)], {
+			bandwidth: 20,
+			baseline: 0,
+			orientation: "horizontal",
+			roundedCorners: { topLeft: 4, topRight: 4 },
+		});
+		// Left edge square: the path starts at the very top-left corner.
+		expect(path.startsWith("M0,40")).toBe(true);
+		// Right edge rounded at both ends.
+		expect(path).toContain("L76,40");
+		expect(path).toContain("80,44L80,56");
+	});
+
+	test("and on the left of a negative bar", () => {
+		const path = buildBarsPath([h(50, 20)], {
+			bandwidth: 20,
+			baseline: 60,
+			orientation: "horizontal",
+			roundedCorners: { topLeft: 4, topRight: 4 },
+		});
+		expect(path.startsWith("M20,44")).toBe(true);
+		expect(path).toContain("L24,60");
+	});
+
+	test("the verbs never depend on the values", () => {
+		const options = { bandwidth: 20, baseline: 0, orientation: "horizontal" as const };
+		const before = buildBarsPath([h(10, 50), h(50, 70)], options);
+		const after = buildBarsPath([h(10, null), h(50, -20)], options);
+		expect(commands(after)).toBe(commands(before));
+	});
+
+	test("the baseline is the position of zero on the value scale, clamped to the plot's width", () => {
+		const scale: ScaleDescriptor = { kind: "linear", domain: [-50, 50], range: [0, 100] };
+		expect(resolveBaseline(scale, bounds, "horizontal")).toBe(50);
+		const pinned: ScaleDescriptor = { kind: "linear", domain: [40, 90], range: [0, 100] };
+		expect(resolveBaseline(pinned, bounds, "horizontal")).toBe(0);
+		expect(resolveBaseline({ kind: "log", domain: [1, 10], range: [0, 100], base: 10 }, bounds, "horizontal")).toBe(0);
+	});
+});

package/src/core/shape/build-bars.ts

@@ -0,0 +1,167 @@
+import type { ChartBounds, ChartOrientation, ChartPoint, ChartSegment } from "../chart.types";
+import { scaleValue } from "../scale/scale";
+import type { ScaleDescriptor } from "../scale/scale.types";
+import { clamp } from "../util/clamp";
+import { type CornerRadii, rectPath } from "./rect-path";
+
+/** One bar, resolved to canvas edges. `top` is always above `bottom`. */
+export type BarRect = {
+	readonly left: number;
+	readonly top: number;
+	readonly right: number;
+	readonly bottom: number;
+	/** Whether the bar hangs below its base — its value end is its canvas bottom. */
+	readonly negative: boolean;
+	/** The datum's index in the series. */
+	readonly index: number;
+};
+
+export type BarRectOptions = {
+	readonly bandwidth: number;
+	/** Canvas position along the value axis a bar stands on when its point has no base of its own. */
+	readonly baseline: number;
+	/** Canvas distance along the category axis added to every bar, for a group's interleaving. */
+	readonly offset?: number;
+	/** Bars grow up from a baseline y, or right from a baseline x. Defaults to `vertical`. */
+	readonly orientation?: ChartOrientation;
+	/**
+	 * Corners named by their role, not their canvas position: `topLeft` and
+	 * `topRight` are the value end, `bottomLeft` and `bottomRight` the base. A
+	 * negative bar swaps them, so the rounded end is still the one that moves.
+	 */
+	readonly roundedCorners?: CornerRadii;
+};
+
+/**
+ * A point that may carry its own base. A `ChartSegment` does; a `ChartPoint`
+ * stands on the baseline.
+ */
+export type BarPoint = ChartPoint | ChartSegment;
+
+/**
+ * Each point as a bar rect, centred on its x.
+ *
+ * A gap is a zero-height rect at the baseline rather than a dropped bar.
+ * Dropping it would shift every later bar's index, and a stacked chart would
+ * pair the wrong segments — and the path would lose nine verbs, which is a
+ * snap instead of a morph the next time that datum has a value.
+ */
+export function barRects(points: readonly BarPoint[], options: BarRectOptions): BarRect[] {
+	const { bandwidth, baseline, offset = 0, orientation = "vertical" } = options;
+	const horizontal = orientation === "horizontal";
+	const half = bandwidth / 2;
+
+	return points.map((point, index) => {
+		const centre = (horizontal ? (point.y ?? Number.NaN) : point.x) + offset;
+		const base = baseOf(point, baseline);
+		const measured = horizontal ? point.x : point.y;
+		const value = measured !== null && Number.isFinite(measured) && Number.isFinite(base) ? measured : base;
+		if (horizontal) {
+			return {
+				left: Math.min(value, base),
+				right: Math.max(value, base),
+				top: centre - half,
+				bottom: centre + half,
+				negative: value < base,
+				index,
+			};
+		}
+		return {
+			left: centre - half,
+			right: centre + half,
+			top: Math.min(value, base),
+			bottom: Math.max(value, base),
+			negative: value > base,
+			index,
+		};
+	});
+}
+
+/** Where a point stands: its own `y0` when it is a segment with one, else the baseline. */
+function baseOf(point: BarPoint, baseline: number): number {
+	if ("y0" in point && point.y0 !== null && Number.isFinite(point.y0)) return point.y0;
+	return baseline;
+}
+
+/**
+ * Rects to one path, with corners resolved per rect.
+ *
+ * `roundedCorners` may be one set for every bar or one per rect, for a stack
+ * that rounds only its outermost segment. Corners are stated in value/base
+ * terms and rotated here for a negative bar.
+ */
+export function barsPathFromRects(
+	rects: readonly BarRect[],
+	roundedCorners?: CornerRadii | readonly (CornerRadii | undefined)[],
+	orientation: ChartOrientation = "vertical"
+): string {
+	let path = "";
+	for (let index = 0; index < rects.length; index += 1) {
+		const rect = rects[index] as BarRect;
+		const radii = Array.isArray(roundedCorners) ? roundedCorners[index] : (roundedCorners as CornerRadii | undefined);
+		path += rectPath(
+			rect.left,
+			rect.top,
+			rect.right,
+			rect.bottom,
+			orientCorners(radii ?? {}, rect.negative, orientation)
+		);
+	}
+	return path;
+}
+
+/**
+ * Value-end corners onto whichever canvas edge the value end is: the top of a
+ * positive vertical bar, the bottom of a negative one, the right of a positive
+ * horizontal bar, the left of a negative one.
+ */
+function orientCorners(radii: CornerRadii, negative: boolean, orientation: ChartOrientation): CornerRadii {
+	if (orientation === "horizontal") {
+		return negative
+			? {
+					topLeft: radii.topRight,
+					bottomLeft: radii.topLeft,
+					bottomRight: radii.bottomLeft,
+					topRight: radii.bottomRight,
+				}
+			: {
+					topRight: radii.topLeft,
+					bottomRight: radii.topRight,
+					bottomLeft: radii.bottomRight,
+					topLeft: radii.bottomLeft,
+				};
+	}
+	if (!negative) return radii;
+	return {
+		topLeft: radii.bottomLeft,
+		topRight: radii.bottomRight,
+		bottomRight: radii.topRight,
+		bottomLeft: radii.topLeft,
+	};
+}
+
+/** Points straight to one path of bars. */
+export function buildBarsPath(points: readonly BarPoint[], options: BarRectOptions): string {
+	return barsPathFromRects(barRects(points, options), options.roundedCorners, options.orientation);
+}
+
+/**
+ * Where bars stand: the position of zero on the value scale, held inside the
+ * plot. A y on a vertical chart, an x on a horizontal one.
+ *
+ * Zero can lie outside a domain that was pinned or padded away from it; a bar
+ * based there would draw off the canvas. A log scale has no zero at all, so
+ * its bars stand on the plot's bottom — or left — edge.
+ */
+export function resolveBaseline(
+	valueScale: ScaleDescriptor,
+	bounds: ChartBounds,
+	orientation: ChartOrientation = "vertical"
+): number {
+	if (orientation === "horizontal") {
+		if (valueScale.kind === "log") return bounds.left;
+		return clamp(scaleValue(valueScale, 0), bounds.left, bounds.right);
+	}
+	if (valueScale.kind === "log") return bounds.bottom;
+	return clamp(scaleValue(valueScale, 0), bounds.top, bounds.bottom);
+}

package/src/core/shape/build-candles.test.ts

@@ -0,0 +1,156 @@
+import { describe, expect, test } from "bun:test";
+import type { ChartPoint } from "../chart.types";
+import { buildCandlePaths, candlePoints, candleSentiment, SENTIMENTS } from "./build-candles";
+
+const at = (x: number, y: number | null): ChartPoint => ({ x, y, xValue: x, yValue: y });
+
+function commands(path: string): string {
+	return (path.match(/[A-Za-z]/g) ?? []).join("");
+}
+
+/** Four series from rows of `[open, high, low, close]`, in canvas y (100 − value). */
+function series(rows: readonly (readonly [number | null, number | null, number | null, number | null])[]) {
+	const pick = (column: 0 | 1 | 2 | 3): ChartPoint[] =>
+		rows.map((row, index) => {
+			const value = row[column];
+			return { x: index * 20 + 10, y: value === null ? null : 100 - value, xValue: index, yValue: value };
+		});
+	return candlePoints(pick(0), pick(1), pick(2), pick(3));
+}
+
+describe("candleSentiment", () => {
+	test("close above open is positive, below is negative", () => {
+		expect(candleSentiment(10, 12)).toBe("positive");
+		expect(candleSentiment(12, 10)).toBe("negative");
+	});
+
+	test("an unchanged close is neutral, and so is anything unreadable", () => {
+		expect(candleSentiment(10, 10)).toBe("neutral");
+		expect(candleSentiment(Number.NaN, 10)).toBe("neutral");
+		expect(candleSentiment(null, 10)).toBe("neutral");
+		expect(candleSentiment(10, null)).toBe("neutral");
+	});
+});
+
+describe("candlePoints", () => {
+	test("zips the four series by index", () => {
+		const candles = series([
+			[10, 15, 5, 12],
+			[12, 14, 8, 9],
+		]);
+		expect(candles).toHaveLength(2);
+		expect(candles[0]).toMatchObject({ index: 0, x: 10, openValue: 10, closeValue: 12, sentiment: "positive" });
+		expect(candles[1]).toMatchObject({ index: 1, x: 30, sentiment: "negative" });
+		expect(candles[0]?.highY).toBe(85);
+		expect(candles[0]?.lowY).toBe(95);
+	});
+
+	test("a row with any missing value is a gap, never dropped", () => {
+		const candles = series([[10, null, 5, 12]]);
+		expect(candles).toHaveLength(1);
+		expect(candles[0]?.gap).toBe(true);
+		expect(candles[0]?.sentiment).toBe("neutral");
+	});
+
+	test("takes the length of the shortest series", () => {
+		expect(candlePoints([at(0, 1), at(1, 1)], [at(0, 1)], [at(0, 1)], [at(0, 1)])).toHaveLength(1);
+	});
+});
+
+describe("buildCandlePaths", () => {
+	const candles = series([
+		[10, 15, 5, 12],
+		[12, 14, 8, 9],
+		[9, 9, 9, 9],
+	]);
+
+	test("every candle appears in every sentiment path, so a flip morphs", () => {
+		const paths = buildCandlePaths(candles, { bandwidth: 10 });
+		const bodies = SENTIMENTS.map((sentiment) => commands(paths[sentiment].bodies));
+		const wicks = SENTIMENTS.map((sentiment) => commands(paths[sentiment].wicks));
+		expect(bodies[0]).toBe("MCLCLCLCZ".repeat(3));
+		expect(bodies[1]).toBe(bodies[0]);
+		expect(bodies[2]).toBe(bodies[0]);
+		expect(wicks[0]).toBe("ML".repeat(3));
+		expect(wicks[1]).toBe(wicks[0]);
+		expect(wicks[2]).toBe(wicks[0]);
+	});
+
+	test("a body spans open to close, half a bandwidth either side of x", () => {
+		const { bodies } = buildCandlePaths(candles, { bandwidth: 10 }).positive;
+		// First candle: open 10 → y 90, close 12 → y 88, x 10.
+		expect(bodies.startsWith("M5,88")).toBe(true);
+		expect(bodies).toContain("L15,88");
+		expect(bodies).toContain("L5,90");
+	});
+
+	test("a wick runs from the high to the low", () => {
+		const { wicks } = buildCandlePaths(candles, { bandwidth: 10 }).positive;
+		expect(wicks.startsWith("M10,85L10,95")).toBe(true);
+	});
+
+	test("a candle of another sentiment is a degenerate rect and a zero-length wick at its own place", () => {
+		const { bodies, wicks } = buildCandlePaths(candles, { bandwidth: 10 }).negative;
+		// The first candle is positive, so in the negative path it collapses to
+		// its body's midpoint (y 89) — where it will grow from if it flips.
+		expect(bodies.startsWith("M10,89")).toBe(true);
+		expect(wicks.startsWith("M10,89L10,89")).toBe(true);
+	});
+
+	test("a flat candle is neutral and is expanded to the minimum body height", () => {
+		const { bodies } = buildCandlePaths(candles, { bandwidth: 10, minBodyHeight: 2 }).neutral;
+		// Third candle: everything at 9 → y 91, expanded about 91 to 90..92.
+		expect(bodies).toContain("M45,90");
+		expect(bodies).toContain("L45,92");
+	});
+
+	test("a thin body is expanded to the minimum height about its midpoint", () => {
+		const thin = series([[10, 12, 8, 10.2]]);
+		const { bodies } = buildCandlePaths(thin, { bandwidth: 10, minBodyHeight: 4 }).positive;
+		// open 10 → 90, close 10.2 → 89.8; midpoint 89.9, expanded to 87.9..91.9.
+		expect(bodies).toContain("M5,87.9");
+		expect(bodies).toContain("L5,91.9");
+	});
+
+	test("a gap row is degenerate in all six paths", () => {
+		const withGap = series([
+			[10, 15, 5, 12],
+			[null, 14, 8, 9],
+		]);
+		const paths = buildCandlePaths(withGap, { bandwidth: 10, baseline: 100 });
+		for (const sentiment of SENTIMENTS) {
+			expect(commands(paths[sentiment].bodies)).toBe("MCLCLCLCZ".repeat(2));
+			expect(paths[sentiment].bodies).toContain("M30,100");
+			expect(paths[sentiment].wicks).toContain("M30,100L30,100");
+		}
+	});
+
+	test("is empty in every path for no candles", () => {
+		const paths = buildCandlePaths([], { bandwidth: 10 });
+		for (const sentiment of SENTIMENTS) {
+			expect(paths[sentiment]).toEqual({ bodies: "", wicks: "" });
+		}
+	});
+});
+
+describe("horizontal candles", () => {
+	// Category on y, value on x.
+	const horizontal = (rows: readonly (readonly [number, number, number, number])[]) => {
+		const pick = (column: 0 | 1 | 2 | 3): ChartPoint[] =>
+			rows.map((row, index) => ({ x: row[column], y: index * 20 + 10, xValue: index, yValue: row[column] }));
+		return candlePoints(pick(0), pick(1), pick(2), pick(3), "horizontal");
+	};
+
+	test("reads the category from y and the values from x", () => {
+		const [candle] = horizontal([[10, 15, 5, 12]]);
+		expect(candle).toMatchObject({ x: 10, openY: 10, highY: 15, lowY: 5, closeY: 12, sentiment: "positive" });
+	});
+
+	test("bodies span open to close on x, a bandwidth tall; wicks run low to high on x", () => {
+		const paths = buildCandlePaths(horizontal([[10, 15, 5, 12]]), { bandwidth: 10, orientation: "horizontal" });
+		expect(paths.positive.bodies.startsWith("M10,5")).toBe(true);
+		expect(paths.positive.bodies).toContain("L12,5");
+		expect(paths.positive.bodies).toContain("L10,15");
+		expect(paths.positive.wicks).toBe("M15,10L5,10");
+	});
+});