@mstone6969/graph 0.0.0-stage → 0.1.0

package/dist/core/LiveStream.js

@@ -0,0 +1,179 @@
+import { DataShape, Dimension } from "./enums.js";
+// src/core/LiveStream.ts
+var SWEEP = 1024;
+/** Runs `fn` on the next animation frame, or a timer where there is none. */
+var nextFrame = (fn) => typeof requestAnimationFrame === "function" ? requestAnimationFrame(fn) : setTimeout(() => fn(Date.now()), 16);
+var cancelFrame = (id) => {
+	if (typeof cancelAnimationFrame === "function") cancelAnimationFrame(id);
+	else clearTimeout(id);
+};
+var stamp = (cell) => {
+	if (cell instanceof Date) return +cell;
+	if (typeof cell === "number") return cell;
+	return typeof cell === "string" ? Date.parse(cell) : NaN;
+};
+/**
+* Rows arriving over time: holds the live buffer, slides the window, and commits at most once per
+* animation frame. Supports flat rows and long-form series rows, on 2D table charts only.
+*/
+var LiveStream = class {
+	columns;
+	mounted;
+	commit;
+	#rows;
+	#window;
+	#keep;
+	#x;
+	#sweepAt = SWEEP;
+	#series = /* @__PURE__ */ new Set();
+	#frame = 0;
+	#dirty = false;
+	#paused = false;
+	#stopped = false;
+	/** Throws when a chart cannot take appended rows, naming what it can do instead. */
+	static assert(meta, data) {
+		const why = meta.dimension !== Dimension.Two ? "it is a 3D chart" : meta.shape !== DataShape.Table ? `its data shape is "${meta.shape}"` : data != null && !Array.isArray(data) ? "its data is not an array of rows" : "";
+		if (why) throw new Error(`${meta.name} (${meta.id}) cannot append: ${why}. append() supports rows and long-form series rows on 2D table charts. Use update({ data }) to replace the data.`);
+	}
+	constructor(seed, columns, mounted, commit) {
+		this.columns = columns;
+		this.mounted = mounted;
+		this.commit = commit;
+		this.#rows = [...seed ?? []];
+		this.#learn(this.#rows);
+	}
+	get paused() {
+		return this.#paused;
+	}
+	get stopped() {
+		return this.#stopped;
+	}
+	/** Rows held now, committed or not. */
+	get size() {
+		return this.#rows.length;
+	}
+	push(rows, { window, keep, x } = {}) {
+		if (this.#stopped) return;
+		const incoming = Array.isArray(rows) ? rows : [rows];
+		if (keep !== void 0 && !(Number.isInteger(keep) && keep > 0)) throw new RangeError(`append: keep must be a positive integer, got ${keep}`);
+		if (window !== void 0 && !(window > 0 && Number.isFinite(window))) throw new RangeError(`append: window must be a positive span, got ${window}`);
+		const span = window ?? this.#window, column = x ?? this.#x ?? this.columns().x;
+		if (span !== void 0 && column === void 0) throw new Error("append: window needs an x column; pass { x } naming it");
+		for (const row of incoming) this.#check(row, span === void 0 ? void 0 : column);
+		this.#window = span;
+		this.#keep = keep ?? this.#keep;
+		this.#x = x ?? this.#x;
+		for (const row of incoming) this.#rows.push(row);
+		this.#learn(incoming);
+		if (this.#rows.length > this.#sweepAt) this.#trim();
+		this.#dirty = true;
+		this.#schedule();
+	}
+	/** Commits now instead of on the next frame. Does nothing while paused. */
+	flush() {
+		if (this.#frame) cancelFrame(this.#frame);
+		this.#frame = 0;
+		if (!this.#dirty || this.#paused || this.#stopped) return;
+		this.#dirty = false;
+		this.#trim();
+		this.commit(this.#steady());
+	}
+	/** Freezes the picture. Rows keep arriving and sliding out of the window. */
+	pause() {
+		this.#paused = true;
+		if (this.#frame) cancelFrame(this.#frame);
+		this.#frame = 0;
+	}
+	resume() {
+		this.#paused = false;
+		this.#schedule();
+	}
+	/** The chart's data was replaced from outside. */
+	reset(rows) {
+		this.#rows = Array.isArray(rows) ? [...rows] : [];
+		this.#series.clear();
+		this.#learn(this.#rows);
+		this.#sweepAt = SWEEP;
+		this.#dirty = false;
+		if (this.#frame) cancelFrame(this.#frame);
+		this.#frame = 0;
+	}
+	/** Cancels pending work and, unless `open`, ignores later rows, as when a socket outlives its chart. */
+	stop(open = false) {
+		this.#stopped = !open;
+		if (this.#frame) cancelFrame(this.#frame);
+		this.#frame = 0;
+	}
+	/** Reopens a stopped stream for a chart being mounted, carrying rows held so far. */
+	start() {
+		this.#stopped = false;
+		this.flush();
+	}
+	#schedule() {
+		if (this.#frame || !this.#dirty || this.#paused || this.#stopped || !this.mounted()) return;
+		this.#frame = nextFrame(() => {
+			this.#frame = 0;
+			this.flush();
+		});
+	}
+	get #xColumn() {
+		return this.#x ?? this.columns().x;
+	}
+	#check(row, column) {
+		if (row === null || typeof row !== "object" || Array.isArray(row)) throw new TypeError(`append: expected row objects, got ${JSON.stringify(row)}`);
+		if (column === void 0) return;
+		const cell = row[column];
+		if (cell != null && !Number.isFinite(stamp(cell))) throw new TypeError(`append: window needs dates or numbers in column "${column}", got ${String(cell)}`);
+	}
+	#trim() {
+		if (this.#window !== void 0) this.#slide(this.#window);
+		if (this.#keep !== void 0) this.#cap(this.#keep);
+		this.#sweepAt = Math.max(SWEEP, this.#rows.length * 2);
+	}
+	#slide(span) {
+		const column = this.#xColumn;
+		let newest = -Infinity;
+		for (const row of this.#rows) {
+			const at = stamp(row[column]);
+			if (at > newest) newest = at;
+		}
+		this.#rows = this.#rows.filter((row) => stamp(row[column]) >= newest - span);
+	}
+	/**
+	* Charts read series in first-seen order, and trimming rotates which series is oldest, so colours
+	* and stacks would swap every frame. Once that happens, each series' oldest row leads, in the order series arrived.
+	*/
+	#steady() {
+		const { series } = this.columns();
+		if (series === void 0) return this.#rows.slice();
+		const first = /* @__PURE__ */ new Map();
+		this.#rows.forEach((row, i) => {
+			if (!first.has(row[series])) first.set(row[series], i);
+		});
+		for (const key of first.keys()) this.#series.add(key);
+		for (const key of this.#series) if (!first.has(key)) this.#series.delete(key);
+		const leads = [...this.#series].map((key) => first.get(key)), led = new Set(leads);
+		if (leads.every((at, i) => !i || leads[i - 1] < at)) return this.#rows.slice();
+		return [...leads.map((i) => this.#rows[i]), ...this.#rows.filter((_, i) => !led.has(i))];
+	}
+	#learn(rows) {
+		const { series } = this.columns();
+		if (series !== void 0) for (const row of rows) this.#series.add(row[series]);
+	}
+	/** Walks back from the newest row, so each series keeps its latest `limit`. */
+	#cap(limit) {
+		const { series } = this.columns();
+		const counts = /* @__PURE__ */ new Map();
+		const kept = [];
+		for (let i = this.#rows.length - 1; i >= 0; i--) {
+			const row = this.#rows[i];
+			const key = series === void 0 ? void 0 : row[series];
+			const count = counts.get(key) ?? 0;
+			if (count >= limit) continue;
+			counts.set(key, count + 1);
+			kept.push(row);
+		}
+		this.#rows = kept.reverse();
+	}
+};
+export { LiveStream, cancelFrame, nextFrame };

package/dist/core/Palette.js

@@ -0,0 +1,49 @@
+import { color, interpolateRgb, interpolateRgbBasis } from "d3";
+// src/core/Palette.ts
+/** Assigns colours by job. Categorical colour follows the entity in first-seen order, folding past 8 into "Other". */
+var Palette = class {
+	tokens;
+	seats;
+	keys = /* @__PURE__ */ new Map();
+	ramp;
+	/** `seats` holds each key's place across palettes, for a stream whose series come and go. */
+	constructor(tokens, seats) {
+		this.tokens = tokens;
+		this.seats = seats;
+		this.ramp = interpolateRgbBasis([...tokens.sequential]);
+	}
+	color = (key) => {
+		let hit = this.keys.get(key);
+		if (!hit) {
+			hit = this.tokens.categorical[this.seat(key)] ?? this.tokens.inkMuted;
+			this.keys.set(key, hit);
+		}
+		return hit;
+	};
+	seat(key) {
+		const { seats, tokens: { categorical: { length } } } = this;
+		if (!seats) return this.keys.size;
+		if (!seats.has(key) && seats.size < length) seats.set(key, seats.size);
+		return seats.get(key) ?? length;
+	}
+	/** Magnitude: `t` in 0..1, one hue from near-surface to strong. */
+	sequential = (t) => this.ramp(Math.max(0, Math.min(1, t)));
+	/** Polarity: `t` in -1..1, grey at zero. */
+	diverging = (t) => {
+		const pole = t < 0 ? this.tokens.divergingLow : this.tokens.divergingHigh;
+		return interpolateRgb(this.tokens.divergingMid, pole)(Math.min(1, Math.abs(t)));
+	};
+	/** Ink that stays legible on top of a filled mark. */
+	inkOn = (fill) => {
+		const rgb = color(fill)?.rgb();
+		if (!rgb) return "#ffffff";
+		return .299 * rgb.r + .587 * rgb.g + .114 * rgb.b > 150 ? "#0b0b0b" : "#ffffff";
+	};
+	items() {
+		return [...this.keys].map(([key, color]) => ({
+			key,
+			color
+		}));
+	}
+};
+export { Palette };

package/dist/core/RadialChart.js

@@ -0,0 +1,14 @@
+import { Chart2D } from "./Chart2D.js";
+// src/core/RadialChart.ts
+/** Polar charts: `ctx.root` is translated to the centre of the plot before `drawRadial`. */
+var RadialChart = class extends Chart2D {
+	draw(ctx) {
+		const center = [ctx.plot.width / 2, ctx.plot.height / 2];
+		const radius = Math.min(ctx.plot.width, ctx.plot.height) / 2;
+		this.drawRadial(ctx.nest(`translate(${center[0]},${center[1]})`), {
+			radius,
+			center
+		});
+	}
+};
+export { RadialChart };

package/dist/core/Scales.js

@@ -0,0 +1,51 @@
+import { CurveKind, ScaleKind, SymbolKind } from "./enums.js";
+import { curveBasis, curveBumpX, curveCardinal, curveCatmullRom, curveLinear, curveMonotoneX, curveNatural, curveStep, curveStepAfter, curveStepBefore, scaleLinear, scaleLog, scalePow, scaleSqrt, scaleSymlog, symbolCircle, symbolCross, symbolDiamond, symbolSquare, symbolStar, symbolTriangle, symbolWye } from "d3";
+// src/core/Scales.ts
+var CURVES = {
+	[CurveKind.Linear]: curveLinear,
+	[CurveKind.Monotone]: curveMonotoneX,
+	[CurveKind.Step]: curveStep,
+	[CurveKind.StepBefore]: curveStepBefore,
+	[CurveKind.StepAfter]: curveStepAfter,
+	[CurveKind.Natural]: curveNatural,
+	[CurveKind.Cardinal]: curveCardinal,
+	[CurveKind.CatmullRom]: curveCatmullRom,
+	[CurveKind.Basis]: curveBasis,
+	[CurveKind.Bump]: curveBumpX
+};
+var SYMBOLS = {
+	[SymbolKind.Circle]: symbolCircle,
+	[SymbolKind.Square]: symbolSquare,
+	[SymbolKind.Diamond]: symbolDiamond,
+	[SymbolKind.Triangle]: symbolTriangle,
+	[SymbolKind.Cross]: symbolCross,
+	[SymbolKind.Star]: symbolStar,
+	[SymbolKind.Wye]: symbolWye
+};
+/** Maps library enums to d3 factories. */
+var Scales = class {
+	static curve(kind = CurveKind.Linear) {
+		return CURVES[kind];
+	}
+	static symbol(kind = SymbolKind.Circle) {
+		return SYMBOLS[kind];
+	}
+	static continuous(kind = ScaleKind.Linear) {
+		switch (kind) {
+			case ScaleKind.Log: return scaleLog();
+			case ScaleKind.Sqrt: return scaleSqrt();
+			case ScaleKind.Pow: return scalePow().exponent(2);
+			case ScaleKind.Symlog: return scaleSymlog();
+			default: return scaleLinear();
+		}
+	}
+	/** Clean axis ticks: full below 10,000, compact above. */
+	static format(value, reach) {
+		if (reach >= 1e4) return Intl.NumberFormat("en", {
+			notation: "compact",
+			maximumFractionDigits: 1
+		}).format(value);
+		return value.toLocaleString("en", { maximumFractionDigits: reach < 10 ? 2 : 0 });
+	}
+};
+export { Scales };

package/dist/core/SceneOverlay.js

@@ -0,0 +1,63 @@
+import { Vector3 } from "three";
+// src/core/SceneOverlay.ts
+var INSET = {
+	x: 14,
+	y: 10
+};
+var SWATCH = 10;
+var LINE_HEIGHT = 1.25;
+/** Draws a 3D chart's HTML text onto a canvas: labels, title and legend live outside the WebGL frame. */
+var SceneOverlay = class SceneOverlay {
+	static paint(paint, scene, camera, size, scale, theme, header) {
+		paint.save();
+		paint.scale(scale, scale);
+		paint.textBaseline = "middle";
+		SceneOverlay.#labels(paint, scene, camera, size);
+		SceneOverlay.#header(paint, size, theme, header);
+		paint.restore();
+	}
+	static #labels(paint, scene, camera, { width, height }) {
+		const at = new Vector3();
+		scene.updateMatrixWorld(true);
+		scene.traverseVisible((object) => {
+			if (!object.isCSS2DObject) return;
+			const { element, center } = object;
+			object.onBeforeRender(null, scene, camera);
+			at.setFromMatrixPosition(object.matrixWorld).project(camera);
+			if (at.z < -1 || at.z > 1 || !element.textContent || element.style.opacity === "0") return;
+			paint.font = element.style.font;
+			paint.fillStyle = element.style.color;
+			const box = paint.measureText(element.textContent);
+			paint.fillText(element.textContent, (at.x + 1) / 2 * width - center.x * box.width, (1 - at.y) / 2 * height + (.5 - center.y) * parseFloat(element.style.fontSize || "11") * LINE_HEIGHT);
+		});
+	}
+	static #header(paint, { width }, theme, { title, subtitle, items }) {
+		let y = INSET.y;
+		const line = (text, font, color, size) => {
+			paint.font = font;
+			paint.fillStyle = color;
+			paint.fillText(text, INSET.x, y + size * LINE_HEIGHT / 2);
+			y += size * LINE_HEIGHT;
+		};
+		if (title) line(title, `600 15px ${theme.fontFamily}`, theme.ink, 15);
+		if (subtitle) line(subtitle, `12px ${theme.fontFamily}`, theme.inkSecondary, 12);
+		paint.font = `12px ${theme.fontFamily}`;
+		let x = INSET.x;
+		y += items.length ? 13 : 0;
+		for (const { key, label, color } of items) {
+			const text = label ?? key, cost = 15 + paint.measureText(text).width + 12;
+			if (x > INSET.x && x + cost > width - INSET.x) {
+				x = INSET.x;
+				y += 18;
+			}
+			paint.fillStyle = color;
+			paint.beginPath();
+			paint.roundRect(x, y - SWATCH / 2, SWATCH, SWATCH, 3);
+			paint.fill();
+			paint.fillStyle = theme.inkSecondary;
+			paint.fillText(text, x + SWATCH + 5, y);
+			x += cost;
+		}
+	}
+};
+export { SceneOverlay };

package/dist/core/Theme.js

@@ -0,0 +1,75 @@
+import { ThemeMode } from "./enums.js";
+// src/core/Theme.ts
+var SEQUENTIAL = [
+	"#cde2fb",
+	"#9ec5f4",
+	"#6da7ec",
+	"#3987e5",
+	"#256abf",
+	"#184f95",
+	"#0d366b"
+];
+var STATUS = {
+	good: "#0ca30c",
+	warning: "#fab219",
+	serious: "#ec835a",
+	critical: "#d03b3b"
+};
+var FONT = "ui-sans-serif, system-ui, -apple-system, \"Segoe UI\", sans-serif";
+/** Colour tokens for both modes. Palette order is CVD-validated: never reorder or cycle it. */
+var Theme = class Theme {
+	static light = {
+		surface: "#fcfcfb",
+		ink: "#0b0b0b",
+		inkSecondary: "#52514e",
+		inkMuted: "#8a8984",
+		grid: "#e8e7e2",
+		axis: "#c3c2b7",
+		categorical: [
+			"#2a78d6",
+			"#eb6834",
+			"#1baf7a",
+			"#eda100",
+			"#e87ba4",
+			"#008300",
+			"#6250d6",
+			"#e34948"
+		],
+		sequential: SEQUENTIAL,
+		divergingLow: "#2a78d6",
+		divergingHigh: "#e34948",
+		divergingMid: "#f0efec",
+		...STATUS,
+		fontFamily: FONT
+	};
+	static dark = {
+		surface: "#1a1a19",
+		ink: "#f0efec",
+		inkSecondary: "#c3c2b7",
+		inkMuted: "#8a8984",
+		grid: "#2e2e2c",
+		axis: "#4a4a46",
+		categorical: [
+			"#3987e5",
+			"#d95926",
+			"#199e70",
+			"#c98500",
+			"#d55181",
+			"#008300",
+			"#9085e9",
+			"#e66767"
+		],
+		sequential: [...SEQUENTIAL].reverse(),
+		divergingLow: "#3987e5",
+		divergingHigh: "#e66767",
+		divergingMid: "#383835",
+		...STATUS,
+		fontFamily: FONT
+	};
+	static resolve(theme = ThemeMode.Auto) {
+		if (typeof theme === "object") return theme;
+		if (theme === ThemeMode.Auto) return globalThis.matchMedia?.("(prefers-color-scheme: dark)").matches ? Theme.dark : Theme.light;
+		return theme === ThemeMode.Dark ? Theme.dark : Theme.light;
+	}
+};
+export { Theme };

package/dist/core/Tooltip.js

@@ -0,0 +1,73 @@
+// src/core/Tooltip.ts
+/** One HTML tooltip per chart, positioned inside the chart's host. */
+var Tooltip = class {
+	host;
+	el;
+	constructor(host) {
+		this.host = host;
+		this.el = document.createElement("div");
+		this.el.setAttribute("role", "status");
+		Object.assign(this.el.style, {
+			position: "absolute",
+			pointerEvents: "none",
+			opacity: "0",
+			transition: "opacity 120ms",
+			zIndex: "10",
+			top: "0",
+			left: "0",
+			padding: "8px 10px",
+			borderRadius: "8px",
+			fontSize: "12px",
+			lineHeight: "1.5",
+			minWidth: "96px",
+			whiteSpace: "nowrap",
+			boxShadow: "0 4px 16px rgba(0,0,0,.14)"
+		});
+		host.appendChild(this.el);
+	}
+	show(event, content, theme) {
+		const { el, host } = this;
+		Object.assign(el.style, {
+			background: theme.surface,
+			color: theme.ink,
+			border: `1px solid ${theme.grid}`,
+			fontFamily: theme.fontFamily
+		});
+		el.replaceChildren();
+		if (content.title) {
+			const title = el.appendChild(document.createElement("div"));
+			title.textContent = content.title;
+			title.style.fontWeight = "600";
+			if (content.color) title.style.borderLeft = `3px solid ${content.color}`, title.style.paddingLeft = "6px";
+		}
+		for (const [label, value] of content.rows ?? []) {
+			const row = el.appendChild(document.createElement("div"));
+			Object.assign(row.style, {
+				display: "flex",
+				justifyContent: "space-between",
+				gap: "16px"
+			});
+			const name = row.appendChild(document.createElement("span"));
+			name.textContent = label;
+			name.style.color = theme.inkSecondary;
+			row.appendChild(document.createElement("span")).textContent = typeof value === "number" ? value.toLocaleString() : value;
+		}
+		const box = host.getBoundingClientRect();
+		const x = event.clientX - box.left, y = event.clientY - box.top;
+		const left = Math.min(x + 12, box.width - el.offsetWidth - 4), top = y - el.offsetHeight - 10;
+		el.style.transform = `translate(${Math.max(4, left)}px, ${top < 4 ? y + 14 : top}px)`;
+		el.style.opacity = "1";
+	}
+	hide() {
+		this.el.style.opacity = "0";
+	}
+	/** Stops assistive tech reading the box, for when a separate live region speaks instead. */
+	mute(muted) {
+		if (muted) this.el.setAttribute("aria-hidden", "true");
+		else this.el.removeAttribute("aria-hidden");
+	}
+	destroy() {
+		this.el.remove();
+	}
+};
+export { Tooltip };

package/dist/core/VariantSpace.js

@@ -0,0 +1,30 @@
+// src/core/VariantSpace.ts
+/** Expands a chart class's variant axes into its concrete chart types. */
+var VariantSpace = class VariantSpace {
+	static expand(chart) {
+		const { id, name, variants = {}, valid } = chart.meta;
+		const axes = Object.entries(variants);
+		const shared = new Set(axes.flatMap(([, values]) => values).filter((value, i, all) => all.indexOf(value) !== i));
+		return axes.reduce((all, [key, values]) => all.flatMap((combo) => values.map((value) => ({
+			...combo,
+			[key]: value
+		}))), [{}]).filter((values) => valid?.(values) ?? true).map((values) => {
+			const moved = axes.filter(([key, list]) => values[key] !== list[0]).map(([key]) => {
+				const slug = VariantSpace.slug(key, values[key]);
+				return shared.has(values[key]) && typeof values[key] === "string" ? `${key}-${slug}` : slug;
+			});
+			return {
+				id: [id, ...moved].join("."),
+				chart,
+				values,
+				name: [name, ...moved.map((part) => part.replaceAll("-", " "))].join(" · ")
+			};
+		});
+	}
+	static slug(key, value) {
+		if (value === true) return key;
+		if (value === false) return `no-${key}`;
+		return typeof value === "number" ? `${key}-${value}` : value;
+	}
+};
+export { VariantSpace };

package/dist/core/ZoomControls.js

@@ -0,0 +1,28 @@
+// src/core/ZoomControls.ts
+var BUTTON = 26;
+/** On-screen buttons in the top right of a plot, shared by maps and x/y charts. */
+var ZoomControls = class {
+	/** The plot area `count` buttons cover. */
+	static box(right, count) {
+		return {
+			x: right - BUTTON - 2,
+			y: 2,
+			width: BUTTON,
+			height: count * 28 - 2
+		};
+	}
+	static draw(ctx, right, items) {
+		const { theme } = ctx;
+		const buttons = ctx.marks("zoom-controls", "g", items, (d) => d.key).attr("transform", (_, i) => `translate(${right - BUTTON - 2},${2 + i * 28})`).attr("role", "button").attr("tabindex", 0).attr("aria-label", (d) => d.label).style("cursor", "pointer").on("mousedown.zoom touchstart.zoom dblclick.zoom wheel.zoom", (event) => event.stopPropagation()).on("click", (event, d) => {
+			event.stopPropagation();
+			d.run();
+		}).on("keydown", (event, d) => {
+			if (event.key !== "Enter" && event.key !== " ") return;
+			event.preventDefault();
+			d.run();
+		});
+		buttons.selectAll("rect").data([0]).join("rect").attr("width", BUTTON).attr("height", BUTTON).attr("rx", 6).attr("fill", theme.surface).attr("stroke", theme.axis).attr("stroke-opacity", .5);
+		ctx.text(buttons.selectAll("text").data((d) => [d.glyph]).join("text"), 15, "ink").attr("x", BUTTON / 2).attr("y", 18).attr("text-anchor", "middle").text((d) => d);
+	}
+};
+export { ZoomControls };

package/dist/core/enums.js

@@ -0,0 +1,107 @@
+// src/core/enums.ts
+/** What job a chart does; drives gallery grouping. */
+var ChartFamily = /* @__PURE__ */ function(ChartFamily) {
+	ChartFamily["Comparison"] = "comparison";
+	ChartFamily["Trend"] = "trend";
+	ChartFamily["Relationship"] = "relationship";
+	ChartFamily["Distribution"] = "distribution";
+	ChartFamily["Composition"] = "composition";
+	ChartFamily["Hierarchy"] = "hierarchy";
+	ChartFamily["Network"] = "network";
+	ChartFamily["Flow"] = "flow";
+	ChartFamily["Matrix"] = "matrix";
+	ChartFamily["Geospatial"] = "geospatial";
+	ChartFamily["Temporal"] = "temporal";
+	ChartFamily["Financial"] = "financial";
+	ChartFamily["Statistical"] = "statistical";
+	ChartFamily["Scientific"] = "scientific";
+	ChartFamily["Mathematical"] = "mathematical";
+	ChartFamily["Radial"] = "radial";
+	ChartFamily["Indicator"] = "indicator";
+	ChartFamily["Pictorial"] = "pictorial";
+	ChartFamily["Text"] = "text";
+	ChartFamily["Project"] = "project";
+	ChartFamily["Volumetric"] = "volumetric";
+	return ChartFamily;
+}({});
+var Dimension = /* @__PURE__ */ function(Dimension) {
+	Dimension[Dimension["Two"] = 2] = "Two";
+	Dimension[Dimension["Three"] = 3] = "Three";
+	return Dimension;
+}({});
+var DataShape = /* @__PURE__ */ function(DataShape) {
+	DataShape["Table"] = "table";
+	DataShape["Hierarchy"] = "hierarchy";
+	DataShape["Graph"] = "graph";
+	DataShape["Matrix"] = "matrix";
+	DataShape["Grid"] = "grid";
+	DataShape["Volume"] = "volume";
+	DataShape["Geo"] = "geo";
+	DataShape["Function"] = "function";
+	DataShape["Text"] = "text";
+	DataShape["Genome"] = "genome";
+	return DataShape;
+}({});
+var Orientation = /* @__PURE__ */ function(Orientation) {
+	Orientation["Vertical"] = "vertical";
+	Orientation["Horizontal"] = "horizontal";
+	return Orientation;
+}({});
+var StackMode = /* @__PURE__ */ function(StackMode) {
+	StackMode["None"] = "grouped";
+	StackMode["Stacked"] = "stacked";
+	StackMode["Normalized"] = "normalized";
+	StackMode["Streamgraph"] = "streamgraph";
+	return StackMode;
+}({});
+var CurveKind = /* @__PURE__ */ function(CurveKind) {
+	CurveKind["Linear"] = "linear";
+	CurveKind["Monotone"] = "monotone";
+	CurveKind["Step"] = "step";
+	CurveKind["StepBefore"] = "step-before";
+	CurveKind["StepAfter"] = "step-after";
+	CurveKind["Natural"] = "natural";
+	CurveKind["Cardinal"] = "cardinal";
+	CurveKind["CatmullRom"] = "catmull-rom";
+	CurveKind["Basis"] = "basis";
+	CurveKind["Bump"] = "bump";
+	return CurveKind;
+}({});
+var ScaleKind = /* @__PURE__ */ function(ScaleKind) {
+	ScaleKind["Linear"] = "linear";
+	ScaleKind["Log"] = "log";
+	ScaleKind["Sqrt"] = "sqrt";
+	ScaleKind["Pow"] = "pow";
+	ScaleKind["Symlog"] = "symlog";
+	return ScaleKind;
+}({});
+var SymbolKind = /* @__PURE__ */ function(SymbolKind) {
+	SymbolKind["Circle"] = "circle";
+	SymbolKind["Square"] = "square";
+	SymbolKind["Diamond"] = "diamond";
+	SymbolKind["Triangle"] = "triangle";
+	SymbolKind["Cross"] = "cross";
+	SymbolKind["Star"] = "star";
+	SymbolKind["Wye"] = "wye";
+	return SymbolKind;
+}({});
+var LegendPosition = /* @__PURE__ */ function(LegendPosition) {
+	LegendPosition["None"] = "none";
+	LegendPosition["Top"] = "top";
+	LegendPosition["Bottom"] = "bottom";
+	LegendPosition["Right"] = "right";
+	return LegendPosition;
+}({});
+var ThemeMode = /* @__PURE__ */ function(ThemeMode) {
+	ThemeMode["Light"] = "light";
+	ThemeMode["Dark"] = "dark";
+	ThemeMode["Auto"] = "auto";
+	return ThemeMode;
+}({});
+var ColorScale = /* @__PURE__ */ function(ColorScale) {
+	ColorScale["Sequential"] = "sequential";
+	ColorScale["Diverging"] = "diverging";
+	ColorScale["Categorical"] = "categorical";
+	return ColorScale;
+}({});
+export { ChartFamily, ColorScale, CurveKind, DataShape, Dimension, LegendPosition, Orientation, ScaleKind, StackMode, SymbolKind, ThemeMode };