@thomasfosterau/charts 0.0.0-stage → 0.1.0

package/dist/core-BVbfW7N6.mjs

@@ -0,0 +1,936 @@
+import { a as isDataRef, i as validateSpec, o as isInlineData } from "./spec-FF2Tds2a.mjs";
+import { area, line } from "d3-shape";
+import { scaleBand, scaleLinear, scaleOrdinal, scalePoint, scaleSqrt, scaleUtc } from "d3-scale";
+// src/core/accessor.ts
+/**
+* Creates a typed accessor for an encoding channel.
+*
+* Values are reconstructed from the channel's **declared** type — never by
+* sniffing the runtime shape of the JSON value (the cross-platform invariant
+* every interpreter must follow):
+*
+* - `quantitative` → finite number
+* - `temporal` → Date, parsed from ISO 8601 strings or epoch milliseconds
+* - `ordinal` / `nominal` → category string (numbers/booleans are stringified)
+*
+* Missing fields and nulls yield `null`. Values that contradict the declared
+* type throw: a declared type is a contract, and violating it is a data error
+* the caller must surface, not hide.
+*/
+function makeAccessor(channel) {
+	switch (channel.type) {
+		case "quantitative": return (datum) => toQuantitative(datum[channel.field], channel.field);
+		case "temporal": return (datum) => toTemporal(datum[channel.field], channel.field);
+		case "ordinal":
+		case "nominal": return (datum) => toCategory(datum[channel.field]);
+	}
+}
+function toQuantitative(value, field) {
+	if (value === null || value === void 0) return null;
+	if (typeof value === "number" && Number.isFinite(value)) return value;
+	throw new TypeError(`Field "${field}" is declared quantitative but datum value ${JSON.stringify(value)} is not a finite number`);
+}
+function toTemporal(value, field) {
+	if (value === null || value === void 0) return null;
+	if (typeof value === "number" || typeof value === "string") {
+		const date = new Date(value);
+		if (!Number.isNaN(date.getTime())) return date;
+	}
+	throw new TypeError(`Field "${field}" is declared temporal but datum value ${JSON.stringify(value)} is not a parseable date (expected ISO 8601 string or epoch milliseconds)`);
+}
+function toCategory(value) {
+	if (value === null || value === void 0) return null;
+	return typeof value === "string" ? value : String(value);
+}
+// src/core/geometry/position.ts
+/**
+* Maps a typed field value to a plot pixel position.
+*
+* Band scales position at the band centre; other scales map directly.
+* Returns undefined for missing values or values outside a categorical domain.
+*/
+function positionOf(scale, value) {
+	if (value === null) return void 0;
+	switch (scale.kind) {
+		case "linear": return typeof value === "number" ? scale.d3(value) : void 0;
+		case "utc": return value instanceof Date ? scale.d3(value) : void 0;
+		case "band": {
+			const start = scale.d3(asCategory$1(value));
+			return start === void 0 ? void 0 : start + scale.d3.bandwidth() / 2;
+		}
+		case "point": return scale.d3(asCategory$1(value));
+	}
+}
+/**
+* The pixel position of the zero baseline for a y scale, clamped to the plot.
+* Non-linear y scales (temporal/categorical) baseline at the bottom of the range.
+*/
+function baselineOf(scale) {
+	const range = scale.resolved.range;
+	const lo = Math.min(...range);
+	const hi = Math.max(...range);
+	if (scale.kind === "linear") return Math.min(Math.max(scale.d3(0), lo), hi);
+	return hi;
+}
+function asCategory$1(value) {
+	return typeof value === "string" ? value : String(value);
+}
+// src/core/geometry/series.ts
+/**
+* Splits data rows into series by the colour channel, preserving data order.
+* Without a colour channel, returns a single unsplit series.
+*/
+function splitSeries(data, colorChannel, colorScale) {
+	if (!colorChannel || !colorScale) return [{
+		key: null,
+		color: void 0,
+		rows: data
+	}];
+	const accessor = makeAccessor(colorChannel);
+	const groups = /* @__PURE__ */ new Map();
+	for (const datum of data) {
+		const value = accessor(datum);
+		if (value === null) continue;
+		const key = typeof value === "string" ? value : String(value);
+		const group = groups.get(key);
+		if (group) group.push(datum);
+		else groups.set(key, [datum]);
+	}
+	return [...groups.entries()].map(([key, rows]) => ({
+		key,
+		color: colorOf(colorScale, key),
+		rows
+	}));
+}
+/** Resolves a colour for a single datum, or undefined without a colour encoding. */
+function colorOfDatum(datum, colorChannel, colorScale) {
+	if (!colorChannel || !colorScale) return void 0;
+	const value = makeAccessor(colorChannel)(datum);
+	if (value === null) return void 0;
+	return colorOf(colorScale, value);
+}
+function colorOf(scale, value) {
+	const result = scale.apply(value);
+	return typeof result === "string" ? result : void 0;
+}
+// src/core/geometry/line.ts
+/** Builds line chart geometry: one series per colour category, each with points and an SVG path. */
+function buildLineGeometry(args) {
+	return {
+		mark: "line",
+		series: buildSeries(args)
+	};
+}
+/** Shared series-of-points construction for line and area marks. */
+function buildSeries(args) {
+	const xAccessor = makeAccessor(args.x);
+	const yAccessor = makeAccessor(args.y);
+	const pathOf = args.pathOf ?? linePathOf;
+	return splitSeries(args.data, args.color, args.colorScale).map((group) => {
+		const points = [];
+		for (const datum of group.rows) {
+			const px = positionOf(args.xScale, xAccessor(datum));
+			const py = positionOf(args.yScale, yAccessor(datum));
+			if (px === void 0 || py === void 0) continue;
+			points.push({
+				x: px,
+				y: py,
+				datum
+			});
+		}
+		return {
+			key: group.key,
+			color: group.color,
+			points,
+			path: points.length > 0 ? pathOf(points) : ""
+		};
+	});
+}
+function linePathOf(points) {
+	return line().x((point) => point.x).y((point) => point.y)([...points]) ?? "";
+}
+// src/core/geometry/area.ts
+/**
+* Builds area chart geometry: like a line, but each series path is closed
+* down to the zero baseline (or the bottom of the plot when zero is not in
+* the y domain).
+*/
+function buildAreaGeometry(args) {
+	const baseline = baselineOf(args.yScale);
+	return {
+		mark: "area",
+		series: buildSeries({
+			...args,
+			pathOf: (points) => areaPathOf(points, baseline)
+		})
+	};
+}
+function areaPathOf(points, baseline) {
+	return area().x((point) => point.x).y1((point) => point.y).y0(baseline)([...points]) ?? "";
+}
+// src/core/geometry/bar.ts
+/**
+* Builds bar chart geometry. Bars grow from the zero baseline, so negative
+* values produce bars below it. Band x-scales give bars their bandwidth;
+* continuous x-scales get a derived width. With a range channel (`x2` or
+* `y2`, spec 1.1) each bar spans from its start to its end instead: a
+* horizontal range bar (a Gantt row) for `x2`, a vertical one for `y2`.
+*/
+function buildBarGeometry(args) {
+	if (args.x2 !== void 0) return buildRangeBars(args, "x", args.x2);
+	if (args.y2 !== void 0) return buildRangeBars(args, "y", args.y2);
+	const xAccessor = makeAccessor(args.x);
+	const yAccessor = makeAccessor(args.y);
+	const baseline = baselineOf(args.yScale);
+	const barWidth = barWidthOf(args.xScale, args.data.length);
+	const bars = [];
+	for (const datum of args.data) {
+		const xCenter = positionOf(args.xScale, xAccessor(datum));
+		const yPosition = positionOf(args.yScale, yAccessor(datum));
+		if (xCenter === void 0 || yPosition === void 0) continue;
+		bars.push({
+			x: xCenter - barWidth / 2,
+			y: Math.min(yPosition, baseline),
+			width: barWidth,
+			height: Math.abs(yPosition - baseline),
+			color: colorOfDatum(datum, args.color, args.colorScale),
+			datum
+		});
+	}
+	return {
+		mark: "bar",
+		bars
+	};
+}
+/**
+* Range bars along `axis`: each spans the start channel's position to the
+* end channel's. An end before its start is normalised (the rect runs
+* between the two whichever comes first), so a reversed row still draws.
+* The other axis is the band each bar sits in.
+*/
+function buildRangeBars(args, axis, end) {
+	const along = axis === "x" ? args.xScale : args.yScale;
+	const across = axis === "x" ? args.yScale : args.xScale;
+	const startAccessor = makeAccessor(axis === "x" ? args.x : args.y);
+	const endAccessor = makeAccessor(end);
+	const bandAccessor = makeAccessor(axis === "x" ? args.y : args.x);
+	const thickness = barWidthOf(across, args.data.length);
+	const bars = [];
+	for (const datum of args.data) {
+		const from = positionOf(along, startAccessor(datum));
+		const to = positionOf(along, endAccessor(datum));
+		const centre = positionOf(across, bandAccessor(datum));
+		if (from === void 0 || to === void 0 || centre === void 0) continue;
+		const low = Math.min(from, to);
+		const length = Math.abs(to - from);
+		const color = colorOfDatum(datum, args.color, args.colorScale);
+		bars.push(axis === "x" ? {
+			x: low,
+			y: centre - thickness / 2,
+			width: length,
+			height: thickness,
+			color,
+			datum
+		} : {
+			x: centre - thickness / 2,
+			y: low,
+			width: thickness,
+			height: length,
+			color,
+			datum
+		});
+	}
+	return {
+		mark: "bar",
+		bars
+	};
+}
+function barWidthOf(xScale, count) {
+	if (xScale.kind === "band") return xScale.d3.bandwidth();
+	const range = xScale.resolved.range;
+	const extent = Math.abs(Math.max(...range) - Math.min(...range));
+	return count > 0 ? Math.max(1, extent / count * .8) : 1;
+}
+// src/core/scale.ts
+/**
+* Default categorical palette (Tableau 10). Interpreters may override; the
+* core resolves concrete colours so geometry is directly drawable.
+*/
+const CATEGORICAL_PALETTE = [
+	"#4e79a7",
+	"#f28e2c",
+	"#e15759",
+	"#76b7b4",
+	"#59a14f",
+	"#edc949",
+	"#af7aa1",
+	"#ff9da7",
+	"#9c755f",
+	"#bab0ab"
+];
+/** Default radius range (pixels) for the size channel on point marks. */
+const DEFAULT_RADIUS_RANGE = [3, 12];
+/** Default point radius when no size encoding is present. */
+const DEFAULT_POINT_RADIUS = 4;
+/**
+* Resolves a positional (x or y) scale from a channel's declared type.
+*
+* - `quantitative` → linear
+* - `temporal` → UTC time (UTC for cross-platform determinism)
+* - `ordinal`/`nominal` → band for bar marks (bars need bandwidth),
+*   point for line/point/area marks (single positions)
+*/
+function resolvePositionalScale(channel, mark, pixelRange, data, hint, rangeEnd) {
+	switch (channel.type) {
+		case "quantitative": return resolveLinear(channel, mark, pixelRange, data, hint, rangeEnd);
+		case "temporal": return resolveUtc(channel, pixelRange, data, hint, rangeEnd);
+		case "ordinal":
+		case "nominal": return resolveCategorical(channel, mark, pixelRange, data, hint);
+	}
+}
+function resolveLinear(channel, mark, pixelRange, data, hint, rangeEnd) {
+	let domain;
+	const hintDomain = numericHintDomain(hint);
+	if (hintDomain) domain = hintDomain;
+	else {
+		const values = valuesOf(data, channel, rangeEnd).filter((value) => typeof value === "number");
+		domain = values.length > 0 ? [Math.min(...values), Math.max(...values)] : [0, 1];
+	}
+	if (hint?.zero ?? (mark === "bar" && rangeEnd === void 0)) domain = [Math.min(domain[0], 0), Math.max(domain[1], 0)];
+	if (domain[0] === domain[1]) domain = [domain[0] - 1, domain[1] + 1];
+	let d3Scale = scaleLinear().domain(domain).range(pixelRange);
+	if (hint?.nice) d3Scale = d3Scale.nice();
+	const finalDomain = d3Scale.domain();
+	return {
+		kind: "linear",
+		d3: d3Scale,
+		resolved: {
+			kind: "linear",
+			domain: finalDomain,
+			range: [...pixelRange],
+			apply: (value) => typeof value === "number" ? d3Scale(value) : void 0,
+			bandwidth: 0
+		}
+	};
+}
+function resolveUtc(channel, pixelRange, data, hint, rangeEnd) {
+	let domain;
+	const hintDomain = temporalHintDomain(hint);
+	if (hintDomain) domain = hintDomain;
+	else {
+		const times = valuesOf(data, channel, rangeEnd).filter((value) => value instanceof Date).map((value) => value.getTime());
+		domain = times.length > 0 ? [new Date(Math.min(...times)), new Date(Math.max(...times))] : [new Date(Date.UTC(2e3, 0, 1)), new Date(Date.UTC(2e3, 0, 2))];
+	}
+	if (domain[0].getTime() === domain[1].getTime()) {
+		const dayMs = 864e5;
+		domain = [/* @__PURE__ */ new Date(domain[0].getTime() - dayMs), new Date(domain[1].getTime() + dayMs)];
+	}
+	let d3Scale = scaleUtc().domain(domain).range(pixelRange);
+	if (hint?.nice) d3Scale = d3Scale.nice();
+	const finalDomain = d3Scale.domain();
+	return {
+		kind: "utc",
+		d3: d3Scale,
+		resolved: {
+			kind: "utc",
+			domain: finalDomain,
+			range: [...pixelRange],
+			apply: (value) => value instanceof Date ? d3Scale(value) : void 0,
+			bandwidth: 0
+		}
+	};
+}
+/** Every value of `channel` and, for a range, of its end channel `rangeEnd`. */
+function valuesOf(data, channel, rangeEnd) {
+	const accessors = rangeEnd === void 0 ? [makeAccessor(channel)] : [makeAccessor(channel), makeAccessor(rangeEnd)];
+	return data.flatMap((datum) => accessors.map((accessor) => accessor(datum)));
+}
+function resolveCategorical(channel, mark, pixelRange, data, hint) {
+	const domain = categoricalDomain(channel, data, hint);
+	if (mark === "bar") {
+		const d3Scale = scaleBand().domain(domain).range(pixelRange).padding(.1);
+		return {
+			kind: "band",
+			d3: d3Scale,
+			resolved: {
+				kind: "band",
+				domain,
+				range: [...pixelRange],
+				apply: (value) => d3Scale(asCategory(value)),
+				bandwidth: d3Scale.bandwidth()
+			}
+		};
+	}
+	const d3Scale = scalePoint().domain(domain).range(pixelRange).padding(.5);
+	return {
+		kind: "point",
+		d3: d3Scale,
+		resolved: {
+			kind: "point",
+			domain,
+			range: [...pixelRange],
+			apply: (value) => d3Scale(asCategory(value)),
+			bandwidth: 0
+		}
+	};
+}
+/**
+* Resolves the colour scale for a colour channel.
+*
+* - `ordinal`/`nominal` → categorical palette
+* - `quantitative`/`temporal` → normalised [0, 1] linear scale; interpreters
+*   map the normalised value onto their own gradient
+*/
+function resolveColorScale(channel, data) {
+	if (channel.type === "ordinal" || channel.type === "nominal") {
+		const domain = categoricalDomain(channel, data);
+		const d3Scale = scaleOrdinal().domain(domain).range(CATEGORICAL_PALETTE.slice(0, Math.max(domain.length, 1)));
+		return {
+			kind: "ordinal",
+			domain,
+			range: domain.map((category) => d3Scale(category)),
+			apply: (value) => d3Scale(asCategory(value)),
+			bandwidth: 0
+		};
+	}
+	const accessor = makeAccessor(channel);
+	const values = [];
+	for (const datum of data) {
+		const value = accessor(datum);
+		if (typeof value === "number") values.push(value);
+		else if (value instanceof Date) values.push(value.getTime());
+	}
+	const domain = values.length > 0 ? [Math.min(...values), Math.max(...values)] : [0, 1];
+	const d3Scale = scaleLinear().domain(domain).range([0, 1]);
+	return {
+		kind: "linear",
+		domain,
+		range: [0, 1],
+		apply: (value) => {
+			if (typeof value === "number") return d3Scale(value);
+			if (value instanceof Date) return d3Scale(value.getTime());
+		},
+		bandwidth: 0
+	};
+}
+/**
+* Resolves the size scale for point marks: quantitative values map onto a
+* radius range with square-root scaling so symbol *area* is proportional to
+* the value.
+*/
+function resolveSizeScale(channel, data) {
+	const accessor = makeAccessor(channel);
+	const values = [];
+	for (const datum of data) {
+		const value = accessor(datum);
+		if (typeof value === "number") values.push(value);
+	}
+	const domain = values.length > 0 ? [Math.min(...values), Math.max(...values)] : [0, 1];
+	const d3Scale = scaleSqrt().domain(domain).range(DEFAULT_RADIUS_RANGE);
+	return {
+		kind: "linear",
+		domain,
+		range: [...DEFAULT_RADIUS_RANGE],
+		apply: (value) => typeof value === "number" ? d3Scale(value) : void 0,
+		bandwidth: 0
+	};
+}
+function numericHintDomain(hint) {
+	if (!hint?.domain || hint.domain.length < 2) return void 0;
+	const [min, max] = [hint.domain[0], hint.domain[hint.domain.length - 1]];
+	if (typeof min === "number" && typeof max === "number") return [min, max];
+}
+function temporalHintDomain(hint) {
+	if (!hint?.domain || hint.domain.length < 2) return void 0;
+	const min = new Date(hint.domain[0]);
+	const max = new Date(hint.domain[hint.domain.length - 1]);
+	if (!Number.isNaN(min.getTime()) && !Number.isNaN(max.getTime())) return [min, max];
+}
+function categoricalDomain(channel, data, hint) {
+	if (hint?.domain && hint.domain.length > 0) return hint.domain.map((value) => String(value));
+	const accessor = makeAccessor(channel);
+	const seen = /* @__PURE__ */ new Set();
+	const domain = [];
+	for (const datum of data) {
+		const value = accessor(datum);
+		if (typeof value === "string" && !seen.has(value)) {
+			seen.add(value);
+			domain.push(value);
+		}
+	}
+	return domain;
+}
+function asCategory(value) {
+	return typeof value === "string" ? value : String(value);
+}
+// src/core/geometry/point.ts
+/** Builds scatter/point chart geometry: one circle per datum. */
+function buildPointGeometry(args) {
+	const xAccessor = makeAccessor(args.x);
+	const yAccessor = makeAccessor(args.y);
+	const sizeAccessor = args.size ? makeAccessor(args.size) : void 0;
+	const points = [];
+	for (const datum of args.data) {
+		const cx = positionOf(args.xScale, xAccessor(datum));
+		const cy = positionOf(args.yScale, yAccessor(datum));
+		if (cx === void 0 || cy === void 0) continue;
+		points.push({
+			cx,
+			cy,
+			r: radiusOf(datum, sizeAccessor, args.sizeScale),
+			color: colorOfDatum(datum, args.color, args.colorScale),
+			datum
+		});
+	}
+	return {
+		mark: "point",
+		points
+	};
+}
+function radiusOf(datum, sizeAccessor, sizeScale) {
+	if (!sizeAccessor || !sizeScale) return 4;
+	const value = sizeAccessor(datum);
+	if (value === null) return 4;
+	const radius = sizeScale.apply(value);
+	return typeof radius === "number" ? radius : 4;
+}
+// src/core/geometry/tree.ts
+/**
+* The inline style every interpreter puts on a tree's nested-list text
+* alternative: in the accessibility tree, out of sight (the classic
+* visually-hidden pattern, inline because these interpreters ship no CSS).
+*/
+const VISUALLY_HIDDEN_STYLE = "position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0,0,0,0);white-space:nowrap;border:0";
+/** The text of one outline entry: its label, then its colour category in words. */
+function outlineText(node) {
+	return node.category === void 0 ? node.label : `${node.label}, ${node.category}`;
+}
+/** Height of a node box, in pixels. */
+const NODE_HEIGHT = 28;
+/** The width of one label character, estimated (the pure path has no text measurer). */
+const CHAR_WIDTH = 7;
+/** Horizontal padding inside a node box. */
+const NODE_PADDING = 16;
+/** The narrowest a node box gets. */
+const MIN_NODE_WIDTH = 24;
+/** How a channel's value names a node: dates as ISO strings, everything else as text. */
+function keyOf(value) {
+	if (value === null) return null;
+	return value instanceof Date ? value.toISOString() : String(value);
+}
+/**
+* Turns rows into a forest, checking the row-level rules `parseSpec` cannot:
+* ids are present and unique, every parent is an id, and there are no
+* cycles. Each error names the offending row (1-based), and is thrown, so
+* `resolveChart` shows it in place of the chart.
+*/
+function buildForest(data, id, parent, label) {
+	const idOf = makeAccessor(id);
+	const parentOf = makeAccessor(parent);
+	const labelOf = label === void 0 ? void 0 : makeAccessor(label);
+	const byId = /* @__PURE__ */ new Map();
+	const parents = /* @__PURE__ */ new Map();
+	data.forEach((datum, index) => {
+		const key = keyOf(idOf(datum));
+		if (key === null) throw new Error(`Tree row ${index + 1}: missing id`);
+		if (byId.has(key)) throw new Error(`Tree row ${index + 1}: duplicate id "${key}"`);
+		byId.set(key, {
+			id: key,
+			label: keyOf(labelOf?.(datum) ?? null) ?? key,
+			datum,
+			children: []
+		});
+		parents.set(key, keyOf(parentOf(datum)));
+	});
+	const roots = [];
+	data.forEach((datum, index) => {
+		const key = keyOf(idOf(datum)) ?? "";
+		const row = byId.get(key);
+		const parentKey = parents.get(key) ?? null;
+		if (row === void 0) return;
+		if (parentKey === null) {
+			roots.push(row);
+			return;
+		}
+		const parentRow = byId.get(parentKey);
+		if (parentRow === void 0) throw new Error(`Tree row ${index + 1}: parent "${parentKey}" is not an id`);
+		parentRow.children.push(row);
+	});
+	const reached = /* @__PURE__ */ new Set();
+	const visit = (row) => {
+		reached.add(row.id);
+		row.children.forEach(visit);
+	};
+	roots.forEach(visit);
+	const stranded = data.findIndex((datum) => !reached.has(keyOf(idOf(datum)) ?? ""));
+	if (stranded !== -1) throw new Error(`Tree row ${stranded + 1}: its parents form a cycle`);
+	return roots;
+}
+/**
+* Places the forest in unit coordinates: leaves take consecutive breadth
+* slots in depth-first order, and every parent sits centred over its first
+* and last child. Linear in the number of rows, never overlapping (siblings'
+* subtrees occupy disjoint slot ranges), and a forest's roots stand side by
+* side as if under one invisible root.
+*/
+function place(roots) {
+	const nodes = [];
+	let nextLeaf = 0;
+	let maxDepth = 0;
+	const walk = (row, depth, parent) => {
+		maxDepth = Math.max(maxDepth, depth);
+		const index = nodes.length;
+		nodes.push({
+			row,
+			slot: 0,
+			depth,
+			parent
+		});
+		if (row.children.length === 0) {
+			const leaf = {
+				row,
+				slot: nextLeaf,
+				depth,
+				parent
+			};
+			nextLeaf += 1;
+			nodes[index] = leaf;
+			return leaf;
+		}
+		const self = {
+			row,
+			slot: 0,
+			depth,
+			parent
+		};
+		nodes[index] = self;
+		const placed = row.children.map((child) => walk(child, depth + 1, self));
+		self.slot = ((placed[0]?.slot ?? 0) + (placed.at(-1)?.slot ?? 0)) / 2;
+		return self;
+	};
+	roots.forEach((root) => walk(root, 0, void 0));
+	return {
+		nodes,
+		leaves: Math.max(nextLeaf, 1),
+		depth: maxDepth
+	};
+}
+/** The nested depth-first structure of the forest: the interpreters' text alternative. */
+function outlineOf(rows, color) {
+	const categoryOf = color === void 0 ? void 0 : makeAccessor(color);
+	return rows.map((row) => ({
+		id: row.id,
+		label: row.label,
+		category: keyOf(categoryOf?.(row.datum) ?? null) ?? void 0,
+		children: outlineOf(row.children, color)
+	}));
+}
+/** An SVG path from a parent's edge to a child's, along the depth axis. */
+function linkPath(from, to, vertical, curved) {
+	if (vertical) {
+		const x1 = from.x + from.width / 2;
+		const y1 = from.y + from.height;
+		const x2 = to.x + to.width / 2;
+		const y2 = to.y;
+		const mid = (y1 + y2) / 2;
+		return curved ? `M${x1},${y1}C${x1},${mid} ${x2},${mid} ${x2},${y2}` : `M${x1},${y1}V${mid}H${x2}V${y2}`;
+	}
+	const x1 = from.x + from.width;
+	const y1 = from.y + from.height / 2;
+	const x2 = to.x;
+	const y2 = to.y + to.height / 2;
+	const mid = (x1 + x2) / 2;
+	return curved ? `M${x1},${y1}C${mid},${y1} ${mid},${y2} ${x2},${y2}` : `M${x1},${y1}H${mid}V${y2}H${x2}`;
+}
+/** A placed node's box in plot pixels: sized from its label, centred in its slot, at its depth's level. */
+function boxOf(node, frame, color) {
+	const { vertical, depth, length, slotSize } = frame;
+	const levelSize = depth === 0 ? 0 : length / depth;
+	const estimate = node.row.label.length * CHAR_WIDTH + NODE_PADDING;
+	const width = vertical ? Math.max(Math.min(estimate, slotSize - 4), MIN_NODE_WIDTH) : Math.max(Math.min(estimate, Math.max(levelSize - 16, MIN_NODE_WIDTH)), MIN_NODE_WIDTH);
+	const height = vertical ? NODE_HEIGHT : Math.min(NODE_HEIGHT, slotSize - 4);
+	const centreBreadth = (node.slot + .5) * slotSize;
+	const depthStart = depth === 0 ? 0 : node.depth / depth * (length - (vertical ? height : width));
+	return {
+		id: node.row.id,
+		label: node.row.label,
+		depth: node.depth,
+		x: vertical ? centreBreadth - width / 2 : depthStart,
+		y: vertical ? depthStart : centreBreadth - height / 2,
+		width,
+		height,
+		color,
+		datum: node.row.datum
+	};
+}
+/** One link per non-root node, from its parent's box to its own. */
+function linksOf(nodes, boxes, vertical, curved) {
+	return nodes.flatMap((node) => {
+		const box = boxes.get(node);
+		const parentBox = node.parent === void 0 ? void 0 : boxes.get(node.parent);
+		return box === void 0 || parentBox === void 0 ? [] : [{
+			from: parentBox.id,
+			to: box.id,
+			path: linkPath(parentBox, box, vertical, curved)
+		}];
+	});
+}
+/**
+* Builds a `tree` mark's geometry (spec 1.1): node boxes, the links between
+* them and the nested outline the interpreters render as the accessible
+* text alternative. Pure and DOM-free; label widths are estimated from
+* character counts, as the pure path's tick layout does.
+*
+* @throws {Error} on a duplicate or missing id, an unknown parent, or a cycle; the message names the row.
+*/
+function buildTreeGeometry(args) {
+	const roots = buildForest(args.data, args.id, args.parent, args.label);
+	const { nodes, leaves, depth } = place(roots);
+	const vertical = args.options?.orientation !== "horizontal";
+	const curved = args.options?.linkStyle === "curved";
+	const breadth = vertical ? args.plot.width : args.plot.height;
+	const frame = {
+		vertical,
+		depth,
+		length: vertical ? args.plot.height : args.plot.width,
+		slotSize: breadth / leaves
+	};
+	const boxes = new Map(nodes.map((node) => [node, boxOf(node, frame, colorOfDatum(node.row.datum, args.color, args.colorScale))]));
+	const links = linksOf(nodes, boxes, vertical, curved);
+	return {
+		mark: "tree",
+		nodes: nodes.map((node) => boxes.get(node)).filter((box) => box !== void 0),
+		links,
+		outline: outlineOf(roots, args.color)
+	};
+}
+// src/core/layout.ts
+/** Default margins, leaving room for axis ticks and labels. */
+const DEFAULT_MARGINS = {
+	top: 20,
+	right: 20,
+	bottom: 40,
+	left: 48
+};
+/**
+* Computes chart dimensions from an outer box and optional margin overrides.
+*
+* Missing margins take their {@link DEFAULT_MARGINS} value. The plot area
+* never goes negative: its width and height are clamped at zero, while the
+* margins are kept as given.
+*/
+function computeDimensions(outer, margins) {
+	const resolved = {
+		...DEFAULT_MARGINS,
+		...margins
+	};
+	return {
+		outer,
+		margins: resolved,
+		plot: {
+			width: Math.max(0, outer.width - resolved.left - resolved.right),
+			height: Math.max(0, outer.height - resolved.top - resolved.bottom)
+		}
+	};
+}
+// src/core/ticks.ts
+/** Default tick count for continuous scales. */
+const DEFAULT_TICK_COUNT = 5;
+/**
+* Computes axis ticks for a positional scale.
+*
+* - Continuous scales (linear, UTC) use d3's tick generation and formatting.
+*   UTC formatting is deterministic across machines and time zones.
+* - Categorical scales (band, point) emit one tick per category, centred on
+*   the band.
+*/
+function computeTicks(scale, count = 5) {
+	switch (scale.kind) {
+		case "linear": {
+			const format = scale.d3.tickFormat(count);
+			return scale.d3.ticks(count).map((value) => ({
+				value,
+				position: scale.d3(value),
+				label: format(value)
+			}));
+		}
+		case "utc": {
+			const format = scale.d3.tickFormat(count);
+			return scale.d3.ticks(count).map((value) => ({
+				value,
+				position: scale.d3(value),
+				label: format(value)
+			}));
+		}
+		case "band": {
+			const bandwidth = scale.d3.bandwidth();
+			return scale.d3.domain().map((value) => ({
+				value,
+				position: (scale.d3(value) ?? 0) + bandwidth / 2,
+				label: value
+			}));
+		}
+		case "point": return scale.d3.domain().map((value) => ({
+			value,
+			position: scale.d3(value) ?? 0,
+			label: value
+		}));
+	}
+}
+// src/core/context.ts
+/**
+* The Layer 2 entry point: turns (spec, measured box, resolved data) into
+* everything an interpreter needs to draw — dimensions, scales, geometry,
+* and ticks.
+*
+* Pure and synchronous: no DOM, no reactivity, no rendering, no data
+* fetching. When the spec's data is a reference (`data.ref`), the host must
+* resolve it and pass the rows; this function never fetches.
+*
+* @param spec - A parsed portable chart spec.
+* @param box - The measured outer pixel box available to the chart.
+* @param data - Resolved data rows. Optional when the spec carries inline values.
+* @param options - Layout options (margins).
+*
+* @throws {Error} when no data rows are available (spec has a ref and no rows were passed).
+* @throws {TypeError} when a datum value contradicts its channel's declared type.
+*/
+function computeContext(spec, box, data, options) {
+	const rows = resolveRows(spec, data);
+	const dimensions = computeDimensions(box, options?.margins);
+	const xPositional = spec.encoding.x ? resolvePositionalScale(spec.encoding.x, spec.mark, [0, dimensions.plot.width], rows, spec.scales?.x, spec.encoding.x2) : void 0;
+	const yPositional = spec.encoding.y ? resolvePositionalScale(spec.encoding.y, spec.mark, [dimensions.plot.height, 0], rows, spec.scales?.y, spec.encoding.y2) : void 0;
+	const colorScale = spec.encoding.color ? resolveColorScale(spec.encoding.color, rows) : void 0;
+	const sizeScale = spec.encoding.size ? resolveSizeScale(spec.encoding.size, rows) : void 0;
+	return {
+		dimensions,
+		scales: buildScales(xPositional, yPositional, colorScale, sizeScale),
+		geometry: spec.mark === "tree" ? buildTreeMark(spec, rows, dimensions.plot, colorScale) : buildGeometry(spec, rows, xPositional, yPositional, colorScale, sizeScale),
+		ticks: buildTicks(xPositional, yPositional)
+	};
+}
+function resolveRows(spec, data) {
+	if (data) return data;
+	if (isInlineData(spec.data)) return spec.data.values;
+	throw new Error(`Chart data is a ${spec.data.ref.kind} reference ("${spec.data.ref.id}"); the host must resolve it and pass rows to computeContext`);
+}
+function buildScales(x, y, color, size) {
+	return {
+		...x ? { x: x.resolved } : {},
+		...y ? { y: y.resolved } : {},
+		...color ? { color } : {},
+		...size ? { size } : {}
+	};
+}
+function buildTicks(x, y) {
+	return {
+		...x ? { x: computeTicks(x) } : {},
+		...y ? { y: computeTicks(y) } : {}
+	};
+}
+/** A `tree` mark's geometry; `parseSpec` has guaranteed its `id` and `parent` channels. */
+function buildTreeMark(spec, rows, plot, colorScale) {
+	const { id, parent, label, color } = spec.encoding;
+	if (id === void 0 || parent === void 0) return {
+		mark: "tree",
+		nodes: [],
+		links: [],
+		outline: []
+	};
+	return buildTreeGeometry({
+		data: rows,
+		plot,
+		id,
+		parent,
+		label,
+		color,
+		colorScale,
+		options: spec.tree
+	});
+}
+function buildGeometry(spec, rows, xScale, yScale, colorScale, sizeScale) {
+	if (!spec.encoding.x || !spec.encoding.y || !xScale || !yScale) return emptyGeometry(spec.mark);
+	const args = {
+		data: rows,
+		x: spec.encoding.x,
+		y: spec.encoding.y,
+		xScale,
+		yScale,
+		color: spec.encoding.color,
+		colorScale
+	};
+	switch (spec.mark) {
+		case "line": return buildLineGeometry(args);
+		case "area": return buildAreaGeometry(args);
+		case "bar": return buildBarGeometry({
+			...args,
+			x2: spec.encoding.x2,
+			y2: spec.encoding.y2
+		});
+		case "point": return buildPointGeometry({
+			...args,
+			size: spec.encoding.size,
+			sizeScale
+		});
+		case "tree": return emptyGeometry("tree");
+	}
+}
+function emptyGeometry(mark) {
+	switch (mark) {
+		case "line": return {
+			mark: "line",
+			series: []
+		};
+		case "area": return {
+			mark: "area",
+			series: []
+		};
+		case "bar": return {
+			mark: "bar",
+			bars: []
+		};
+		case "point": return {
+			mark: "point",
+			points: []
+		};
+		case "tree": return {
+			mark: "tree",
+			nodes: [],
+			links: [],
+			outline: []
+		};
+	}
+}
+// src/core/resolve.ts
+/**
+* Validates a spec and computes its geometry, turning every failure into a
+* message rather than a throw: an invalid spec, a data reference with no
+* resolved rows, or an error from {@link computeContext}. The bundled Svelte
+* `Chart` component is this function plus SVG.
+*/
+function resolveChart(spec, box, data, options) {
+	const validation = validateSpec(spec);
+	if (!validation.ok) return {
+		kind: "error",
+		message: `Invalid chart spec: ${validation.errors[0] ?? ""}`
+	};
+	if (isDataRef(validation.value.data) && !data) return {
+		kind: "error",
+		message: "Chart data is stored externally; pass resolved rows via the data prop"
+	};
+	try {
+		return {
+			kind: "ready",
+			spec: validation.value,
+			context: computeContext(validation.value, box, data, options)
+		};
+	} catch (error) {
+		return {
+			kind: "error",
+			message: error instanceof Error ? error.message : "Failed to compute chart"
+		};
+	}
+}
+export { buildBarGeometry as _, DEFAULT_MARGINS as a, makeAccessor as b, buildTreeGeometry as c, CATEGORICAL_PALETTE as d, DEFAULT_POINT_RADIUS as f, resolveSizeScale as g, resolvePositionalScale as h, computeTicks as i, outlineText as l, resolveColorScale as m, computeContext as n, computeDimensions as o, DEFAULT_RADIUS_RANGE as p, DEFAULT_TICK_COUNT as r, VISUALLY_HIDDEN_STYLE as s, resolveChart as t, buildPointGeometry as u, buildAreaGeometry as v, buildLineGeometry as y };
+
+//# sourceMappingURL=core-BVbfW7N6.mjs.map