@mstone6969/graph 0.0.0-stage → 0.2.0

package/dist/charts/linesareas/HorizonChart.js

@@ -0,0 +1,134 @@
+import { ChartFamily, CurveKind, DataShape, Dimension, LegendPosition } from "../../core/enums.js";
+import { SampleData } from "../../data/SampleData.js";
+import { AreaBaseline, HorizonMode, HorizonScale } from "./LineEnums.js";
+import { TrendChart } from "./TrendChart.js";
+import { TrendLabels } from "./TrendLabels.js";
+import { TrendMath } from "./TrendMath.js";
+import { area, mean, scaleBand, select } from "d3";
+// src/charts/linesareas/HorizonChart.ts
+/** Many time series in very little height. Values fold into darker bands, so spikes stay visible at 20px per row. */
+var HorizonChart = class extends TrendChart {
+	static meta = {
+		id: "horizon",
+		name: "Horizon chart",
+		family: ChartFamily.Trend,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Slices each series into layered colour bands so that many time series fit in compact, comparable rows.",
+		tags: [
+			"monitoring",
+			"dense",
+			"folded area"
+		],
+		sample: (seed) => SampleData.timeSeries(seed, 60, 6),
+		variants: {
+			bands: [
+				3,
+				2,
+				4,
+				5
+			],
+			mode: [HorizonMode.Mirror, HorizonMode.Offset],
+			baseline: [
+				AreaBaseline.Mean,
+				AreaBaseline.First,
+				AreaBaseline.Zero
+			],
+			curve: [
+				CurveKind.Monotone,
+				CurveKind.Linear,
+				CurveKind.StepAfter
+			],
+			rowScale: [HorizonScale.Shared, HorizonScale.Independent]
+		}
+	};
+	defaults() {
+		return {
+			...super.defaults(),
+			bands: 3,
+			mode: HorizonMode.Mirror,
+			baseline: AreaBaseline.Mean,
+			rowScale: HorizonScale.Shared,
+			grid: false
+		};
+	}
+	get legended() {
+		return this.view.length > 0;
+	}
+	get legendPosition() {
+		return this.options.legend ?? LegendPosition.Top;
+	}
+	plotMargin() {
+		return {
+			...super.plotMargin(),
+			left: Math.min(92, 14 + Math.max(4, ...this.view.map((s) => s.key.length)) * 6.2)
+		};
+	}
+	legendItems() {
+		return [{
+			key: "Above baseline",
+			color: this.palette.diverging(TrendMath.polarity(1, .8))
+		}, {
+			key: "Below baseline",
+			color: this.palette.diverging(TrendMath.polarity(-1, .8))
+		}];
+	}
+	/** Each series as its signed deviation from the baseline. */
+	shape(table) {
+		const { baseline } = this.options;
+		return table.series.map((s) => {
+			const known = s.points.filter((p) => p.y !== null);
+			const level = baseline === AreaBaseline.Zero ? 0 : baseline === AreaBaseline.Mean ? mean(known, (p) => p.y) ?? 0 : known[0]?.y ?? 0;
+			return {
+				key: s.key,
+				points: s.points.map((p) => ({
+					...p,
+					raw: p.y,
+					y: p.y === null ? null : p.y - level
+				}))
+			};
+		});
+	}
+	scales(ctx) {
+		return {
+			x: this.xAxis([0, ctx.plot.width]),
+			y: scaleBand(this.view.map((s) => s.key), [0, ctx.plot.height]).paddingInner(.1)
+		};
+	}
+	tickFormat(scale) {
+		return typeof scale.domain?.()[0] === "string" ? (value) => TrendLabels.fit(String(value), 78) : super.tickFormat(scale);
+	}
+	reach(points) {
+		return Math.max(1e-9, ...points.map((p) => Math.abs(p.y ?? 0)));
+	}
+	plotMarks(ctx, axes) {
+		const { bands, mode, rowScale } = this.options;
+		const series = this.view;
+		const height = axes.y.bandwidth();
+		const shared = this.reach(series.flatMap((s) => s.points));
+		const chart = this;
+		ctx.marks("rows", "g", series, (s) => s.key).attr("transform", (s) => `translate(0,${axes.y(s.key) ?? 0})`).each(function(s, row) {
+			const group = select(this);
+			const step = (rowScale === HorizonScale.Shared ? shared : chart.reach(s.points)) / bands;
+			const layers = [1, -1].flatMap((sign) => Array.from({ length: bands }, (_, band) => ({
+				sign,
+				band
+			})));
+			const clip = chart.clipTo(ctx, `row-${row}`, `M0,0H${ctx.plot.width}V${height}H0Z`, group);
+			const paths = ctx.marks("layers", "path", layers, (d) => `${d.sign}/${d.band}`, group).attr("clip-path", clip).attr("fill", (d) => ctx.palette.diverging(TrendMath.polarity(d.sign, (d.band + 1) / bands)));
+			const known = s.points.filter(chart.drawn);
+			const hanging = (d) => mode === HorizonMode.Offset && d.sign < 0;
+			const shape = (d, flat = false) => {
+				const depth = (p) => flat ? 0 : (p.y * d.sign - d.band * step) / step * height;
+				const edge = hanging(d) ? 0 : height;
+				return area().x((p) => chart.px(axes, p)).y0(edge).y1((p) => hanging(d) ? depth(p) : height - depth(p)).curve(chart.curveOf())(known) ?? "";
+			};
+			ctx.set(paths, { d: (d) => shape(d) }, { d: (d) => shape(d, true) });
+		});
+		this.hoverColumns(ctx, axes, series, {
+			place: (p, s) => [this.px(axes, p), (axes.y(s.key) ?? 0) + height / 2],
+			color: () => ctx.theme.inkSecondary
+		});
+	}
+};
+export { HorizonChart };

package/dist/charts/linesareas/IndexedLine.js

@@ -0,0 +1,94 @@
+import { ChartFamily, CurveKind, DataShape, Dimension, ScaleKind } from "../../core/enums.js";
+import { SampleData } from "../../data/SampleData.js";
+import { IndexBase, LineLabels, LineMarkers } from "./LineEnums.js";
+import { TrendChart } from "./TrendChart.js";
+// src/charts/linesareas/IndexedLine.ts
+var LEVEL = 100;
+/** Rebases each series to 100 so that growth compares fairly across different units. Prefer the log scale: equal distance is equal growth. */
+var IndexedLine = class extends TrendChart {
+	static meta = {
+		id: "indexed-line",
+		name: "Indexed line",
+		family: ChartFamily.Trend,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Rebases every series to 100 at a chosen point to compare relative growth across different magnitudes.",
+		tags: [
+			"rebased",
+			"growth",
+			"performance"
+		],
+		sample: (seed) => SampleData.timeSeries(seed, 60, 4),
+		variants: {
+			base: [
+				IndexBase.First,
+				IndexBase.Middle,
+				IndexBase.Last
+			],
+			scale: [ScaleKind.Log, ScaleKind.Linear],
+			curve: [
+				CurveKind.Monotone,
+				CurveKind.CatmullRom,
+				CurveKind.Basis
+			],
+			labels: [LineLabels.Direct, LineLabels.Legend],
+			markers: [LineMarkers.None, LineMarkers.Ends],
+			rule: [true, false]
+		}
+	};
+	defaults() {
+		return {
+			...super.defaults(),
+			scale: ScaleKind.Log,
+			base: IndexBase.First,
+			labels: LineLabels.Direct,
+			markers: LineMarkers.None,
+			rule: true
+		};
+	}
+	get direct() {
+		return this.options.labels === LineLabels.Direct;
+	}
+	get slot() {
+		const { base } = this.options;
+		const last = this.source.xs.length - 1;
+		return base === IndexBase.First ? 0 : base === IndexBase.Last ? last : Math.floor(last / 2);
+	}
+	shape(table) {
+		const anchor = table.xs[this.slot]?.order;
+		return table.series.flatMap((s) => {
+			const known = s.points.filter((p) => p.y !== null && p.y > 0);
+			const pivot = known.reduce((best, p) => best === null || Math.abs(p.order - anchor) < Math.abs(best - anchor) ? p.order : best, null);
+			const level = known.find((p) => p.order === pivot)?.y;
+			return level ? [{
+				key: s.key,
+				points: s.points.map((p) => ({
+					...p,
+					raw: p.y,
+					y: p.y === null ? null : p.y / level * LEVEL
+				}))
+			}] : [];
+		});
+	}
+	yValues() {
+		return [...super.yValues(), LEVEL];
+	}
+	plotMarks(ctx, axes) {
+		const series = this.view;
+		const width = ctx.plot.width - this.labelRoom();
+		const level = axes.y(LEVEL) ?? 0;
+		ctx.marks("level", "line", [LEVEL]).attr("stroke", ctx.theme.axis).attr("stroke-width", 1.5).attr("x1", 0).attr("x2", width).attr("y1", level).attr("y2", level);
+		const anchor = this.source.xs[this.slot];
+		const ruled = this.options.rule && anchor ? [anchor] : [];
+		const rule = ctx.marks("base-rule", "line", ruled).attr("stroke", ctx.theme.axis).attr("stroke-dasharray", "3 3").attr("y1", 0).attr("y2", ctx.plot.height);
+		ctx.set(rule, {
+			x1: (p) => this.px(axes, p),
+			x2: (p) => this.px(axes, p)
+		});
+		this.strokes(ctx, "lines", series, axes);
+		this.markers(ctx, series, axes, this.options.markers);
+		if (this.direct) this.endLabels(ctx, series, axes);
+		this.hoverColumns(ctx, axes, series);
+	}
+};
+export { IndexedLine };

package/dist/charts/linesareas/LayeredChart.js

@@ -0,0 +1,97 @@
+import { AreaStackOrder, LineLabels } from "./LineEnums.js";
+import { TrendChart } from "./TrendChart.js";
+import { TrendLabels } from "./TrendLabels.js";
+import { TrendMath } from "./TrendMath.js";
+import { area, max, min, scaleLinear, stack, stackOffsetDiverging, stackOffsetExpand, stackOffsetNone, stackOffsetSilhouette, stackOffsetWiggle, stackOrderAscending, stackOrderDescending, stackOrderInsideOut, stackOrderNone, stackOrderReverse } from "d3";
+// src/charts/linesareas/LayeredChart.ts
+var LayerOffset = /* @__PURE__ */ function(LayerOffset) {
+	LayerOffset["None"] = "none";
+	LayerOffset["Expand"] = "expand";
+	LayerOffset["Wiggle"] = "wiggle";
+	LayerOffset["Silhouette"] = "silhouette";
+	return LayerOffset;
+}({});
+var ORDER = {
+	[AreaStackOrder.Data]: stackOrderNone,
+	[AreaStackOrder.Ascending]: stackOrderAscending,
+	[AreaStackOrder.Descending]: stackOrderDescending,
+	[AreaStackOrder.InsideOut]: stackOrderInsideOut,
+	[AreaStackOrder.Reverse]: stackOrderReverse
+};
+var OFFSET = {
+	["none"]: stackOffsetNone,
+	["expand"]: stackOffsetExpand,
+	["wiggle"]: stackOffsetWiggle,
+	["silhouette"]: stackOffsetSilhouette
+};
+var GAP = 1;
+/** Stacked layers along x: the geometry behind stacked areas and streamgraphs. Missing values count as zero. */
+var LayeredChart = class extends TrendChart {
+	get direct() {
+		return this.options.labels === LineLabels.Direct;
+	}
+	labelRoom() {
+		return 0;
+	}
+	layers() {
+		const lookups = this.view.map((s) => ({
+			key: s.key,
+			values: TrendMath.byOrder(s)
+		}));
+		const slots = this.source.xs.map((slot) => new Map(lookups.flatMap(({ key, values }) => {
+			const value = values.get(slot.order);
+			return value === null || value === void 0 ? [] : [[key, value]];
+		})));
+		const signed = slots.some((slot) => [...slot.values()].some((value) => value < 0));
+		return stack().keys(this.view.map((s) => s.key)).value((slot, key) => slot.get(key) ?? 0).order(ORDER[this.options.order]).offset(signed && this.offset() === "none" ? stackOffsetDiverging : OFFSET[this.offset()])(slots);
+	}
+	yAxis(height) {
+		const layers = this.layers();
+		const lo = min(layers, (layer) => min(layer, (d) => Math.min(d[0], d[1]))) ?? 0, hi = max(layers, (layer) => max(layer, (d) => Math.max(d[0], d[1]))) ?? 1;
+		const scale = scaleLinear([lo, hi === lo ? lo + 1 : hi], [height, 0]);
+		return this.offset() === "none" ? scale.nice() : scale;
+	}
+	plotMarks(ctx, axes) {
+		const layers = this.layers();
+		const xs = this.source.xs.map((slot) => this.px(axes, slot));
+		const y = (value) => axes.y(value) ?? 0;
+		const low = (d) => Math.max(y(d[0]), y(d[1])), high = (d) => Math.min(y(d[0]), y(d[1]));
+		const shape = () => area().x((_, i) => xs[i]).curve(this.curveOf());
+		const solid = shape().y0((d) => Math.max(low(d) - GAP, (low(d) + high(d)) / 2)).y1((d) => Math.min(high(d) + GAP, (low(d) + high(d)) / 2));
+		const folded = shape().y(low);
+		const fills = ctx.marks("layers", "path", layers, (layer) => layer.key).attr("fill", (layer) => ctx.palette.color(layer.key));
+		ctx.set(fills, { d: (layer) => solid(layer) ?? "" }, { d: (layer) => folded(layer) ?? "" });
+		this.bandLabels(ctx, this.direct ? layers : [], xs, low, high);
+		const tops = new Map(layers.map((layer) => [layer.key, layer]));
+		const row = new Map(this.source.xs.map((slot, i) => [slot.order, i]));
+		this.hoverColumns(ctx, axes, this.view, { place: (p, s) => [this.px(axes, p), y(tops.get(s.key)[row.get(p.order)][1])] });
+	}
+	/** Names a layer at its thickest point, and only when the text fits inside it. */
+	bandLabels(ctx, layers, xs, low, high) {
+		const width = ctx.plot.width;
+		const spots = layers.flatMap((layer) => {
+			const w = layer.key.length * 6.2 + 8;
+			const best = layer.map((d, i) => ({
+				d,
+				x: xs[i],
+				thick: low(d) - high(d)
+			})).filter(({ x }) => x - w / 2 >= 0 && x + w / 2 <= width).reduce((a, b) => !a || b.thick > a.thick ? b : a, null);
+			return best && best.thick >= 16 ? [{
+				key: layer.key,
+				x: best.x,
+				y: (low(best.d) + high(best.d)) / 2,
+				w,
+				h: 12
+			}] : [];
+		});
+		const labels = ctx.marks("band-labels", "text", TrendLabels.reject(spots), (d) => d.key).attr("text-anchor", "middle").attr("dy", ".32em").attr("font-size", 11).attr("font-weight", 500).attr("font-family", ctx.theme.fontFamily).attr("pointer-events", "none").attr("fill", (d) => ctx.palette.inkOn(ctx.palette.color(d.key))).text((d) => d.key);
+		ctx.set(labels, {
+			x: (d) => d.x,
+			y: (d) => d.y
+		}, {
+			x: (d) => d.x,
+			y: (d) => d.y
+		});
+	}
+};
+export { LayerOffset, LayeredChart };

package/dist/charts/linesareas/LineChart.js

@@ -0,0 +1,76 @@
+import { ChartFamily, CurveKind, DataShape, Dimension, ScaleKind } from "../../core/enums.js";
+import { SampleData } from "../../data/SampleData.js";
+import { LineBaseline, LineMarkers, LineTrend } from "./LineEnums.js";
+import { TrendChart } from "./TrendChart.js";
+import { TrendMath } from "./TrendMath.js";
+// src/charts/linesareas/LineChart.ts
+/** The default for a value changing over an ordered x. Use `trend` to separate signal from noise. */
+var LineChart = class extends TrendChart {
+	static meta = {
+		id: "line",
+		name: "Line chart",
+		family: ChartFamily.Trend,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Shows how a value changes across an ordered axis, with optional markers, trend overlay and scale.",
+		tags: [
+			"trend",
+			"time series",
+			"run chart"
+		],
+		sample: (seed) => SampleData.timeSeries(seed, 36, 1),
+		variants: {
+			curve: [
+				CurveKind.Monotone,
+				CurveKind.Linear,
+				CurveKind.CatmullRom
+			],
+			markers: [
+				LineMarkers.None,
+				LineMarkers.Ends,
+				LineMarkers.Extrema,
+				LineMarkers.All
+			],
+			scale: [
+				ScaleKind.Linear,
+				ScaleKind.Log,
+				ScaleKind.Sqrt
+			],
+			baseline: [LineBaseline.Data, LineBaseline.Zero],
+			trend: [
+				LineTrend.None,
+				LineTrend.MovingAverage,
+				LineTrend.Regression
+			]
+		},
+		valid: ({ scale, baseline, trend }) => !(scale === ScaleKind.Log && baseline === LineBaseline.Zero) && (trend !== LineTrend.Regression || scale === ScaleKind.Linear)
+	};
+	defaults() {
+		return {
+			...super.defaults(),
+			markers: LineMarkers.None,
+			baseline: LineBaseline.Data,
+			trend: LineTrend.None
+		};
+	}
+	get zeroBased() {
+		return this.options.baseline === LineBaseline.Zero;
+	}
+	overlay(series) {
+		const { points, key } = series;
+		const window = Math.max(3, Math.round(points.length / 7));
+		return {
+			key,
+			points: this.options.trend === LineTrend.Regression ? TrendMath.regression(points) : TrendMath.movingAverage(points, window)
+		};
+	}
+	plotMarks(ctx, axes) {
+		const series = this.view;
+		const overlays = this.options.trend === LineTrend.None ? [] : series.map((s) => this.overlay(s));
+		this.strokes(ctx, "lines", series, axes);
+		this.strokes(ctx, "trends", overlays, axes, this.curveOf(CurveKind.Linear), () => ctx.theme.inkSecondary).attr("stroke-dasharray", "5 4");
+		this.markers(ctx, series, axes, this.options.markers);
+		this.hoverColumns(ctx, axes, series);
+	}
+};
+export { LineChart };

package/dist/charts/linesareas/LineEnums.js

@@ -0,0 +1,253 @@
+// src/charts/linesareas/LineEnums.ts
+/** Which points of a line carry a marker. */
+var LineMarkers = /* @__PURE__ */ function(LineMarkers) {
+	LineMarkers["None"] = "no-markers";
+	LineMarkers["Ends"] = "end-markers";
+	LineMarkers["Extrema"] = "extrema-markers";
+	LineMarkers["All"] = "all-markers";
+	return LineMarkers;
+}({});
+/** Whether the value axis follows the data or always contains zero. */
+var LineBaseline = /* @__PURE__ */ function(LineBaseline) {
+	LineBaseline["Data"] = "data-baseline";
+	LineBaseline["Zero"] = "zero-baseline";
+	return LineBaseline;
+}({});
+/** Statistical overlay fitted to each series. */
+var LineTrend = /* @__PURE__ */ function(LineTrend) {
+	LineTrend["None"] = "no-trend";
+	LineTrend["MovingAverage"] = "moving-average";
+	LineTrend["Regression"] = "regression";
+	return LineTrend;
+}({});
+/** How series are identified. */
+var LineLabels = /* @__PURE__ */ function(LineLabels) {
+	LineLabels["Legend"] = "legend";
+	LineLabels["Direct"] = "direct-labels";
+	return LineLabels;
+}({});
+/** How rows sharing a series and x are combined. */
+var LineAggregate = /* @__PURE__ */ function(LineAggregate) {
+	LineAggregate["Mean"] = "mean";
+	LineAggregate["Sum"] = "sum";
+	LineAggregate["Last"] = "last";
+	return LineAggregate;
+}({});
+/** Reference level an area fills towards. */
+var AreaBaseline = /* @__PURE__ */ function(AreaBaseline) {
+	AreaBaseline["Zero"] = "zero";
+	AreaBaseline["Mean"] = "mean";
+	AreaBaseline["First"] = "first";
+	return AreaBaseline;
+}({});
+/** Vertical order of stacked layers. */
+var AreaStackOrder = /* @__PURE__ */ function(AreaStackOrder) {
+	AreaStackOrder["Data"] = "data-order";
+	AreaStackOrder["Ascending"] = "ascending";
+	AreaStackOrder["Descending"] = "descending";
+	AreaStackOrder["InsideOut"] = "inside-out";
+	AreaStackOrder["Reverse"] = "reverse";
+	return AreaStackOrder;
+}({});
+/** Where the riser of a step sits relative to its point. */
+var StepPlacement = /* @__PURE__ */ function(StepPlacement) {
+	StepPlacement["After"] = "step-after";
+	StepPlacement["Before"] = "step-before";
+	StepPlacement["Middle"] = "step-middle";
+	return StepPlacement;
+}({});
+/** How a step series is drawn. */
+var StepLineForm = /* @__PURE__ */ function(StepLineForm) {
+	StepLineForm["Line"] = "stepped-line";
+	StepLineForm["Filled"] = "stepped-area";
+	StepLineForm["Treads"] = "treads-only";
+	return StepLineForm;
+}({});
+/** What a slope chart plots at each period. */
+var SlopeValue = /* @__PURE__ */ function(SlopeValue) {
+	SlopeValue["Absolute"] = "absolute";
+	SlopeValue["Indexed"] = "indexed";
+	return SlopeValue;
+}({});
+/** Which periods of the data become columns. */
+var SlopeSpan = /* @__PURE__ */ function(SlopeSpan) {
+	SlopeSpan["Ends"] = "first-and-last";
+	SlopeSpan["All"] = "all-periods";
+	return SlopeSpan;
+}({});
+/** Which sides of a slope or bump chart carry names. */
+var SlopeLabels = /* @__PURE__ */ function(SlopeLabels) {
+	SlopeLabels["Both"] = "both-sides";
+	SlopeLabels["Right"] = "right-side";
+	SlopeLabels["Left"] = "left-side";
+	return SlopeLabels;
+}({});
+/** Where rank one sits. */
+var BumpDirection = /* @__PURE__ */ function(BumpDirection) {
+	BumpDirection["TopFirst"] = "first-on-top";
+	BumpDirection["BottomFirst"] = "first-at-bottom";
+	return BumpDirection;
+}({});
+/** How each stop of a bump line is marked. */
+var BumpStops = /* @__PURE__ */ function(BumpStops) {
+	BumpStops["None"] = "no-stops";
+	BumpStops["Dots"] = "dots";
+	BumpStops["Ranks"] = "rank-numbers";
+	return BumpStops;
+}({});
+/** Line thickness in a bump chart. */
+var BumpWidth = /* @__PURE__ */ function(BumpWidth) {
+	BumpWidth["Uniform"] = "uniform";
+	BumpWidth["Value"] = "value-ribbon";
+	return BumpWidth;
+}({});
+/** Mark a sparkline draws. */
+var SparklineForm = /* @__PURE__ */ function(SparklineForm) {
+	SparklineForm["Line"] = "line";
+	SparklineForm["Area"] = "area";
+	SparklineForm["Step"] = "step";
+	SparklineForm["Bars"] = "bars";
+	SparklineForm["WinLoss"] = "win-loss";
+	return SparklineForm;
+}({});
+/** Reference band behind a sparkline. */
+var SparklineBand = /* @__PURE__ */ function(SparklineBand) {
+	SparklineBand["None"] = "no-band";
+	SparklineBand["Interquartile"] = "interquartile-band";
+	SparklineBand["Range"] = "range-band";
+	return SparklineBand;
+}({});
+/** Whether a difference chart shows both lines or the gap as one signed area. */
+var DifferenceView = /* @__PURE__ */ function(DifferenceView) {
+	DifferenceView["Between"] = "between-lines";
+	DifferenceView["Delta"] = "delta-from-zero";
+	return DifferenceView;
+}({});
+/** How a horizon chart folds values below its baseline. */
+var HorizonMode = /* @__PURE__ */ function(HorizonMode) {
+	HorizonMode["Mirror"] = "mirror";
+	HorizonMode["Offset"] = "offset";
+	return HorizonMode;
+}({});
+/** Whether horizon rows share one value scale. */
+var HorizonScale = /* @__PURE__ */ function(HorizonScale) {
+	HorizonScale["Shared"] = "shared-scale";
+	HorizonScale["Independent"] = "row-scale";
+	return HorizonScale;
+}({});
+/** Mark type for a low-to-high range. */
+var RangeForm = /* @__PURE__ */ function(RangeForm) {
+	RangeForm["Band"] = "band";
+	RangeForm["ErrorBars"] = "error-bars";
+	RangeForm["Spans"] = "span-bars";
+	return RangeForm;
+}({});
+/** What runs through the middle of a range or fan. */
+var RangeCenter = /* @__PURE__ */ function(RangeCenter) {
+	RangeCenter["Line"] = "center-line";
+	RangeCenter["None"] = "no-center";
+	return RangeCenter;
+}({});
+/** Central estimate of a fan chart. */
+var FanCenter = /* @__PURE__ */ function(FanCenter) {
+	FanCenter["Median"] = "median";
+	FanCenter["Mean"] = "mean";
+	FanCenter["None"] = "no-center";
+	return FanCenter;
+}({});
+/** Cumulative total, in units or as a share of the final total. */
+var CumulativeUnit = /* @__PURE__ */ function(CumulativeUnit) {
+	CumulativeUnit["Absolute"] = "running-total";
+	CumulativeUnit["Share"] = "share-of-final";
+	return CumulativeUnit;
+}({});
+/** When a running total restarts. */
+var CumulativeReset = /* @__PURE__ */ function(CumulativeReset) {
+	CumulativeReset["Never"] = "no-reset";
+	CumulativeReset["Weekly"] = "week-to-date";
+	CumulativeReset["Monthly"] = "month-to-date";
+	return CumulativeReset;
+}({});
+/** How facets relate on the value axis. */
+var FacetScale = /* @__PURE__ */ function(FacetScale) {
+	FacetScale["Shared"] = "shared-y";
+	FacetScale["Free"] = "free-y";
+	return FacetScale;
+}({});
+/** Row order of ridge lines. */
+var RidgeSort = /* @__PURE__ */ function(RidgeSort) {
+	RidgeSort["Data"] = "data-order";
+	RidgeSort["Peak"] = "by-peak-time";
+	RidgeSort["Mean"] = "by-mean";
+	RidgeSort["Last"] = "by-last-value";
+	return RidgeSort;
+}({});
+/** Which rows share a vertical scale. */
+var RidgeScale = /* @__PURE__ */ function(RidgeScale) {
+	RidgeScale["Shared"] = "shared-height";
+	RidgeScale["Row"] = "row-height";
+	return RidgeScale;
+}({});
+/** Whether a ridge is filled below its line. */
+var RidgeFill = /* @__PURE__ */ function(RidgeFill) {
+	RidgeFill["Filled"] = "filled";
+	RidgeFill["Line"] = "lines-only";
+	return RidgeFill;
+}({});
+/** Point every series is rebased to 100 at. */
+var IndexBase = /* @__PURE__ */ function(IndexBase) {
+	IndexBase["First"] = "base-first";
+	IndexBase["Middle"] = "base-middle";
+	IndexBase["Last"] = "base-last";
+	return IndexBase;
+}({});
+/** Mark for the second measure of a dual-axis chart. */
+var DualForm = /* @__PURE__ */ function(DualForm) {
+	DualForm["Line"] = "second-line";
+	DualForm["Bars"] = "second-bars";
+	DualForm["Area"] = "second-area";
+	return DualForm;
+}({});
+/** How the two value axes relate. */
+var DualAlignment = /* @__PURE__ */ function(DualAlignment) {
+	DualAlignment["Independent"] = "independent";
+	DualAlignment["Zero"] = "both-from-zero";
+	DualAlignment["Gridlock"] = "shared-gridlines";
+	return DualAlignment;
+}({});
+/** How a threshold is derived when no value is given. */
+var ThresholdSource = /* @__PURE__ */ function(ThresholdSource) {
+	ThresholdSource["Mean"] = "mean";
+	ThresholdSource["Median"] = "median";
+	ThresholdSource["First"] = "first";
+	ThresholdSource["Last"] = "last";
+	return ThresholdSource;
+}({});
+/** Which side of a threshold is filled. */
+var ThresholdSide = /* @__PURE__ */ function(ThresholdSide) {
+	ThresholdSide["Both"] = "both-sides";
+	ThresholdSide["Above"] = "above-only";
+	ThresholdSide["Below"] = "below-only";
+	return ThresholdSide;
+}({});
+/** Length of the repeating cycle. */
+var SeasonPeriod = /* @__PURE__ */ function(SeasonPeriod) {
+	SeasonPeriod["Week"] = "weekly";
+	SeasonPeriod["Month"] = "monthly";
+	return SeasonPeriod;
+}({});
+/** Whether each cycle keeps its level or starts from 100. */
+var SeasonAlign = /* @__PURE__ */ function(SeasonAlign) {
+	SeasonAlign["Level"] = "actual-level";
+	SeasonAlign["Rebased"] = "rebased-start";
+	return SeasonAlign;
+}({});
+/** Rule used to project a series forward. */
+var ForecastMethod = /* @__PURE__ */ function(ForecastMethod) {
+	ForecastMethod["Linear"] = "linear-trend";
+	ForecastMethod["Holt"] = "holt";
+	ForecastMethod["Naive"] = "naive";
+	ForecastMethod["Mean"] = "mean";
+	return ForecastMethod;
+}({});
+export { AreaBaseline, AreaStackOrder, BumpDirection, BumpStops, BumpWidth, CumulativeReset, CumulativeUnit, DifferenceView, DualAlignment, DualForm, FacetScale, FanCenter, ForecastMethod, HorizonMode, HorizonScale, IndexBase, LineAggregate, LineBaseline, LineLabels, LineMarkers, LineTrend, RangeCenter, RangeForm, RidgeFill, RidgeScale, RidgeSort, SeasonAlign, SeasonPeriod, SlopeLabels, SlopeSpan, SlopeValue, SparklineBand, SparklineForm, StepLineForm, StepPlacement, ThresholdSide, ThresholdSource };