@mstone6969/graph 0.1.0 → 0.2.0

package/dist/charts/financial/RelativeStrengthRotation.js

@@ -0,0 +1,434 @@
+import { CartesianChart } from "../../core/CartesianChart.js";
+import { ChartFamily, CurveKind, DataShape, Dimension } from "../../core/enums.js";
+import { Scales } from "../../core/Scales.js";
+import { FinanceInk } from "./FinanceInk.js";
+import { Quotes } from "./Quotes.js";
+import { RelativeStrengthRotationMath, RotationFrame, RotationMethod, RotationQuadrant } from "./RelativeStrengthRotationMath.js";
+import { RelativeStrengthRotationSamples } from "./RelativeStrengthRotationSamples.js";
+import { format, group, line, precisionFixed, scaleLinear, tickStep } from "d3";
+// src/charts/financial/RelativeStrengthRotation.ts
+var CENTER = 100;
+var PAD = 1.12;
+var HEAD = 6;
+var NODE = 4;
+var LABEL_CHARS = 12;
+var CHAR = 6.2;
+/** Polarity of each quadrant: the sign is which side of the benchmark it is on, the size whether momentum agrees. The warm pole is the weak side. */
+var TINT = {
+	[RotationQuadrant.Leading]: -.9,
+	[RotationQuadrant.Weakening]: -.35,
+	[RotationQuadrant.Improving]: .35,
+	[RotationQuadrant.Lagging]: .9
+};
+var dayLabel = (value, when) => when ? when.toISOString().slice(0, 10) : String(value ?? "");
+var shorten = (text, chars) => text.length > chars ? `${text.slice(0, Math.max(1, chars - 1))}…` : text;
+var wholeAtLeast = (value, floor, fallback) => Number.isFinite(value) ? Math.max(floor, Math.round(value)) : fallback;
+var overlaps = (a, b) => a.left < b.right && b.left < a.right && a.top < b.bottom && b.top < a.bottom;
+/**
+* Relative strength rotation: use it to compare many symbols against one benchmark and see which are
+* rotating through Leading, Weakening, Lagging and Improving, normally clockwise.
+*
+* Method: Julius de Kempenaer's RRG, whose JdK RS-Ratio and RS-Momentum formulas are proprietary and
+* unpublished, so computed values are an approximation and will not match licensed RRG software.
+* With relative strength `RS = 100 * price / benchmark`:
+* - `RotationMethod.ZScore`, the rolling z-score recipe circulated in public reimplementations:
+*   `ratio = 100 + z(RS, window)`, `momentum = 100 + z(ROC(ratio, lookback), window)`.
+* - `RotationMethod.RatioToAverage`, after Mansfield relative strength as in Weinstein (1988):
+*   `ratio = 100 * RS / SMA(RS, window)`, `momentum = 100 + ROC(ratio, lookback)`.
+* RS first passes through `EMA(RS, smoothing)`, 5 by default, because RRG tails are known to be smoothed
+* and an unsmoothed z-score scribbles on real prices. That default is this library's choice; 1 turns it off.
+* Supply `ratio` and `momentum` columns to draw licensed or other values unchanged.
+*/
+var RelativeStrengthRotation = class RelativeStrengthRotation extends CartesianChart {
+	static meta = {
+		id: "relative-strength-rotation",
+		name: "Relative strength rotation",
+		family: ChartFamily.Financial,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Tracks symbols against a benchmark through the Leading, Weakening, Lagging and Improving quadrants, using a documented approximation of the proprietary JdK RS-Ratio and RS-Momentum, or values you supply.",
+		tags: [
+			"rrg",
+			"rs-ratio",
+			"rs-momentum",
+			"sector rotation",
+			"relative strength",
+			"momentum",
+			"benchmark"
+		],
+		sample: (seed) => RelativeStrengthRotationSamples.prices(seed),
+		variants: {
+			method: [RotationMethod.ZScore, RotationMethod.RatioToAverage],
+			tail: [
+				10,
+				5,
+				20
+			],
+			curve: [CurveKind.Linear, CurveKind.CatmullRom],
+			frame: [RotationFrame.Centered, RotationFrame.Fitted],
+			nodes: [true, false]
+		}
+	};
+	defaults() {
+		return {
+			date: "date",
+			series: "series",
+			close: "close",
+			benchmark: "benchmark",
+			ratio: "rsRatio",
+			momentum: "rsMomentum",
+			method: RotationMethod.ZScore,
+			window: 14,
+			lookback: 1,
+			smoothing: 5,
+			tail: 10,
+			curve: CurveKind.Linear,
+			frame: RotationFrame.Centered,
+			nodes: true,
+			xLabel: "RS-Ratio",
+			yLabel: "RS-Momentum"
+		};
+	}
+	get settings() {
+		const { method, window, lookback, smoothing } = this.options;
+		return {
+			method,
+			window: wholeAtLeast(window, 2, 14),
+			lookback: wholeAtLeast(lookback, 1, 1),
+			smoothing: wholeAtLeast(smoothing, 1, 5)
+		};
+	}
+	rows() {
+		const { data, date, series, close, benchmark, ratio, momentum } = this.options;
+		return (Array.isArray(data) ? data : []).filter((row) => row !== null && typeof row === "object").map((row, i) => {
+			const when = Quotes.date(row[date]);
+			const rsRatio = Quotes.number(row[ratio]), rsMomentum = Quotes.number(row[momentum]);
+			return {
+				name: String(row[series] ?? "Symbol"),
+				time: when?.getTime() ?? i,
+				label: dayLabel(row[date], when),
+				close: Quotes.number(row[close]),
+				base: Quotes.number(row[benchmark]),
+				given: Number.isFinite(rsRatio) && Number.isFinite(rsMomentum) ? {
+					ratio: rsRatio,
+					momentum: rsMomentum
+				} : null
+			};
+		});
+	}
+	/** Oldest first, one row per bar, with the last duplicate winning. */
+	static ordered(rows) {
+		return [...new Map(rows.map((row) => [row.time, row]))].sort((a, b) => a[0] - b[0]).map(([, row]) => row);
+	}
+	computed(rows, indexPrices) {
+		const priced = rows.flatMap((row) => {
+			const base = indexPrices.get(row.time) ?? row.base;
+			return row.close > 0 && base > 0 && Number.isFinite(row.close) && Number.isFinite(base) ? [{
+				row,
+				base
+			}] : [];
+		});
+		const points = RelativeStrengthRotationMath.rotation(priced.map(({ row }) => row.close), priced.map(({ base }) => base), this.settings);
+		return priced.map(({ row }, i) => ({
+			row,
+			point: points[i]
+		}));
+	}
+	/** Every symbol's whole path. Supplied values win over prices, symbol by symbol. */
+	reading() {
+		const { benchmarkSymbol } = this.options;
+		const rows = this.rows();
+		const indexPrices = new Map(rows.filter((row) => row.name === benchmarkSymbol && row.close > 0 && Number.isFinite(row.close)).map((row) => [row.time, row.close]));
+		const trails = [], skipped = [];
+		for (const [name, own] of group(rows.filter((row) => row.name !== benchmarkSymbol), (row) => row.name)) {
+			const ordered = RelativeStrengthRotation.ordered(own);
+			const given = ordered.filter((row) => row.given);
+			const stops = (given.length ? given.map((row) => ({
+				row,
+				point: row.given
+			})) : this.computed(ordered, indexPrices)).flatMap(({ row, point }) => point ? [{
+				...point,
+				series: name,
+				when: row.label,
+				quadrant: RelativeStrengthRotationMath.quadrant(point),
+				age: 0
+			}] : []);
+			if (stops.length) trails.push({
+				name,
+				stops
+			});
+			else skipped.push(name);
+		}
+		return {
+			trails,
+			skipped
+		};
+	}
+	/** The head and `tail` bars behind it, with `age` counting back from the head. */
+	recent(trail) {
+		const stops = trail.stops.slice(-(wholeAtLeast(this.options.tail, 0, 10) + 1));
+		return {
+			name: trail.name,
+			stops: stops.map((stop, i) => ({
+				...stop,
+				age: stops.length - 1 - i
+			}))
+		};
+	}
+	domain(values) {
+		const low = Math.min(CENTER, ...values), high = Math.max(CENTER, ...values);
+		if (low === high) return [99, 101];
+		if (this.options.frame === RotationFrame.Fitted) {
+			const pad = (high - low) * .1200000000000001;
+			return [low - pad, high + pad];
+		}
+		const reach = Math.max(CENTER - low, high - CENTER) * PAD;
+		return [CENTER - reach, CENTER + reach];
+	}
+	scales(ctx) {
+		const { trails, skipped } = this.reading();
+		const shown = trails.map((trail) => this.recent(trail));
+		const stops = shown.flatMap((trail) => trail.stops);
+		const x = scaleLinear(this.domain(stops.map((stop) => stop.ratio)), [0, ctx.plot.width]);
+		const y = scaleLinear(this.domain(stops.map((stop) => stop.momentum)), [ctx.plot.height, 0]);
+		if (this.options.frame !== RotationFrame.Fitted) {
+			x.nice(this.xTicks());
+			y.nice(this.yTicks());
+		}
+		return {
+			x,
+			y,
+			shown,
+			skipped
+		};
+	}
+	/** Readings sit a fraction either side of 100, so ticks take the decimals their spacing needs. */
+	tickFormat(scale) {
+		const [low, high] = scale.domain();
+		const print = format(`.${precisionFixed(tickStep(low, high, this.yTicks()))}f`);
+		return (value) => print(+value);
+	}
+	plotMarks(ctx, axes) {
+		const { x, y, shown } = axes;
+		this.drawQuadrants(ctx, axes);
+		const color = (name) => ctx.palette.color(name);
+		const path = line().curve(Scales.curve(this.options.curve)).x((stop) => x(stop.ratio)).y((stop) => y(stop.momentum));
+		const tails = ctx.marks("tails", "path", shown.filter((trail) => trail.stops.length > 1), (trail) => trail.name).attr("fill", "none").attr("stroke", (trail) => color(trail.name)).attr("stroke-width", 2).attr("stroke-linejoin", "round").attr("stroke-linecap", "round");
+		ctx.set(tails, { d: (trail) => path(trail.stops) ?? "" }, { d: (trail) => path(trail.stops) ?? "" });
+		ctx.drawOn(tails);
+		const last = wholeAtLeast(this.options.tail, 1, 10);
+		const stops = shown.flatMap((trail) => this.options.nodes ? trail.stops : trail.stops.slice(-1));
+		const dots = ctx.marks("dots", "circle", stops, (stop) => `${stop.series}/${stop.age}`).attr("fill", (stop) => color(stop.series)).attr("stroke", ctx.theme.surface).attr("stroke-width", 2).attr("opacity", (stop) => 1 - .6 * stop.age / last);
+		const place = {
+			cx: (stop) => x(stop.ratio),
+			cy: (stop) => y(stop.momentum)
+		};
+		ctx.set(dots, {
+			...place,
+			r: (stop) => stop.age ? NODE : HEAD
+		}, {
+			...place,
+			r: 0
+		}, 6);
+		ctx.hover(dots, (stop) => this.tipFor(stop));
+		this.drawLabels(ctx, axes);
+		this.drawNotice(ctx, axes);
+	}
+	tipFor(stop) {
+		return {
+			title: stop.when ? `${stop.series}, ${stop.when}` : stop.series,
+			color: this.palette.color(stop.series),
+			rows: [
+				["RS-Ratio", stop.ratio.toFixed(2)],
+				["RS-Momentum", stop.momentum.toFixed(2)],
+				["Quadrant", stop.quadrant]
+			]
+		};
+	}
+	drawQuadrants(ctx, { x, y }) {
+		const { width, height } = ctx.plot;
+		const left = Math.max(0, Math.min(width, x(CENTER))), top = Math.max(0, Math.min(height, y(CENTER)));
+		const areas = [
+			{
+				name: RotationQuadrant.Improving,
+				x: 0,
+				y: 0,
+				width: left,
+				height: top,
+				anchor: "start",
+				textX: 6,
+				textY: 14
+			},
+			{
+				name: RotationQuadrant.Leading,
+				x: left,
+				y: 0,
+				width: width - left,
+				height: top,
+				anchor: "end",
+				textX: width - 6,
+				textY: 14
+			},
+			{
+				name: RotationQuadrant.Lagging,
+				x: 0,
+				y: top,
+				width: left,
+				height: height - top,
+				anchor: "start",
+				textX: 6,
+				textY: height - 6
+			},
+			{
+				name: RotationQuadrant.Weakening,
+				x: left,
+				y: top,
+				width: width - left,
+				height: height - top,
+				anchor: "end",
+				textX: width - 6,
+				textY: height - 6
+			}
+		];
+		const tiles = ctx.marks("quadrants", "rect", areas, (area) => area.name).attr("fill", (area) => ctx.palette.diverging(TINT[area.name])).attr("fill-opacity", .1);
+		ctx.set(tiles, {
+			x: (area) => area.x,
+			y: (area) => area.y,
+			width: (area) => area.width,
+			height: (area) => area.height
+		});
+		FinanceInk.note(ctx, "quadrant-labels", areas.filter((area) => area.width >= area.name.length * CHAR + 12 && area.height >= 20), (area) => ({
+			x: area.textX,
+			y: area.textY,
+			text: area.name,
+			anchor: area.anchor
+		}), 11, "muted");
+		const axisLines = [...x(CENTER) >= 0 && x(CENTER) <= width ? [{
+			key: "x",
+			x1: left,
+			x2: left,
+			y1: 0,
+			y2: height
+		}] : [], ...y(CENTER) >= 0 && y(CENTER) <= height ? [{
+			key: "y",
+			x1: 0,
+			x2: width,
+			y1: top,
+			y2: top
+		}] : []];
+		const rules = ctx.marks("center", "line", axisLines, (rule) => rule.key).attr("stroke", ctx.theme.axis).attr("stroke-width", 1);
+		ctx.set(rules, {
+			x1: (rule) => rule.x1,
+			x2: (rule) => rule.x2,
+			y1: (rule) => rule.y1,
+			y2: (rule) => rule.y2
+		});
+	}
+	/** Names sit beside their heads, on the first free side; a name with no room is left to the legend and tooltip. */
+	drawLabels(ctx, { x, y, shown }) {
+		const { width, height } = ctx.plot;
+		const heads = shown.flatMap((trail) => {
+			const head = trail.stops.at(-1);
+			const px = x(head.ratio), py = y(head.momentum);
+			return px >= 0 && px <= width && py >= 0 && py <= height ? [{
+				text: shorten(trail.name, LABEL_CHARS),
+				px,
+				py
+			}] : [];
+		});
+		const taken = heads.map(({ px, py }) => ({
+			left: px - HEAD,
+			right: px + HEAD,
+			top: py - HEAD,
+			bottom: py + HEAD
+		}));
+		const labels = heads.flatMap(({ text, px, py }) => {
+			const wide = text.length * CHAR, gap = 9;
+			const spot = [
+				{
+					x: px + gap,
+					y: py + 4,
+					anchor: "start",
+					box: {
+						left: px + gap,
+						right: px + gap + wide,
+						top: py - 7,
+						bottom: py + 7
+					}
+				},
+				{
+					x: px - gap,
+					y: py + 4,
+					anchor: "end",
+					box: {
+						left: px - gap - wide,
+						right: px - gap,
+						top: py - 7,
+						bottom: py + 7
+					}
+				},
+				{
+					x: px,
+					y: py - gap - 2,
+					anchor: "middle",
+					box: {
+						left: px - wide / 2,
+						right: px + wide / 2,
+						top: py - gap - 12,
+						bottom: py - gap + 2
+					}
+				},
+				{
+					x: px,
+					y: py + gap + 10,
+					anchor: "middle",
+					box: {
+						left: px - wide / 2,
+						right: px + wide / 2,
+						top: py + gap - 2,
+						bottom: py + gap + 12
+					}
+				}
+			].find(({ box }) => box.left >= 0 && box.right <= width && box.top >= 0 && box.bottom <= height && !taken.some((other) => overlaps(box, other)));
+			if (!spot) return [];
+			taken.push(spot.box);
+			return [{
+				text,
+				...spot
+			}];
+		});
+		FinanceInk.note(ctx, "head-labels", labels, (label) => label, 11, "ink");
+	}
+	/** A symbol without enough bars has no position, so the chart says so rather than losing it quietly. */
+	drawNotice(ctx, { shown, skipped }) {
+		const { width, height } = ctx.plot;
+		const need = `${RelativeStrengthRotationMath.required(this.settings)} bars`;
+		const text = !skipped.length ? null : shown.length ? `Too short, needs ${need}: ${skipped.join(", ")}` : `Each symbol needs ${need}`;
+		FinanceInk.note(ctx, "notice", text ? [shorten(text, Math.floor((width - 200) / CHAR))] : [], (note) => ({
+			x: width / 2,
+			y: height - 6,
+			text: note,
+			anchor: "middle"
+		}), 11, "secondary");
+	}
+	/** Exports the computed positions, not the prices that went in. */
+	table() {
+		return {
+			columns: [
+				"series",
+				"date",
+				"rsRatio",
+				"rsMomentum",
+				"quadrant"
+			],
+			rows: this.reading().trails.flatMap((trail) => trail.stops.map((stop) => [
+				stop.series,
+				stop.when,
+				+stop.ratio.toFixed(4),
+				+stop.momentum.toFixed(4),
+				stop.quadrant
+			]))
+		};
+	}
+};
+export { RelativeStrengthRotation };

package/dist/charts/financial/RelativeStrengthRotationMath.js

@@ -0,0 +1,71 @@
+import { FinanceMath } from "./FinanceMath.js";
+// src/charts/financial/RelativeStrengthRotationMath.ts
+/** How price and benchmark become the two rotation axes. Both are public approximations: the JdK formula is proprietary. */
+var RotationMethod = /* @__PURE__ */ function(RotationMethod) {
+	RotationMethod["ZScore"] = "z-score";
+	RotationMethod["RatioToAverage"] = "ratio-to-average";
+	return RotationMethod;
+}({});
+var RotationQuadrant = /* @__PURE__ */ function(RotationQuadrant) {
+	RotationQuadrant["Leading"] = "Leading";
+	RotationQuadrant["Weakening"] = "Weakening";
+	RotationQuadrant["Lagging"] = "Lagging";
+	RotationQuadrant["Improving"] = "Improving";
+	return RotationQuadrant;
+}({});
+/** `Centered` keeps 100,100 mid-plot, the customary framing. `Fitted` follows the data but always holds 100,100. */
+var RotationFrame = /* @__PURE__ */ function(RotationFrame) {
+	RotationFrame["Centered"] = "centered";
+	RotationFrame["Fitted"] = "fitted";
+	return RotationFrame;
+}({});
+/** Below this share of the mean, a rolling deviation is rounding error rather than movement. */
+var FLAT = 1e-12;
+/** Pure maths behind the relative rotation graph; everything is centred on 100. */
+var RelativeStrengthRotationMath = class {
+	static relativeStrength(prices, benchmark) {
+		return prices.map((price, i) => 100 * price / benchmark[i]);
+	}
+	/** Rolling population z-score, `(value - mean) / deviation`. A flat window scores 0. */
+	static zScore(values, window) {
+		const means = FinanceMath.sma(values, window), spreads = FinanceMath.stdev(values, window);
+		return values.map((value, i) => {
+			const mean = means[i], spread = spreads[i];
+			if (value === null || mean == null || spread == null) return null;
+			return spread <= Math.abs(mean) * FLAT ? 0 : (value - mean) / spread;
+		});
+	}
+	/** Percent change over `lookback` bars. */
+	static rateOfChange(values, lookback) {
+		return values.map((value, i) => {
+			const before = values[i - lookback];
+			return value === null || before == null || before === 0 ? null : 100 * (value / before - 1);
+		});
+	}
+	/** Each aligned bar's position, or null while the rolling windows fill. */
+	static rotation(prices, benchmark, { method, window, lookback, smoothing }) {
+		const strength = FinanceMath.ema(this.relativeStrength(prices, benchmark), smoothing);
+		const zScore = method === "z-score";
+		const averages = FinanceMath.sma(strength, window);
+		const ratios = zScore ? this.zScore(strength, window).map((z) => z === null ? null : 100 + z) : strength.map((value, i) => value === null || !averages[i] ? null : 100 * value / averages[i]);
+		const change = this.rateOfChange(ratios, lookback);
+		const momenta = zScore ? this.zScore(change, window) : change;
+		return ratios.map((ratio, i) => {
+			const momentum = momenta[i];
+			return ratio === null || momentum == null ? null : {
+				ratio,
+				momentum: 100 + momentum
+			};
+		});
+	}
+	/** Bars a series needs before its first point appears. */
+	static required({ method, window, lookback, smoothing }) {
+		return smoothing - 1 + window + lookback + (method === "z-score" ? window - 1 : 0);
+	}
+	/** Clockwise from top right. A point exactly on 100 counts as the stronger side. */
+	static quadrant({ ratio, momentum }) {
+		if (ratio >= 100) return momentum >= 100 ? "Leading" : "Weakening";
+		return momentum >= 100 ? "Improving" : "Lagging";
+	}
+};
+export { RelativeStrengthRotationMath, RotationFrame, RotationMethod, RotationQuadrant };

package/dist/charts/financial/RelativeStrengthRotationSamples.js

@@ -0,0 +1,27 @@
+import { SampleData } from "../../data/SampleData.js";
+// src/charts/financial/RelativeStrengthRotationSamples.ts
+var BARS = 90;
+var SYMBOLS = 6;
+/** Synthetic prices only: seeded sine waves of relative strength over a seeded walk. Not market data. */
+var RelativeStrengthRotationSamples = class {
+	/** `{ date, series, close, benchmark }`, long form, with every symbol cycling around the benchmark at its own pace. */
+	static prices(seed) {
+		const benchmark = SampleData.ohlc(seed, BARS);
+		const noise = SampleData.timeSeries(seed, BARS, SYMBOLS);
+		return noise.map((row, i) => {
+			const bar = i % BARS, symbol = Math.floor(i / BARS);
+			const period = 42 + symbol * 5, phase = symbol * 2.1 + seed;
+			const previous = bar ? Number(noise[i - 1].value) : Number(row.value);
+			const wobble = (Number(row.value) - previous) * 6e-4;
+			const strength = Math.exp(.05 * Math.sin(2 * Math.PI * bar / period + phase) + wobble);
+			const index = Number(benchmark[bar].close);
+			return {
+				date: row.date,
+				series: row.series,
+				close: +(index * strength * (1 + symbol * .2)).toFixed(3),
+				benchmark: index
+			};
+		});
+	}
+};
+export { RelativeStrengthRotationSamples };

package/dist/charts/financial/index.js

@@ -4,7 +4,6 @@ import { Quotes } from "./Quotes.js";
 import { SessionChart } from "./SessionChart.js";
 import { PriceChart } from "./PriceChart.js";
 import { BollingerBands } from "./BollingerBands.js";
-import { Candlestick3D } from "./Candlestick3D.js";
 import { CandlestickChart } from "./CandlestickChart.js";
 import { DepthChart } from "./DepthChart.js";
 import { EquityBase } from "./EquityBase.js";
@@ -24,6 +23,9 @@ import { OHLCChart } from "./OHLCChart.js";
 import { PayoffDiagram } from "./PayoffDiagram.js";
 import { PointFigureChart } from "./PointFigureChart.js";
 import { ProjectionCone } from "./ProjectionCone.js";
+import { RelativeStrengthRotationMath, RotationFrame, RotationMethod, RotationQuadrant } from "./RelativeStrengthRotationMath.js";
+import { RelativeStrengthRotationSamples } from "./RelativeStrengthRotationSamples.js";
+import { RelativeStrengthRotation } from "./RelativeStrengthRotation.js";
 import { RenkoChart } from "./RenkoChart.js";
 import { ReturnCalendar } from "./ReturnCalendar.js";
 import { RSIChart } from "./RSIChart.js";
@@ -57,6 +59,6 @@ var financialCatalog = [
 	ReturnCalendar,
 	ProjectionCone,
 	VolatilitySurface,
-	Candlestick3D
+	RelativeStrengthRotation
 ];
-export { BollingerBands, BollingerPane, BoxMethod, BrickChart, CalendarCell, CalendarGrain, CalendarMeasure, CalendarTotals, Candle3DDepth, CandleBody, Candlestick3D, CandlestickChart, ConeBands, ConeModel, DepthChart, DepthCurve, DepthLayout, DepthScale, DrawdownChart, DrawdownMark, DrawdownUnit, EquityBase, EquityBasis, EquityCurve, EquityFill, FinanceMath, HeikinAshiChart, IchimokuCloud, IchimokuLines, IchimokuPeriods, KagiChart, LineBreakChart, MACDChart, MacdBasis, MacdHistogram, MacdPeriods, MarketProfileChart, MaturityScale, MovingAverageKind, OHLCChart, OhlcTicks, OptionStrategy, OscillatorChart, PayoffAxis, PayoffDiagram, PayoffHorizon, PointFigureChart, PriceChart, PriceMark, PriceOverlay, PriceScale, PriceSource, PriceTransforms, ProfileAllocation, ProfileMode, ProfileSide, ProjectionCone, Quotes, RSIChart, RenkoChart, ReturnCalendar, RsiForm, SessionChart, StochasticChart, StochasticForm, TpoBracket, TpoForm, TpoGrouping, TpoProfile, TpoStacking, VolatilitySurface, VolatilitySurfaceForm, VolumeBars, VolumeBucket, VolumeLayout, VolumeMark, VolumeMeasure, VolumeProfile, YieldCurve, YieldMode, financialCatalog };
+export { BollingerBands, BollingerPane, BoxMethod, BrickChart, CalendarCell, CalendarGrain, CalendarMeasure, CalendarTotals, Candle3DDepth, CandleBody, CandlestickChart, ConeBands, ConeModel, DepthChart, DepthCurve, DepthLayout, DepthScale, DrawdownChart, DrawdownMark, DrawdownUnit, EquityBase, EquityBasis, EquityCurve, EquityFill, FinanceMath, HeikinAshiChart, IchimokuCloud, IchimokuLines, IchimokuPeriods, KagiChart, LineBreakChart, MACDChart, MacdBasis, MacdHistogram, MacdPeriods, MarketProfileChart, MaturityScale, MovingAverageKind, OHLCChart, OhlcTicks, OptionStrategy, OscillatorChart, PayoffAxis, PayoffDiagram, PayoffHorizon, PointFigureChart, PriceChart, PriceMark, PriceOverlay, PriceScale, PriceSource, PriceTransforms, ProfileAllocation, ProfileMode, ProfileSide, ProjectionCone, Quotes, RSIChart, RelativeStrengthRotation, RelativeStrengthRotationMath, RelativeStrengthRotationSamples, RenkoChart, ReturnCalendar, RotationFrame, RotationMethod, RotationQuadrant, RsiForm, SessionChart, StochasticChart, StochasticForm, TpoBracket, TpoForm, TpoGrouping, TpoProfile, TpoStacking, VolatilitySurface, VolatilitySurfaceForm, VolumeBars, VolumeBucket, VolumeLayout, VolumeMark, VolumeMeasure, VolumeProfile, YieldCurve, YieldMode, financialCatalog };

package/dist/charts/flow/index.js

@@ -5,7 +5,6 @@ import { FlowGraph } from "./FlowGraph.js";
 import { FlowChart, FlowGraphChart } from "./FlowChart.js";
 import { StratumAxisOrder, StratumChart, StratumThreading } from "./StratumChart.js";
 import { AlluvialChart } from "./AlluvialChart.js";
-import { BumpFlow, BumpLeader, BumpMark, BumpSpacing } from "./BumpFlow.js";
 import { ChordDirection, ChordFlow, ChordHead, ChordLayout } from "./ChordFlow.js";
 import { CircularColumn, CircularCorner, CircularLoopSide, CircularSankey } from "./CircularSankey.js";
 import { CohortAlignment, CohortFlow, CohortForm, CohortMeasure, CohortStack } from "./CohortFlow.js";
@@ -24,7 +23,6 @@ import { RetentionExit, RetentionFlow, RetentionScale } from "./RetentionFlow.js
 import { RibbonFlow, RibbonScale } from "./RibbonFlow.js";
 import { SankeyAlign, SankeyChart } from "./SankeyChart.js";
 import { StateEdge, StateLayout, StateMark, StateTransitionChart, StateWeight } from "./StateTransitionChart.js";
-import { StreamFlow, StreamOffset, StreamOrder } from "./StreamFlow.js";
 import { SwimFlowChart, SwimHeader, SwimLaneOrder, SwimSpacing } from "./SwimFlowChart.js";
 // src/charts/flow/index.ts
 var flowCatalog = [
@@ -32,7 +30,6 @@ var flowCatalog = [
 	AlluvialChart,
 	ChordFlow,
 	ParallelSets,
-	StreamFlow,
 	FlowMapLess,
 	CircularSankey,
 	RibbonFlow,
@@ -41,11 +38,10 @@ var flowCatalog = [
 	DecisionTreeChart,
 	StateTransitionChart,
 	SwimFlowChart,
-	BumpFlow,
 	CohortFlow,
 	RetentionFlow,
 	ConversionFlow,
 	NetworkFlowChart,
 	EnergyBalanceChart
 ];
-export { AlluvialChart, BumpFlow, BumpLeader, BumpMark, BumpSpacing, ChordDirection, ChordFlow, ChordHead, ChordLayout, CircularColumn, CircularCorner, CircularLoopSide, CircularSankey, CohortAlignment, CohortFlow, CohortForm, CohortMeasure, CohortStack, ConversionAlign, ConversionFlow, ConversionShape, DecisionLayout, DecisionLinkWidth, DecisionNode, DecisionTreeChart, EnergyBalanceChart, EnergyBranch, EnergyLossSide, EnergyTip, FlowBaseline, FlowChart, FlowDirection, FlowGeometry, FlowGraph, FlowGraphChart, FlowMapLess, FlowNodeMark, FlowNodeShape, FlowPaint, FlowRibbon, FlowRouter, FlowSort, FlowTable, LayeredLayout, MapLessArc, MapLessBend, MapLessLayout, MapLessMeasure, MarimekkoFlow, MaxFlow, MekkoConnector, MekkoSeriesOrder, NetworkFlowChart, NetworkFlowEncoding, NodeLinkChart, ParallelSets, ProcessDensity, ProcessFlowChart, ProcessNodeStyle, RetentionExit, RetentionFlow, RetentionScale, RibbonFlow, RibbonScale, SankeyAlign, SankeyChart, StateEdge, StateLayout, StateMark, StateTransitionChart, StateWeight, StratumAxisOrder, StratumChart, StratumThreading, StreamFlow, StreamOffset, StreamOrder, SwimFlowChart, SwimHeader, SwimLaneOrder, SwimSpacing, TreeGrowth, flowCatalog };
+export { AlluvialChart, ChordDirection, ChordFlow, ChordHead, ChordLayout, CircularColumn, CircularCorner, CircularLoopSide, CircularSankey, CohortAlignment, CohortFlow, CohortForm, CohortMeasure, CohortStack, ConversionAlign, ConversionFlow, ConversionShape, DecisionLayout, DecisionLinkWidth, DecisionNode, DecisionTreeChart, EnergyBalanceChart, EnergyBranch, EnergyLossSide, EnergyTip, FlowBaseline, FlowChart, FlowDirection, FlowGeometry, FlowGraph, FlowGraphChart, FlowMapLess, FlowNodeMark, FlowNodeShape, FlowPaint, FlowRibbon, FlowRouter, FlowSort, FlowTable, LayeredLayout, MapLessArc, MapLessBend, MapLessLayout, MapLessMeasure, MarimekkoFlow, MaxFlow, MekkoConnector, MekkoSeriesOrder, NetworkFlowChart, NetworkFlowEncoding, NodeLinkChart, ParallelSets, ProcessDensity, ProcessFlowChart, ProcessNodeStyle, RetentionExit, RetentionFlow, RetentionScale, RibbonFlow, RibbonScale, SankeyAlign, SankeyChart, StateEdge, StateLayout, StateMark, StateTransitionChart, StateWeight, StratumAxisOrder, StratumChart, StratumThreading, SwimFlowChart, SwimHeader, SwimLaneOrder, SwimSpacing, TreeGrowth, flowCatalog };